@wenathlan/saddle 2.0.151 → 2.0.152

package/dist/Sol/wingets/DashboardGlobalsandboxestable.d.ts

@@ -0,0 +1,8 @@
+type GlobalSandboxesTableProps = {
+    /** "api" lists /api/v1/admin/sandboxes; "local" shows the static note. */
+    mode: 'api' | 'local';
+    /** bumped by the admin refresh-all action. */
+    reloadkey: number;
+};
+export default function GlobalSandboxesTable({ mode, reloadkey }: GlobalSandboxesTableProps): import("react").JSX.Element;
+export {};

package/dist/Sol/wingets/DashboardGlobalsandboxestable.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Signal & Ledger: the global sandbox table absorbed from dashboard.js —
+// db rows (flat or enveloped) for the main node admin; on the static
+// edge, the honest note pointing to the user view.
+import { useEffect, useState } from 'react';
+import { apiresult, asarray, chipclass, fmtdate, pick } from '../../dashboardlib.ts';
+import { label, labelfill } from '../../labels.ts';
+export default function GlobalSandboxesTable({ mode, reloadkey }) {
+    const [items, setitems] = useState([]);
+    const [error, seterror] = useState('');
+    useEffect(() => {
+        if (mode !== 'api') {
+            return undefined;
+        }
+        let stopped = false;
+        (async () => {
+            try {
+                const result = await apiresult('/api/v1/admin/sandboxes');
+                if (stopped) {
+                    return;
+                }
+                if (!result.ok) {
+                    seterror(labelfill('dashboard.global.unavailable', { status: String(result.status) }));
+                    return;
+                }
+                seterror('');
+                setitems(asarray(result.body, ['sandboxes', 'items', 'data', 'list']));
+            }
+            catch {
+                if (!stopped) {
+                    seterror(label('dashboard.global.unreachable'));
+                }
+            }
+        })();
+        return () => {
+            stopped = true;
+        };
+    }, [mode, reloadkey]);
+    if (mode === 'local') {
+        return _jsx("p", { className: "dash-empty", children: label('dashboard.global.localNote') });
+    }
+    return (_jsxs("div", { children: [_jsx("div", { className: "dash-tablescroll", 
+                // biome-ignore lint/a11y/noNoninteractiveTabindex: deliberate wcag scrollable-region pattern: the tabIndex keeps the overflowing table keyboard-scrollable; the rows are display data and the interactive cells (none here) use real buttons
+                tabIndex: 0, role: "region", "aria-label": label('dashboard.global.tableAria'), children: _jsxs("table", { children: [items.length === 0 && error === '' && (_jsx("caption", { className: "dash-empty", children: label('dashboard.global.empty') })), _jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { scope: "col", children: label('dashboard.global.colId') }), _jsx("th", { scope: "col", children: label('dashboard.global.colOwner') }), _jsx("th", { scope: "col", children: label('dashboard.global.colState') }), _jsx("th", { scope: "col", children: label('dashboard.global.colSpec') }), _jsx("th", { scope: "col", children: label('dashboard.global.colCreated') }), _jsx("th", { scope: "col", children: label('dashboard.global.colExpires') })] }) }), _jsx("tbody", { children: items.map((record) => {
+                                /* admin rows may be flat db rows or enveloped public views */
+                                const specobj = pick(record, ['spec'], null);
+                                const spec = specobj !== null && typeof specobj === 'object' ? specobj : record;
+                                const owner = pick(record, ['owner', 'username', 'user', 'ownerUsername', 'userid', 'user_id'], '-');
+                                const id = String(pick(record, ['id'], '?'));
+                                return (_jsxs("tr", { children: [_jsx("td", { className: "wrapcell", children: id }), _jsx("td", { children: String(owner) }), _jsx("td", { children: _jsx("span", { className: chipclass(pick(record, ['state'], '?')), children: String(pick(record, ['state'], '?')) }) }), _jsx("td", { className: "wrapcell", children: [
+                                                String(pick(spec, ['model'], '?')),
+                                                `x${String(pick(spec, ['vcpus'], '?'))}`,
+                                                `${String(pick(spec, ['ramgb', 'ramGb', 'ram'], '?'))}gb`,
+                                                String(pick(spec, ['gpu'], '?')),
+                                            ].join(' ') }), _jsx("td", { children: fmtdate(pick(record, ['createdAt', 'createdat', 'created_at'], null)) }), _jsx("td", { children: fmtdate(pick(record, ['expiresAt', 'expiresat', 'expires_at'], null)) })] }, `${id}|${String(owner)}`));
+                            }) })] }) }), error !== '' && _jsx("p", { className: "dash-panelerror", children: error })] }));
+}

