@wenathlan/saddle 2.0.150 → 2.0.152

package/dist/Sol/compute/compute.d.ts

@@ -0,0 +1,9 @@
+/**
+ * compute page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ */
+export default function Compute(): import("react").JSX.Element;

package/dist/Sol/compute/compute.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * compute page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ */
+// Signal & Ledger: the compute face — the engine presents itself honestly.
+// The page mounts the two api surfaces (the boot ladder and the modality
+// catalog) and carries no provider table of its own: every row the visitor
+// reads is served by the saddle engine through the internal api — the
+// fixed provider and state arrays died with the old page. Every word the
+// page itself speaks rides the label store (labels.ts — the copy law).
+import { BoxRegular as Box } from "@fluentui/react-icons";
+import { PageShell } from "../shell/Shell.tsx";
+import { label } from "../../labels.ts";
+import { ComputeBootladder, ComputeModalitycatalog } from "../wingets";
+export default function Compute() {
+    return (_jsxs(PageShell, { section: label("compute.shell.section"), label: label("compute.shell.label"), title: label("compute.shell.title"), intro: label("compute.shell.intro"), children: [_jsxs("section", { className: "content-section split-content", children: [_jsxs("div", { children: [_jsx("p", { className: "eyebrow", children: label("compute.split.eyebrow") }), _jsx("h2", { className: "section-title", children: label("compute.split.title") })] }), _jsxs("div", { className: "prose-copy", children: [_jsx("p", { children: label("compute.split.body1") }), _jsx("p", { children: label("compute.split.body2") })] })] }), _jsx(ComputeBootladder, {}), _jsx(ComputeModalitycatalog, {}), _jsxs("section", { className: "content-section note-band", children: [_jsx(Box, { fontSize: 21, "aria-hidden": "true" }), _jsxs("div", { children: [_jsx("p", { className: "eyebrow", children: label("compute.note.eyebrow") }), _jsx("p", { children: label("compute.note.body") })] })] })] }));
+}

package/dist/Sol/console/console.d.ts

@@ -0,0 +1,15 @@
+/**
+ * console page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ */
+export * from '../wingets';
+/**
+ * the console page: wires the spec panel, terminal, events timeline and
+ * lifecycle controls to the browser-pure engine (sandbox.ts) and, when
+ * available, the self-hosted /api/v1 contract.
+ */
+export default function Console(): import("react").JSX.Element;

package/dist/Sol/console/console.js