package/dist/Sol/wingets/DashboardMeshnodestable.d.ts

@@ -0,0 +1,8 @@
+type MeshNodesTableProps = {
+    /** "api" lists /api/v1/admin/nodes; "local" renders the browser row. */
+    mode: 'api' | 'local';
+    /** bumped by the admin refresh-all action. */
+    reloadkey: number;
+};
+export default function MeshNodesTable({ mode, reloadkey }: MeshNodesTableProps): import("react").JSX.Element;
+export {};

package/dist/Sol/wingets/DashboardMeshnodestable.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Signal & Ledger: the mesh nodes table absorbed from dashboard.js —
+// ping through the signed /api/v1/mesh/ping route with fallback to the
+// browser latency probe; on the static edge, the "this browser" row.
+import { useEffect, useState } from 'react';
+import { apiresult, asarray, chipclass, fmtdate, pick } from '../../dashboardlib.ts';
+import { label, labelfill } from '../../labels.ts';
+/**
+ * pings one mesh node: the primary contract posts /api/v1/mesh/ping (the
+ * server-side signed mesh); when the node does not expose it the browser
+ * falls back to a latency probe of the node health endpoint.
+ */
+async function meshping(url) {
+    try {
+        const post = await apiresult('/api/v1/mesh/ping', {
+            method: 'POST',
+            body: JSON.stringify({ url }),
+        });
+        if (post.ok) {
+            const rtt = pick(post.body, ['rttMs', 'rtt', 'latencyMs', 'latency'], null);
+            return rtt !== null
+                ? labelfill('dashboard.mesh.pongMesh', { rtt: String(rtt) })
+                : label('dashboard.mesh.pongMeshPlain');
+        }
+    }
+    catch {
+        /* fall through to the client probe */
+    }
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort();
+        }, 4000);
+        const started = performance.now();
+        await fetch(`${String(url).replace(/\/+$/, '')}/api/v1/health`, {
+            mode: 'no-cors',
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        return labelfill('dashboard.mesh.pongProbe', {
+            ms: String(Math.max(1, Math.round(performance.now() - started))),
+        });
+    }
+    catch {
+        return label('dashboard.mesh.unreachable');
+    }
+}
+export default function MeshNodesTable({ mode, reloadkey }) {
+    const [nodes, setnodes] = useState([]);
+    const [error, seterror] = useState('');
+    const [pings, setpings] = useState({});
+    useEffect(() => {
+        if (mode !== 'api') {
+            return undefined;
+        }
+        let stopped = false;
+        (async () => {
+            try {
+                const result = await apiresult('/api/v1/admin/nodes');
+                if (stopped) {
+                    return;
+                }
+                if (!result.ok) {
+                    setnodes([]);
+                    seterror(labelfill('dashboard.mesh.nodeUnavailable', { status: String(result.status) }));
+                    return;
+                }
+                seterror('');
+                setnodes(asarray(result.body, ['nodes', 'items', 'data', 'list']));
+            }
+            catch {
+                if (!stopped) {
+                    seterror(label('dashboard.mesh.nodesUnreachable'));
+                }
+            }
+        })();
+        return () => {
+            stopped = true;
+        };
+    }, [mode, reloadkey]);
+    /** runs one ping and paints the result cell beside the button. */
+    function runping(url) {
+        setpings((previous) => ({
+            ...previous,
+            [url]: { busy: true, result: label('dashboard.mesh.pinging') },
+        }));
+        void meshping(url).then((result) => {
+            setpings((previous) => ({ ...previous, [url]: { busy: false, result } }));
+        });
+    }
+    return (_jsxs("div", { children: [_jsx("p", { className: "dash-statusnote", children: label('dashboard.mesh.pollNote') }), _jsx("div", { className: "dash-tablescroll", 
+                // biome-ignore lint/a11y/noNoninteractiveTabindex: deliberate wcag scrollable-region pattern: the tabIndex keeps the overflowing table keyboard-scrollable; the interactive cells are real buttons, the region itself only scrolls
+                tabIndex: 0, role: "region", "aria-label": label('dashboard.mesh.tableAria'), children: _jsxs("table", { children: [mode === 'api' && nodes.length === 0 && error === '' && (_jsx("caption", { className: "dash-empty", children: label('dashboard.mesh.empty') })), _jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { scope: "col", children: label('dashboard.mesh.colUrl') }), _jsx("th", { scope: "col", children: label('dashboard.mesh.colRegion') }), _jsx("th", { scope: "col", children: label('dashboard.mesh.colStatus') }), _jsx("th", { scope: "col", children: label('dashboard.mesh.colHeartbeat') }), _jsx("th", { scope: "col", children: label('dashboard.mesh.colPing') })] }) }), _jsx("tbody", { children: mode === 'local' ? (_jsxs("tr", { children: [_jsx("td", { children: label('dashboard.mesh.localNode') }), _jsx("td", { children: label('dashboard.mesh.localRegion') }), _jsx("td", { children: label('dashboard.mesh.localStatus') }), _jsx("td", { children: label('dashboard.mesh.na') })] })) : (nodes.map((node) => {
+                                const url = String(pick(node, ['url', 'endpoint', 'address', 'host'], '?'));
+                                const region = String(pick(node, ['region', 'location', 'zone'], '-'));
+                                const status = String(pick(node, ['status', 'state'], '?'));
+                                const heartbeat = pick(node, ['lastHeartbeat', 'lastHeartbeatAt', 'lastSeen', 'last_heartbeat'], null);
+                                const pingstate = pings[url];
+                                return (_jsxs("tr", { children: [_jsx("td", { className: "wrapcell", children: url }), _jsx("td", { children: region }), _jsx("td", { children: _jsx("span", { className: chipclass(status), children: status }) }), _jsx("td", { children: fmtdate(heartbeat) }), _jsxs("td", { children: [_jsx("button", { type: "button", className: "dash-btn mini", "aria-label": labelfill('dashboard.mesh.pingAria', { url }), "aria-busy": pingstate?.busy === true ? 'true' : undefined, disabled: pingstate?.busy === true, onClick: () => {
+                                                        runping(url);
+                                                    }, children: label('dashboard.mesh.ping') }), ' ', _jsx("span", { className: "wrapcell", role: "status", "aria-live": "polite", children: pingstate === undefined ? label('dashboard.mesh.nopong') : pingstate.result })] })] }, url));
+                            })) })] }) }), error !== '' && _jsx("p", { className: "dash-panelerror", children: error })] }));
+}

package/dist/Sol/wingets/DashboardSandboxlist.d.ts

@@ -0,0 +1,10 @@
+type SandboxListProps = {
+    /** "api" polls the shelf endpoint; "local" renders the sessionStorage shelf. */
+    mode: 'api' | 'local';
+    /** bumped by the orchestrator to force a skeleton reload. */
+    reloadkey: number;
+    /** false while the session bootstrap runs (avoids a premature 401). */
+    ready: boolean;
+};
+export default function SandboxList({ mode, reloadkey, ready }: SandboxListProps): import("react").JSX.Element;
+export {};

package/dist/Sol/wingets/DashboardSandboxlist.js

@@ -0,0 +1,163 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Signal & Ledger: the sandbox list absorbed from dashboard.js — state
+// chips, skeletons, 30 s refresh, open/delete actions (api) and stop
+// (browser-local engine).
+import { useCallback, useEffect, useState } from 'react';
+import { Link } from 'wouter';
+import { apiresult, asarray, chipclass, errormessage, fmtdate, pick, readlocalsandboxes, writelocalsandboxes, } from '../../dashboardlib.ts';
+import { label, labelfill } from '../../labels.ts';
+/** truncates one sandbox id for display (the full id stays in the links). */
+function shortid(id) {
+    return id.slice(0, 13) + (id.length > 13 ? '...' : '');
+}
+export default function SandboxList({ mode, reloadkey, ready }) {
+    const [loading, setloading] = useState(true);
+    const [items, setitems] = useState([]);
+    const [error, seterror] = useState('');
+    const [notlive, setnotlive] = useState(false);
+    const [deleting, setdeleting] = useState(null);
+    const [locals, setlocals] = useState([]);
+    /** loads the authenticated user's shelf exactly like the original page. */
+    const load = useCallback(async (showskeleton) => {
+        if (showskeleton) {
+            setloading(true);
+            setitems([]);
+        }
+        let result;
+        try {
+            result = await apiresult('/api/v1/sandboxes');
+        }
+        catch {
+            setloading(false);
+            seterror(label('dashboard.list.unreachable'));
+            return;
+        }
+        if (result.status === 401 || result.status === 403) {
+            setloading(false);
+            seterror(label('dashboard.list.sessionExpired'));
+            return;
+        }
+        setloading(false);
+        seterror('');
+        if (result.status === 404) {
+            /* the list endpoint is not live on this node yet (v7 rollout) */
+            setitems([]);
+            setnotlive(true);
+            return;
+        }
+        setnotlive(false);
+        const rows = asarray(result.body, ['sandboxes', 'items', 'data', 'list']);
+        setitems(rows);
+    }, []);
+    useEffect(() => {
+        if (!ready) {
+            return undefined;
+        }
+        if (mode === 'local') {
+            setloading(false);
+            seterror('');
+            setlocals(readlocalsandboxes());
+            return;
+        }
+        void load(true);
+    }, [mode, reloadkey, ready, load]);
+    /* the 30 s shelf poll: only while the tab is visible (api mode). */
+    useEffect(() => {
+        if (mode !== 'api' || !ready) {
+            return undefined;
+        }
+        const timer = setInterval(() => {
+            if (document.visibilityState !== 'visible') {
+                return;
+            }
+            void load(false);
+        }, 30000);
+        return () => clearInterval(timer);
+    }, [mode, ready, load]);
+    /** deletes one sandbox (the manual purge of the shelf contract). */
+    async function destroy(id) {
+        setdeleting(id);
+        try {
+            const result = await apiresult(`/api/v1/sandboxes/${encodeURIComponent(id)}`, {
+                method: 'DELETE',
+            });
+            if (result.ok) {
+                await load(true);
+            }
+            else {
+                seterror(errormessage(result, labelfill('dashboard.list.deleteFailed', { status: String(result.status) })));
+            }
+        }
+        catch {
+            seterror(label('dashboard.list.deleteUnreachable'));
+        }
+        setdeleting(null);
+    }
+    /** stops one browser-local sandbox (removes it from the shelf). */
+    function stop(id) {
+        const remaining = readlocalsandboxes().filter((entry) => entry.id !== id);
+        writelocalsandboxes(remaining);
+        setlocals(remaining);
+    }
+    const emptyvisible = !loading && error === '' && (mode === 'local' ? locals.length === 0 : items.length === 0);
+    const listvisible = mode === 'local' ? locals.length > 0 : items.length > 0 && !loading;
+    return (_jsxs("div", { children: [_jsx("h3", { children: label('dashboard.list.title') }), loading && (_jsxs("div", { "aria-hidden": "true", children: [_jsx("div", { className: "dash-skeleton" }), _jsx("div", { className: "dash-skeleton", style: { width: '88%' } }), _jsx("div", { className: "dash-skeleton", style: { width: '70%' } })] })), listvisible && (_jsx("ul", { className: "dash-boxlist", "aria-live": "polite", "aria-label": label('dashboard.list.aria'), children: mode === 'local'
+                    ? locals.map((record) => {
+                        const spectext = [
+                            record.spec.model,
+                            labelfill('dashboard.list.specVcpus', {
+                                vcpus: String(record.spec.vcpus),
+                            }),
+                            labelfill('dashboard.list.specRam', { ram: String(record.spec.ramgb) }),
+                            record.spec.gpu,
+                            record.spec.mig && record.spec.mig !== 'off'
+                                ? labelfill('dashboard.list.specMig', { mig: record.spec.mig })
+                                : '',
+                        ]
+                            .filter(Boolean)
+                            .join(' / ');
+                        return (_jsxs("li", { children: [_jsxs("div", { className: "rowtop", children: [_jsx("span", { className: "id", children: shortid(record.id) }), _jsx("span", { className: chipclass(record.state ?? 'created'), children: record.state ?? 'created' }), _jsx("span", { className: "rowactions", children: _jsx("button", { type: "button", className: "danger mini", "aria-label": labelfill('dashboard.list.stopAria', { id: record.id }), onClick: () => stop(record.id), children: label('dashboard.list.stop') }) })] }), _jsx("span", { className: "specs", children: spectext }), _jsx("span", { className: "meta", children: labelfill('dashboard.list.metaCreated', {
+                                        date: fmtdate(record.createdat),
+                                    }) })] }, record.id));
+                    })
+                    : items.map((record) => {
+                        const id = String(pick(record, ['id'], ''));
+                        const state = String(pick(record, ['state'], '?'));
+                        const specobj = pick(record, ['spec'], null);
+                        const spec = specobj !== null && typeof specobj === 'object' ? specobj : record;
+                        const spectext = [
+                            String(pick(spec, ['model'], '?')),
+                            labelfill('dashboard.list.specVcpus', {
+                                vcpus: String(pick(spec, ['vcpus'], '?')),
+                            }),
+                            labelfill('dashboard.list.specRam', {
+                                ram: String(pick(spec, ['ramgb', 'ramGb', 'ram'], '?')),
+                            }),
+                            String(pick(spec, ['gpu'], '?')),
+                            labelfill('dashboard.list.specMig', {
+                                mig: String(pick(spec, ['mig'], 'off')),
+                            }),
+                        ].join(' / ');
+                        const files = pick(record, ['files'], null);
+                        const metafrags = [
+                            labelfill('dashboard.list.metaCreated', {
+                                date: fmtdate(pick(record, ['createdAt', 'createdat', 'created_at'], null)),
+                            }),
+                            labelfill('dashboard.list.metaExpires', {
+                                date: fmtdate(pick(record, ['expiresAt', 'expiresat', 'expires_at'], null)),
+                            }),
+                            labelfill('dashboard.list.metaExecs', {
+                                count: String(pick(record, ['execCount', 'execcount'], 0)),
+                            }),
+                        ];
+                        if (files !== null && files !== undefined) {
+                            metafrags.push(labelfill('dashboard.list.metaFiles', { count: String(files) }));
+                        }
+                        const meta = metafrags.join(' / ');
+                        return (_jsxs("li", { children: [_jsxs("div", { className: "rowtop", children: [_jsx("span", { className: "id", children: shortid(id) }), _jsx("span", { className: chipclass(state), children: state }), _jsxs("span", { className: "rowactions", children: [_jsx(Link, { className: "dash-btn mini", href: `/console?sandbox=${encodeURIComponent(id)}`, "aria-label": labelfill('dashboard.list.openAria', { id }), children: label('dashboard.list.open') }), _jsx("button", { type: "button", className: "danger mini", "aria-label": labelfill('dashboard.list.deleteAria', { id }), disabled: deleting === id, onClick: () => {
+                                                        void destroy(id);
+                                                    }, children: label('dashboard.list.delete') })] })] }), _jsx("span", { className: "specs", children: spectext }), _jsx("span", { className: "meta", children: meta })] }, id));
+                    }) })), emptyvisible && (_jsxs("p", { className: "dash-empty", children: [notlive
+                        ? label('dashboard.list.emptyNotLive')
+                        : label('dashboard.list.empty'), !notlive && _jsx(Link, { href: "/console", children: label('dashboard.list.consoleLink') }), !notlive && label('dashboard.list.emptyPeriod')] })), error !== '' && _jsx("p", { className: "dash-panelerror", children: error })] }));
+}