@@ -0,0 +1,292 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * console page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ */
+// Real sandbox console: faithful absorption of console.html + console.js —
+// the spec panel, the animated boot sequence, the interactive terminal, the
+// bus event timeline, snapshot/stop and the api detection badge. when the
+// self-hosted node answers, the sandbox is also created through
+// /api/v1/sandboxes and commands run through the api exec endpoint;
+// otherwise the same dispatcher runs locally in the browser.
+import { useEffect, useRef, useState } from 'react';
+import { Link } from 'wouter';
+import { PageShell } from '../shell/Shell.tsx';
+import { apibase, apifetch, fetchhealth } from '../../api';
+import { label, labelfill } from '../../labels.ts';
+import { bootSequence, cpudata, createSandboxState, dispatch, gpudata } from '../../sandbox.ts';
+import { ApiBadge as ApiBadge } from '../wingets';
+import { ConsoleEdgelaw as ConsoleEdgelaw } from '../wingets';
+import { EventsTimeline as EventsTimeline } from '../wingets';
+import { SnapshotControls as SnapshotControls } from '../wingets';
+import { SpecPanel as SpecPanel } from '../wingets';
+import { Terminal as Terminal } from '../wingets';
+export * from '../wingets';
+/** display cap for very large payloads such as cpuinfo at 192 vcpus. */
+const displaycap = 120000;
+/** the session key the home landing writes and this page reads once (then spent). */
+const declaredkey = 'saddle.declared';
+/** initial spec selection mirroring the static page defaults. */
+const initialspec = {
+    model: cpudata[0].model,
+    quotamb: 16,
+    vcpus: 8,
+    ramgb: 32,
+    gpu: gpudata[0].id,
+    mig: 'off',
+};
+/** the sleep used to animate the boot sequence line by line. */
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * the console page: wires the spec panel, terminal, events timeline and
+ * lifecycle controls to the browser-pure engine (sandbox.ts) and, when
+ * available, the self-hosted /api/v1 contract.
+ */
+export default function Console() {
+    const rowseq = useRef(0);
+    const eventseq = useRef(0);
+    const engineref = useRef(null);
+    const apiref = useRef(null);
+    const [selection, setSelection] = useState(initialspec);
+    const [rows, setRows] = useState([]);
+    const [events, setEvents] = useState([]);
+    const [running, setRunning] = useState(false);
+    const [busy, setBusy] = useState(false);
+    const [termstate, setTermstate] = useState('halted');
+    const [prompt, setPrompt] = useState(labelfill('console.prompt', { host: 'saddle' }));
+    const [apimode, setApimode] = useState(false);
+    const [badgelabel, setBadgelabel] = useState(label('console.badge.local'));
+    const [declared, setDeclared] = useState(null);
+    /** api detection: probe the health endpoint once (1.5s budget). */
+    useEffect(() => {
+        let cancelled = false;
+        const detect = async () => {
+            const health = await fetchhealth(apibase(), 1500);
+            if (cancelled)
+                return;
+            if (health !== null) {
+                setApimode(true);
+                setBadgelabel(labelfill('console.badge.api', {
+                    version: String(health.version),
+                    uptime: String(health.uptime),
+                }));
+            }
+            else {
+                setBadgelabel(label('console.badge.local'));
+            }
+        };
+        detect().catch(() => {
+            if (!cancelled)
+                setBadgelabel(label('console.badge.local'));
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    /** the handed-over declaration of the landing prompt: read once, then spent. */
+    useEffect(() => {
+        try {
+            const raw = sessionStorage.getItem(declaredkey);
+            if (raw === null)
+                return;
+            sessionStorage.removeItem(declaredkey);
+            const parsed = JSON.parse(raw);
+            setDeclared({
+                base: typeof parsed.base === 'string' ? parsed.base : null,
+                os: typeof parsed.os === 'string' ? parsed.os : null,
+                arch: typeof parsed.arch === 'string' ? parsed.arch : null,
+            });
+        }
+        catch {
+            /* a broken handoff spends itself silently */
+        }
+    }, []);
+    /** appends one text block as a row; truncates giant payloads for display. */
+    const printrow = (text, cls) => {
+        rowseq.current += 1;
+        const id = rowseq.current;
+        if (text.length > displaycap) {
+            rowseq.current += 1;
+            const truncid = rowseq.current;
+            setRows((prev) => [
+                ...prev,
+                { id, text: text.slice(0, displaycap), cls },
+                {
+                    id: truncid,
+                    text: labelfill('console.boot.truncated', { bytes: String(text.length) }),
+                    cls: 'trunc',
+                },
+            ]);
+        }
+        else {
+            setRows((prev) => [...prev, { id, text, cls }]);
+        }
+    };
+    /** prepends one bus event; the timeline keeps at most 50 entries. */
+    const logevent = (topic, detail, kind) => {
+        eventseq.current += 1;
+        const now = new Date();
+        const item = {
+            id: eventseq.current,
+            time: now.toTimeString().slice(0, 8),
+            topic,
+            detail,
+            kind,
+        };
+        setEvents((prev) => [item, ...prev].slice(0, 50));
+    };
+    const onselectionchange = (patch) => {
+        setSelection((prev) => ({ ...prev, ...patch }));
+    };
+    /** boots the sandbox: spec commit, api-backed creation, animated dmesg. */
+    const bootsandbox = async () => {
+        setBusy(true);
+        setRunning(false);
+        setRows([]);
+        setTermstate('booting');
+        const spec = {
+            model: selection.model,
+            vcpus: selection.vcpus,
+            ramgb: selection.ramgb,
+            gpu: selection.gpu,
+            mig: selection.mig,
+            quotamb: selection.quotamb,
+        };
+        const state = createSandboxState(spec);
+        engineref.current = state;
+        setPrompt(labelfill('console.prompt', { host: state.hostname }));
+        logevent('vm:creating', labelfill('console.event.creating', {
+            model: spec.model,
+            vcpus: String(state.vcpus),
+            ram: String(spec.ramgb),
+            gpu: spec.gpu,
+        }), 'lifecycle');
+        /* api-backed sandbox when the self-hosted server answers */
+        if (apimode) {
+            try {
+                const response = await apifetch('/api/v1/sandboxes', {
+                    method: 'POST',
+                    body: JSON.stringify(spec),
+                });
+                if (response.ok) {
+                    const created = (await response.json());
+                    apiref.current = created.id;
+                    logevent('sandbox:created', labelfill('console.event.created', { id: created.id, state: created.state }), 'lifecycle');
+                }
+            }
+            catch {
+                apiref.current = null;
+                logevent('sandbox:create-failed', label('console.event.createFailed'), 'lifecycle');
+            }
+        }
+        printrow(labelfill('console.boot.line', {
+            model: spec.model,
+            vcpus: String(state.vcpus),
+            ram: String(spec.ramgb),
+            gpu: spec.gpu,
+        }), 'boot');
+        const lines = bootSequence(spec.model, state.vcpus, spec.ramgb, spec.gpu);
+        for (const bootline of lines) {
+            printrow(bootline, 'boot');
+            await sleep(28 + Math.random() * 34);
+        }
+        printrow(label('console.boot.ready'), 'ok');
+        logevent('vm:created', labelfill('console.event.specsCommitted', { id: state.id }), 'lifecycle');
+        logevent('vm:started', label('console.event.started'), 'lifecycle');
+        setRunning(true);
+        setTermstate('running');
+        setBusy(false);
+    };
+    const onstart = () => {
+        bootsandbox().catch(() => {
+            printrow(label('console.boot.failed'), 'err');
+            setBusy(false);
+        });
+    };
+    /** executes one command: api exec first, local dispatcher as fallback. */
+    const runcommand = async (rawcommand) => {
+        printrow(`${prompt} ${rawcommand}`, 'cmdline');
+        if (rawcommand === 'clear') {
+            setRows([]);
+            return;
+        }
+        let result = null;
+        let source = 'local';
+        if (apiref.current !== null) {
+            try {
+                const response = await apifetch(`/api/v1/sandboxes/${apiref.current}/exec`, {
+                    method: 'POST',
+                    body: JSON.stringify({ command: rawcommand }),
+                });
+                if (response.ok) {
+                    result = (await response.json());
+                    source = 'api';
+                }
+            }
+            catch {
+                result = null;
+            }
+        }
+        if (result === null) {
+            result =
+                engineref.current !== null
+                    ? dispatch(rawcommand, engineref.current)
+                    : { output: label('console.boot.notrunning'), exitCode: 1 };
+            source = 'local';
+        }
+        if (result.output.length > 0) {
+            printrow(result.output, result.exitCode === 0 ? '' : 'err');
+        }
+        logevent('exec:completed', labelfill('console.event.exec', {
+            command: rawcommand,
+            code: String(result.exitCode),
+            source,
+        }), 'exec');
+    };
+    /** snapshot: precopy stage 1 of 1, memory + disk. */
+    const onsnapshot = () => {
+        if (!running)
+            return;
+        const snapid = `snap-${Math.random().toString(16).slice(2, 10)}`;
+        printrow(labelfill('console.snapshot.created', { id: snapid }), 'ok');
+        logevent('snapshot:created', labelfill('console.event.snapshot', { id: snapid, sandbox: engineref.current?.id ?? 'n/a' }), 'snapshot');
+    };
+    /** teardown: local halt plus the api sandbox delete when connected. */
+    const onstop = async () => {
+        if (!running)
+            return;
+        setRunning(false);
+        setTermstate('stopped');
+        printrow(label('console.stop.done'), 'boot');
+        logevent('vm:stopped', labelfill('console.event.stopped', { id: engineref.current?.id ?? 'n/a' }), 'lifecycle');
+        if (apiref.current !== null) {
+            const id = apiref.current;
+            try {
+                await apifetch(`/api/v1/sandboxes/${id}`, { method: 'DELETE' });
+                logevent('vm:deleted', labelfill('console.event.deleted', { id }), 'lifecycle');
+            }
+            catch {
+                logevent('vm:delete-failed', labelfill('console.event.deleteFailed', { id }), 'lifecycle');
+            }
+            apiref.current = null;
+        }
+    };
+    return (_jsxs(PageShell, { section: label('console.shell.section'), label: label('console.shell.label'), title: label('console.shell.title'), intro: label('console.shell.intro'), children: [_jsx(ConsoleEdgelaw, {}), _jsxs("section", { className: "content-section console-section", children: [_jsxs("div", { className: "content-section-heading", children: [_jsx("p", { className: "eyebrow", children: label('console.eyebrow') }), _jsxs("div", { className: "console-heading-side", children: [_jsx(Link, { href: "/login", className: "console-signin", children: label('console.signin') }), _jsx(ApiBadge, { apion: apimode, label: badgelabel })] })] }), _jsxs("div", { className: "sandbox-grid", children: [_jsxs("section", { className: "sandbox-panel", "aria-labelledby": "specstitle", children: [_jsx("h2", { className: "sandbox-panel-title", id: "specstitle", children: label('console.specs.title') }), declared !== null &&
+                                        (declared.base !== null || declared.os !== null || declared.arch !== null) && (_jsxs("p", { className: "r3-declared-ribbon", role: "note", children: [label('console.declared.head'), [
+                                                declared.base !== null
+                                                    ? labelfill('console.declared.base', { value: declared.base })
+                                                    : null,
+                                                declared.os !== null
+                                                    ? labelfill('console.declared.guest', { value: declared.os })
+                                                    : null,
+                                                declared.arch !== null
+                                                    ? labelfill('console.declared.arch', { value: declared.arch })
+                                                    : null,
+                                            ]
+                                                .filter(Boolean)
+                                                .join(' · '), label('console.declared.tail')] })), _jsx(SpecPanel, { spec: selection, onChange: onselectionchange, disabled: busy || running }), _jsxs("div", { className: "sandbox-actions", children: [_jsx("button", { className: "button button-primary", type: "button", onClick: onstart, disabled: busy || running, "aria-label": label('console.startAria'), children: label('console.start') }), _jsx(SnapshotControls, { running: running, onsnapshot: onsnapshot, onstop: onstop })] })] }), _jsx(Terminal, { rows: rows, prompt: prompt, state: termstate, enabled: running, oncommand: runcommand }), _jsx(EventsTimeline, { events: events })] }), _jsx("p", { className: "console-note", children: label('console.note') })] })] }));
+}

package/dist/Sol/dashboard/dashboard.d.ts

@@ -0,0 +1,10 @@
+/**
+ * dashboard page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ */
+export * from '../wingets';
+export default function Dashboard(): import("react").JSX.Element;

package/dist/Sol/dashboard/dashboard.js

@@ -0,0 +1,181 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * dashboard page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ */
+// Signal & Ledger: the e2ugh dashboard absorbed into the single interface —
+// session via the saddlesession cookie (api) or the browser-local account
+// (static edge), user view and admin view in the same React shell.
+import { useEffect, useRef, useState } from 'react';
+import { Link, useLocation } from 'wouter';
+import { apibase } from '../../api';
+import { apiresult, noderole, pick } from '../../dashboardlib';
+import { label, labelfill } from '../../labels.ts';
+/* the explicit .ts suffix keeps the resolution unambiguous while the
+ * typed ES module that replaced the window-global localauth.js of the static edge (the original
+ * beside the typed module - the same convention the Login page uses. */
+import { logout, probe, session as readlocalsession } from '../../localauth.ts';
+import { AccountPanel as AccountPanel } from '../wingets';
+import { AdminPanel as AdminPanel } from '../wingets';
+import { CreateSandboxForm as CreateSandboxForm } from '../wingets';
+import { DashboardEventstimeline as EventsTimeline } from '../wingets';
+import { SandboxList as SandboxList } from '../wingets';
+export * from '../wingets';
+export default function Dashboard() {
+    const [, navigate] = useLocation();
+    const [phase, setphase] = useState('booting');
+    const [fatal, setfatal] = useState(null);
+    const [me, setme] = useState(null);
+    const [localview, setlocalview] = useState(null);
+    const [nodelabel, setnodelabel] = useState(label('dashboard.node.pending'));
+    const [tab, settab] = useState('user');
+    const [sandboxreload, setsandboxreload] = useState(0);
+    const [leaving, setleaving] = useState(false);
+    const tabrefs = useRef({});
+    /** decorative health read: paints the node role badge. */
+    async function loadhealth() {
+        try {
+            const result = await apiresult('/api/v1/health');
+            if (result.ok && result.body !== null && typeof result.body === 'object') {
+                setnodelabel(noderole(result.body));
+                return;
+            }
+        }
+        catch {
+            /* health is decorative; the badge simply stays neutral */
+        }
+        setnodelabel(label('dashboard.node.standalone'));
+    }
+    /** the account bootstrap: /auth/me fills the session or the fatal gate. */
+    async function loadme() {
+        let result;
+        try {
+            result = await apiresult('/api/v1/auth/me');
+        }
+        catch {
+            setfatal(label('dashboard.fatal.apiUnreachable'));
+            return;
+        }
+        if (result.status === 401 || result.status === 403) {
+            setfatal(label('dashboard.fatal.needsSession'));
+            return;
+        }
+        if (!result.ok || result.body === null || typeof result.body !== 'object') {
+            setfatal(label('dashboard.fatal.payload'));
+            return;
+        }
+        const envelope = result.body;
+        const body = envelope.user !== null && typeof envelope.user === 'object'
+            ? envelope.user
+            : envelope;
+        setme({
+            username: String(pick(body, ['username', 'name', 'user'], 'unknown')),
+            role: String(pick(body, ['role'], 'user')).toLowerCase(),
+            createdat: pick(body, ['createdAt', 'created_at', 'createdat', 'registeredAt'], null),
+            lastloginat: pick(body, ['lastLoginAt', 'last_login_at', 'lastlogin', 'lastLogin'], null),
+            id: pick(body, ['id', 'uuid'], null),
+        });
+    }
+    /* boot: probe the api once; no answer -> the static edge takes over with
+     * the browser-local session (localauth), exactly like the original page. */
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            const answers = await probe(apibase());
+            if (cancelled) {
+                return;
+            }
+            if (!answers) {
+                setphase('local');
+                setnodelabel(label('dashboard.node.edge'));
+                const raw = (await readlocalsession());
+                if (raw === null || raw === undefined) {
+                    setfatal(label('dashboard.fatal.noLocalSession'));
+                    return;
+                }
+                const view = {
+                    user: String(pick(raw, ['user', 'username'], 'unknown')),
+                    role: String(pick(raw, ['role'], 'user')),
+                    issuedat: Number(pick(raw, ['issuedat', 'issuedAt'], Date.now())),
+                    expiresat: Number(pick(raw, ['expiresat', 'expiresAt'], 0)),
+                };
+                setlocalview(view);
+                setme({
+                    username: view.user,
+                    role: view.role === 'admin' ? 'admin' : 'local',
+                    createdat: null,
+                    lastloginat: new Date(view.issuedat).toISOString(),
+                    id: null,
+                });
+                return;
+            }
+            setphase('api');
+            void loadhealth();
+            void loadme();
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    /** ends the session (cookie or local) and returns to the sign in page. */
+    async function dolgout() {
+        setleaving(true);
+        /* clears the local browser session too (no-op on the api mode) */
+        void logout();
+        try {
+            await apiresult('/api/v1/auth/logout', { method: 'POST' });
+        }
+        catch {
+            /* the cookie may already be gone; proceed to the login page */
+        }
+        navigate('/login');
+    }
+    /** selects one tab and moves the roving focus onto it. */
+    function selecttab(next) {
+        settab(next);
+        requestAnimationFrame(() => {
+            tabrefs.current[next]?.focus();
+        });
+    }
+    const mode = phase === 'local' ? 'local' : 'api';
+    const adminvisible = me !== null && me.role === 'admin';
+    const userbadge = me === null
+        ? label('dashboard.userbadge.pending')
+        : mode === 'local'
+            ? me.role === 'admin'
+                ? labelfill('dashboard.userbadge.localAdmin', { name: me.username })
+                : labelfill('dashboard.userbadge.local', { name: me.username })
+            : me.role === 'admin'
+                ? labelfill('dashboard.userbadge.admin', { name: me.username })
+                : me.username;
+    const roleclass = nodelabel === 'main' || nodelabel === 'clone'
+        ? `dash-rolebadge ${nodelabel}`
+        : 'dash-rolebadge';
+    return (_jsx("div", { className: "dash", children: _jsxs("div", { className: "dash-wrap", children: [_jsxs("header", { className: "dash-topbar", children: [_jsx("h1", { children: _jsx(Link, { href: "/console", children: label('dashboard.brand') }) }), _jsx("span", { className: "dash-tagline", children: label('dashboard.tagline') }), _jsx("span", { className: roleclass, "aria-live": "polite", children: labelfill('dashboard.nodeBadge', { label: nodelabel }) }), _jsx("span", { className: "dash-spacer" }), _jsx("span", { className: "dash-userbadge", children: userbadge }), _jsx("button", { type: "button", "aria-label": label('dashboard.logoutAria'), disabled: leaving, onClick: () => {
+                                void dolgout();
+                            }, children: label('dashboard.logout') })] }), fatal !== null && (_jsxs("div", { className: "dash-panel dash-fatal", "aria-live": "polite", children: [_jsx("h2", { children: label('dashboard.fatal.title') }), _jsx("p", { children: fatal }), _jsxs("div", { className: "dash-actions", children: [_jsx(Link, { className: "dash-btn", href: "/login", children: label('dashboard.fatal.signin') }), _jsx(Link, { className: "dash-btn", href: "/console", children: label('dashboard.fatal.backConsole') })] })] })), fatal === null && (_jsxs("div", { className: "dash-tabs", role: "tablist", "aria-label": label('dashboard.tabsAria'), onKeyDown: (event) => {
+                        if (event.key !== 'ArrowRight' && event.key !== 'ArrowLeft') {
+                            return;
+                        }
+                        if (adminvisible) {
+                            event.preventDefault();
+                            selecttab(tab === 'user' ? 'admin' : 'user');
+                        }
+                    }, children: [_jsx("button", { type: "button", role: "tab", id: "tab-user", ref: (node) => {
+                                tabrefs.current.user = node;
+                            }, "aria-selected": tab === 'user', "aria-controls": "panel-user", tabIndex: tab === 'user' ? 0 : -1, onClick: () => {
+                                selecttab('user');
+                            }, children: label('dashboard.tab.user') }), adminvisible && (_jsx("button", { type: "button", role: "tab", id: "tab-admin", ref: (node) => {
+                                tabrefs.current.admin = node;
+                            }, "aria-selected": tab === 'admin', "aria-controls": "panel-admin", tabIndex: tab === 'admin' ? 0 : -1, onClick: () => {
+                                selecttab('admin');
+                            }, children: label('dashboard.tab.admin') }))] })), fatal === null && (_jsx("div", { role: "tabpanel", id: "panel-user", "aria-labelledby": "tab-user", hidden: tab !== 'user', children: _jsxs("div", { className: "dash-grid2", children: [_jsx("div", { children: _jsxs("section", { className: "dash-panel", "aria-labelledby": "boxtitle", children: [_jsx("h2", { id: "boxtitle", children: label('dashboard.panel.sandboxes') }), _jsx(CreateSandboxForm, { mode: mode, oncreated: () => {
+                                                setsandboxreload((key) => key + 1);
+                                            }, onrefresh: () => {
+                                                setsandboxreload((key) => key + 1);
+                                            } }), _jsx(SandboxList, { mode: mode, reloadkey: sandboxreload, ready: me !== null })] }) }), _jsxs("div", { children: [_jsxs("section", { className: "dash-panel", "aria-labelledby": "infotitle", children: [_jsx("h2", { id: "infotitle", children: label('dashboard.panel.account') }), _jsx(AccountPanel, { mode: mode, user: me, local: localview })] }), _jsxs("section", { className: "dash-panel", "aria-labelledby": "eventstitle", children: [_jsx("h2", { id: "eventstitle", children: label('dashboard.panel.events') }), _jsx(EventsTimeline, { mode: mode, ready: me !== null })] })] })] }) })), fatal === null && adminvisible && (_jsx("div", { role: "tabpanel", id: "panel-admin", "aria-labelledby": "tab-admin", hidden: tab !== 'admin', children: _jsx(AdminPanel, { mode: mode }) })), _jsxs("footer", { className: "dash-footer", children: [_jsx("span", { children: label('dashboard.footer.cookie') }), _jsx("span", { children: label('dashboard.footer.storage') }), _jsx("span", { style: { marginLeft: 'auto' }, children: label('dashboard.footer.api') })] })] }) }));
+}

package/dist/Sol/docs/docs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * docs page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ */
+export default function Docs(): import("react").JSX.Element;

package/dist/Sol/docs/docs.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * docs page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ */
+// Signal & Ledger: documentation as an operations index, with short paths and preserved context.
+import { ArrowUpRightRegular as ArrowUpRight, BookOpenRegular as BookOpen, BracesRegular as Braces, CodeRegular as FileCode2, FlagRegular as Flag, RecordRegular as GitCommitHorizontal, PlayCircleRegular as PlayCircle, } from '@fluentui/react-icons';
+import { PageShell } from '../shell/Shell.tsx';
+import { label, labelfill } from '../../labels.ts';
+/** the operations index: the glyph and the two-digit index are presentation
+ * code, every word rides the store under the docs.note.* family. */
+const docs = [
+    { icon: BookOpen, index: '00', key: 'thesis' },
+    { icon: Braces, index: '01', key: 'session' },
+    { icon: GitCommitHorizontal, index: '02', key: 'repo' },
+    { icon: FileCode2, index: '03', key: 'chain' },
+    { icon: Flag, index: '04', key: 'gates' },
+];
+export default function Docs() {
+    return (_jsxs(PageShell, { section: label('docs.shell.section'), label: label('docs.shell.label'), title: label('docs.shell.title'), intro: label('docs.shell.intro'), children: [_jsxs("section", { className: "content-section split-content", children: [_jsxs("div", { children: [_jsx("p", { className: "eyebrow", children: label('docs.split.eyebrow') }), _jsx("h2", { className: "section-title", children: label('docs.split.title') })] }), _jsxs("div", { className: "prose-copy", children: [_jsx("p", { children: label('docs.split.body1') }), _jsx("p", { children: label('docs.split.body2') })] })] }), _jsxs("section", { className: "content-section docs-list", children: [_jsxs("div", { className: "content-section-heading", children: [_jsx("p", { className: "eyebrow", children: label('docs.index.eyebrow') }), _jsx("span", { className: "mono-label", children: labelfill('docs.index.mono', { n: String(docs.length) }) })] }), docs.map((doc) => {
+                        const Icon = doc.icon;
+                        return (_jsxs("button", { type: "button", className: "doc-row", onClick: (event) => event.preventDefault(), children: [_jsx("span", { className: "doc-index", children: doc.index }), _jsx(Icon, { fontSize: 20, strokeWidth: 1.5 }), _jsxs("div", { className: "doc-copy", children: [_jsx("span", { children: label(`docs.note.${doc.key}.meta`) }), _jsx("strong", { children: label(`docs.note.${doc.key}.title`) }), _jsx("p", { children: label(`docs.note.${doc.key}.body`) })] }), _jsx(ArrowUpRight, { fontSize: 17 })] }, doc.key));
+                    })] }), _jsxs("section", { className: "content-section docs-cta", children: [_jsx(PlayCircle, { fontSize: 22 }), _jsxs("div", { children: [_jsx("p", { className: "eyebrow", children: label('docs.cta.eyebrow') }), _jsx("h3", { children: label('docs.cta.title') }), _jsx("p", { children: label('docs.cta.body') })] }), _jsxs("a", { href: "https://github.com/wenathlan/saddle", target: "_blank", rel: "noreferrer", className: "button button-dark", children: [label('docs.cta.link'), _jsx(ArrowUpRight, { fontSize: 15 })] })] })] }));
+}

package/dist/Sol/home/home.d.ts

@@ -0,0 +1,35 @@
+/**
+ * home page anchor — layer 3 of the anchor architecture.
+ * The file carrying the folder's own name is the path manager of the page:
+ * it imports the loose components beside it, mounts the page and re-exports
+ * the public component surface. Only the theme anchor (Sol/Sol.tsx) consumes
+ * this file. This anchor carries the former main component of the folder,
+ * which now lives here as the page mount itself.
+ *
+ * R3-saddle: home is the LANDING of the platform — one sand light over the
+ * window stage, the prompt-giga field where the operator declares a sandbox
+ * (a giant mono input with the embedded boot key and the real declared
+ * vocabulary of sandboxprofile.ts as chips), the sandbox matrix as a
+ * hairline ledger of the three runtime bases (base / guests / arch / vgpu /
+ * ceiling — the documented development bootstrap limits of
+ * sandboxenvprofile.ts), the thesis, the runtime chain, the surfaces
+ * ledger, the 01–03 steps and the footer meta-quad. The boot key parses the
+ * draft against the declared vocabulary and hands the parsed declaration to
+ * the console over the `saddle.declared` session key — the console reads
+ * and spends it once on mount (a real handoff: the hardware identities stay
+ * caller choices there).
+ *
+ * The flow law rides this anchor: the default export is the ENTRY GATE
+ * (entrygate.tsx, beside this anchor) — the seen flags are consulted before
+ * the landing shows, an unfinished flow is replaced at /intro or
+ * /onboarding, and only a visitor that finished both stages ever sees the
+ * surface below.
+ */
+export * from '../wingets';
+/**
+ * The home page anchor: the entry gate rides the surface — the flow law
+ * (intro → onboarding → the platform) is consulted before the home shows.
+ *
+ * @returns the gated home element.
+ */
+export default function Home(): import("react").JSX.Element;