package/dist/Sol/wingets/DashboardUserstable.d.ts

@@ -0,0 +1,8 @@
+type UsersTableProps = {
+    /** "api" lists /api/v1/admin/users; "local" the browser account registry. */
+    mode: 'api' | 'local';
+    /** bumped by the admin refresh-all action. */
+    reloadkey: number;
+};
+export default function UsersTable({ mode, reloadkey }: UsersTableProps): import("react").JSX.Element;
+export {};

package/dist/Sol/wingets/DashboardUserstable.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Signal & Ledger: the users table absorbed from dashboard.js — client-side
+// search by username, account fields only (hash and salt never leave the
+// api); on the static edge, the browser-local registry.
+import { useEffect, useState } from 'react';
+import { apiresult, asarray, chipclass, fmtdate, pick } from '../../dashboardlib.ts';
+import { label, labelfill } from '../../labels.ts';
+import { available, roleof } from '../../localauth.ts';
+/** reads the local account names (defensive; the api mode never lands here). */
+function localaccountnames() {
+    try {
+        const raw = window.localStorage.getItem('saddle_local_users');
+        const parsed = raw ? JSON.parse(raw) : {};
+        if (parsed !== null && typeof parsed === 'object') {
+            return Object.keys(parsed);
+        }
+    }
+    catch {
+        /* no registry or unreadable storage: the empty table applies */
+    }
+    return [];
+}
+export default function UsersTable({ mode, reloadkey }) {
+    const [users, setusers] = useState([]);
+    const [error, seterror] = useState('');
+    const [query, setquery] = useState('');
+    useEffect(() => {
+        if (mode === 'local') {
+            seterror('');
+            setusers(available() ? localaccountnames() : []);
+            return;
+        }
+        let stopped = false;
+        (async () => {
+            try {
+                const result = await apiresult('/api/v1/admin/users');
+                if (stopped) {
+                    return;
+                }
+                if (!result.ok) {
+                    seterror(labelfill('dashboard.users.unavailable', { status: String(result.status) }));
+                    return;
+                }
+                seterror('');
+                setusers(asarray(result.body, ['users', 'items', 'data', 'list']));
+            }
+            catch {
+                if (!stopped) {
+                    seterror(label('dashboard.users.unreachable'));
+                }
+            }
+        })();
+        return () => {
+            stopped = true;
+        };
+    }, [mode, reloadkey]);
+    const needle = query.trim().toLowerCase();
+    const rows = users.filter((user) => {
+        const username = mode === 'local' ? String(user) : String(pick(user, ['username', 'name', 'user'], ''));
+        return needle === '' || username.toLowerCase().includes(needle);
+    });
+    return (_jsxs("div", { children: [_jsxs("div", { className: "dash-field", style: { maxWidth: '340px' }, children: [_jsx("label", { htmlFor: "usersearch", children: label('dashboard.users.searchLabel') }), _jsx("input", { type: "search", id: "usersearch", placeholder: label('dashboard.users.searchPlaceholder'), "aria-label": label('dashboard.users.searchAria'), value: query, onChange: (event) => {
+                            setquery(event.target.value);
+                        } })] }), _jsx("div", { className: "dash-tablescroll", 
+                // biome-ignore lint/a11y/noNoninteractiveTabindex: deliberate wcag scrollable-region pattern: the tabIndex keeps the overflowing table keyboard-scrollable; the rows are display data and the interactive cells (none here) use real buttons
+                tabIndex: 0, role: "region", "aria-label": label('dashboard.users.tableAria'), children: _jsxs("table", { children: [rows.length === 0 && error === '' && (_jsx("caption", { className: "dash-empty", children: needle === ''
+                                ? mode === 'local'
+                                    ? label('dashboard.users.emptyLocal')
+                                    : label('dashboard.users.empty')
+                                : labelfill('dashboard.users.noMatch', { needle }) })), _jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { scope: "col", children: label('dashboard.users.colUsername') }), _jsx("th", { scope: "col", children: label('dashboard.users.colRole') }), _jsx("th", { scope: "col", children: label('dashboard.users.colLastLogin') }), _jsx("th", { scope: "col", children: label('dashboard.users.colCreated') })] }) }), _jsx("tbody", { children: mode === 'local'
+                                ? rows.map((name) => (_jsxs("tr", { children: [_jsx("td", { children: String(name) }), _jsx("td", { children: roleof(String(name)) }), _jsx("td", { children: label('dashboard.users.localCell') })] }, String(name))))
+                                : rows.map((user) => {
+                                    const username = String(pick(user, ['username', 'name', 'user'], '?'));
+                                    const role = String(pick(user, ['role'], 'user'));
+                                    /* account fields only: hash and salt keys are ignored */
+                                    return (_jsxs("tr", { children: [_jsx("td", { children: username }), _jsx("td", { children: _jsx("span", { className: chipclass(role), children: role }) }), _jsx("td", { children: fmtdate(pick(user, ['lastLoginAt', 'last_login_at', 'lastlogin'], null)) }), _jsx("td", { children: fmtdate(pick(user, ['createdAt', 'created_at', 'createdat'], null)) })] }, username));
+                                }) })] }) }), mode !== 'local' && (_jsx("p", { className: "dash-statusnote", children: label('dashboard.users.hashesNote') })), error !== '' && _jsx("p", { className: "dash-panelerror", children: error })] }));
+}

package/dist/Sol/wingets/HomeEntrygate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * entrygate.tsx — the entry gate of the application (the flow law: intro →
+ * onboarding → the platform). The home anchor mounts it on the "/" route:
+ * the synchronous first verdict answers from the offline layer (the cache
+ * mirror) so a returning visitor never flashes, and while the state is
+ * still unknown the gate renders null — the stage never shows behind the
+ * gate. An unseen intro replaces the route with /intro; an unseen
+ * onboarding replaces it with /onboarding; only a visitor that finished the
+ * flow ever sees the home. The gate only reads — marking the stages seen
+ * belongs to the pages that show them (onboardingstate.ts is the one
+ * writer).
+ */
+import { type ReactNode } from 'react';
+/**
+ * The entry gate wrapping the platform home.
+ *
+ * @param children the home surface revealed when the flow is through.
+ * @returns the gated element.
+ */
+export declare function EntryGate({ children }: {
+    children: ReactNode;
+}): ReactNode;
+export default EntryGate;

package/dist/Sol/wingets/HomeEntrygate.js

@@ -0,0 +1,73 @@
+/**
+ * entrygate.tsx — the entry gate of the application (the flow law: intro →
+ * onboarding → the platform). The home anchor mounts it on the "/" route:
+ * the synchronous first verdict answers from the offline layer (the cache
+ * mirror) so a returning visitor never flashes, and while the state is
+ * still unknown the gate renders null — the stage never shows behind the
+ * gate. An unseen intro replaces the route with /intro; an unseen
+ * onboarding replaces it with /onboarding; only a visitor that finished the
+ * flow ever sees the home. The gate only reads — marking the stages seen
+ * belongs to the pages that show them (onboardingstate.ts is the one
+ * writer).
+ */
+import { useEffect, useState } from 'react';
+import { useLocation } from 'wouter';
+import { loadOnboardingState, readOnboardingState, } from '../../onboardingstate.ts';
+/**
+ * Reads the gate verdict from a seen-state snapshot (the flow order: intro
+ * first, then onboarding, then the home).
+ *
+ * @param state the resolved flags.
+ * @returns true when the visitor finished the flow.
+ */
+function flowthrough(state) {
+    return state.introseen && state.onboardingseen;
+}
+/**
+ * The entry gate wrapping the platform home.
+ *
+ * @param children the home surface revealed when the flow is through.
+ * @returns the gated element.
+ */
+export function EntryGate({ children }) {
+    // the embedded pass is the bare stage: inside the os window the first-run
+    // flow belongs to the shell, so the frame lands straight home — the frame
+    // of a mount never changes, the hooks stay unconditional for the lint
+    const embedded = typeof window !== 'undefined' && window.self !== window.top;
+    const [, navigate] = useLocation();
+    const [phase, setPhase] = useState(() => {
+        if (embedded)
+            return 'through';
+        const known = readOnboardingState();
+        return known !== null && flowthrough(known) ? 'through' : 'resolving';
+    });
+    useEffect(() => {
+        if (embedded)
+            return;
+        // the fast path: the cache already knows a missing stage — replace at once
+        const known = readOnboardingState();
+        if (known && !flowthrough(known)) {
+            if (!known.introseen)
+                navigate('/intro', { replace: true });
+            else
+                navigate('/onboarding', { replace: true });
+            return;
+        }
+        let live = true;
+        loadOnboardingState().then((state) => {
+            if (!live)
+                return;
+            if (!state.introseen)
+                navigate('/intro', { replace: true });
+            else if (!state.onboardingseen)
+                navigate('/onboarding', { replace: true });
+            else
+                setPhase('through');
+        });
+        return () => {
+            live = false;
+        };
+    }, [embedded, navigate]);
+    return phase === 'through' ? children : null;
+}
+export default EntryGate;

package/dist/Sol/wingets/HomeMetricstrip.d.ts

@@ -0,0 +1,9 @@
+type Metric = {
+    value: string;
+    label: string;
+    detail: string;
+};
+export default function MetricStrip({ metrics }: {
+    metrics: Metric[];
+}): import("react").JSX.Element;
+export {};

package/dist/Sol/wingets/HomeMetricstrip.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export default function MetricStrip({ metrics }) {
+    return (_jsx("div", { className: "metric-strip", children: metrics.map((metric) => (_jsxs("div", { className: "metric", children: [_jsx("span", { className: "metric-value", children: metric.value }), _jsx("span", { className: "metric-label", children: metric.label }), _jsx("span", { className: "metric-detail", children: metric.detail })] }, metric.label))) }));
+}

package/dist/Sol/wingets/HomeRuntimediagram.d.ts

@@ -0,0 +1 @@
+export default function RuntimeDiagram(): import("react").JSX.Element;

package/dist/Sol/wingets/HomeRuntimediagram.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Signal & Ledger: the runtime chain of repo, runner and pages as one
+// execution model. Page-owned copy of the runtime diagram: lives inside the
+// home folder that renders it. The topline states the chain it draws — no
+// boot timer, no live indicator: the diagram is the model, never a claim
+// that a runner is running. the copy rides the label store (labels.ts).
+import { ArrowRightRegular as ArrowRight, DatabaseRegular as Database, BranchForkRegular as GitBranch, GlobeRegular as Globe2, ServerRegular as Server, } from '@fluentui/react-icons';
+import { label } from '../../labels.ts';
+/** the four nodes of the chain: the icon and the tone stay data, the words
+ * ride the store. */
+const nodes = [
+    { icon: GitBranch, labelkey: 'home.diagram.repo', detailkey: 'home.diagram.repoDetail', tone: 'ink' },
+    { icon: Server, labelkey: 'home.diagram.runner', detailkey: 'home.diagram.runnerDetail', tone: 'ember' },
+    { icon: Database, labelkey: 'home.diagram.memory', detailkey: 'home.diagram.memoryDetail', tone: 'blue' },
+    { icon: Globe2, labelkey: 'home.diagram.surface', detailkey: 'home.diagram.surfaceDetail', tone: 'sage' },
+];
+export default function RuntimeDiagram() {
+    return (_jsxs("div", { className: "runtime-diagram", role: "group", "aria-label": label('home.diagram.aria'), children: [_jsxs("div", { className: "diagram-topline", children: [_jsx("span", { children: label('home.diagram.topline') }), _jsx("span", { children: label('home.diagram.chain') })] }), _jsx("div", { className: "diagram-nodes", children: nodes.map((node, index) => {
+                    const Icon = node.icon;
+                    return (_jsxs("div", { className: "diagram-node-wrap", children: [_jsxs("div", { className: `diagram-node tone-${node.tone}`, children: [_jsx(Icon, { fontSize: 19, strokeWidth: 1.7 }), _jsxs("div", { children: [_jsx("strong", { children: label(node.labelkey) }), _jsx("small", { children: label(node.detailkey) })] })] }), index < nodes.length - 1 && _jsx(ArrowRight, { className: "diagram-arrow", fontSize: 18 })] }, label(node.labelkey)));
+                }) }), _jsxs("div", { className: "diagram-footer", children: [_jsxs("span", { children: [label('home.diagram.usageFlag'), _jsx("b", { children: label('home.diagram.usageFlagValue') })] }), _jsxs("span", { children: [label('home.diagram.latencyBudget'), _jsx("b", { children: label('home.diagram.latencyBudgetValue') })] })] })] }));
+}

package/dist/Sol/wingets/LoginForm.d.ts

@@ -0,0 +1,19 @@
+/**
+ * only same-origin page-relative targets are honored; absolute urls,
+ * protocol relative (//host), backslash (\host), scheme (javascript:,
+ * data:), control characters and path traversal are all rejected.
+ * targets stay page-relative (no leading slash) so the redirect works
+ * both on the self-hosted node (/, /login) and inside sub-path static
+ * hosting such as github pages (/saddle/login). the redirect target
+ * never depends on an unvalidated user value. legacy ".html" suffixes
+ * from the absorbed static pages map to the spa route of the same name.
+ *
+ * @returns the sanitized page-relative target.
+ */
+export declare function safenext(): string;
+/**
+ * the sign-in form: username + password only, generic error messages on
+ * purpose (no user enumeration, no cause leak), aria-invalid feedback and
+ * loading states while the submission is in flight.
+ */
+export default function LoginForm(): import("react").JSX.Element;