@deepwatch/dsh-client-settings 0.1.0

package/lib/client/chat-gate.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The composer, closed until something is actually bound to Chat — and the
+ * fastest way to bind it, offered where the person is standing.
+ *
+ * A person typed a message into a composer that looked ready, pressed send,
+ * and the prompt was routed to a provider they had never configured. Nothing
+ * about the composer had told them otherwise: the model chip named a DeepSeek
+ * model they had not chosen, the send button was live, and the first thing
+ * that disagreed was a failed turn.
+ *
+ * This is the client half of preflight. It raises the block upstream provides
+ * for exactly this — *"Composer blocks: the one way another plugin stops a
+ * session's input"* — so the textarea goes inert, the send button stops
+ * accepting, and the placeholder says why in the words of whoever knows.
+ *
+ * **This is an affordance, and it is not the enforcement.** It lives in a
+ * browser tab. The Host refuses an unbound route regardless of what any client
+ * disables (`@deepwatch/dsh-technology/routing`), and the composed default
+ * names no route so the Harness's own admission boundary refuses a turn before
+ * one exists. The value of this layer is not that it makes refusal certain — it
+ * is that a person finds out *before* typing rather than after sending.
+ *
+ * **The draft survives.** Blocking is one inert textarea, never a second tree:
+ * the composer keeps its DOM, so whatever was typed is still there when the
+ * binding is fixed. That is upstream's design and this file's reason for using
+ * it rather than rendering a replacement.
+ *
+ * **The way out is here, not somewhere else.** The settings panel's open state
+ * is component-local to `SettingsRoot`, so no plugin can navigate to a section
+ * — and a button that names a screen it cannot open is worse than no button.
+ * So the fix is offered inline: the same provider-and-model picker the Role
+ * Bindings screen uses, writing through the same store, so the two surfaces
+ * cannot disagree about what a provider offers.
+ *
+ * @module @deepwatch/dsh-client-settings/chat-gate
+ */
+import { useEffect, useState, useSyncExternalStore } from 'react';
+import { PRIMARY_ROLE, ROLE_LABEL, cardForBlocker, isExecutable } from '@deepwatch/dsh-contracts';
+import { StatusChip } from './components.js';
+import { BindingEditor, CONTROL } from './role-bindings.js';
+import { chatReadiness } from './binding-state.js';
+/**
+ * The placeholder an inert composer carries.
+ *
+ * The blocker's own sentence, prefixed with the capability it is about. A
+ * placeholder reading only "Not configured" leaves a person guessing which of
+ * six things is missing, which is the failure the ordered blocker list exists
+ * to prevent.
+ */
+export function blockReason(detail) {
+    return `${ROLE_LABEL[PRIMARY_ROLE]} is not ready — ${detail}`;
+}
+/**
+ * The block this snapshot calls for, or undefined when the composer may open.
+ *
+ * A pure function rather than a branch inside the effect, so the decision can
+ * be tested as the decision. A test that re-derived the same condition beside
+ * the component would agree with itself and prove nothing about what a person
+ * gets.
+ *
+ * `idle` and `loading` deliberately produce nothing. Blocking a composer
+ * because an answer has not arrived yet would make every reload look like a
+ * misconfiguration — and the Host refuses an unbound route regardless, so the
+ * safe direction here is to say nothing until something is known.
+ *
+ * @param snapshot - what the store currently knows.
+ * @returns the block to raise, or undefined to lift any standing one.
+ */
+export function blockFor(snapshot) {
+    if (snapshot.status !== 'ready')
+        return undefined;
+    const chat = chatReadiness(snapshot);
+    if (chat === null || isExecutable(chat) || chat.primaryBlocker === null)
+        return undefined;
+    return { reason: blockReason(cardForBlocker(chat.primaryBlocker).detail) };
+}
+/**
+ * Raise or clear this session's composer block, and offer the way out.
+ *
+ * @param props - see {@link ChatGateProps}.
+ * @returns the setup card while Chat cannot run, and nothing once it can.
+ */
+export function ChatGate({ sessionId, store, blocks }) {
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+    const [open, setOpen] = useState(false);
+    // One load per mounted gate, not one per render. The store guards against a
+    // slow answer landing after a newer one, so a second session mounting while
+    // the first is loading does not produce a stale snapshot.
+    useEffect(() => { void store.load(); }, [store]);
+    const chat = chatReadiness(snapshot);
+    const ready = chat !== null && isExecutable(chat);
+    const card = chat === null || chat.primaryBlocker === null
+        ? null
+        : cardForBlocker(chat.primaryBlocker);
+    // The same decision function the tests assert on, so what a person gets and
+    // what is asserted cannot drift apart.
+    const block = blockFor(snapshot);
+    useEffect(() => {
+        const registry = blocks();
+        if (registry === undefined)
+            return;
+        registry.set(sessionId, block);
+        // Clearing on unmount matters: a session whose gate is gone must not keep
+        // a block nothing is left to lift.
+        return () => { registry.set(sessionId, undefined); };
+    }, [blocks, sessionId, block?.reason]);
+    if (ready || card === null || chat === null)
+        return null;
+    return (_jsxs("section", { "aria-label": `${ROLE_LABEL[PRIMARY_ROLE]} setup`, style: {
+            border: '1px solid color-mix(in srgb, var(--watch-accent) 68%, var(--dsw-alias-border-l2))',
+            borderRadius: '14px',
+            padding: '15px 17px',
+            margin: '0 0 8px',
+            background: 'linear-gradient(145deg, color-mix(in srgb, var(--watch-accent) 7%, var(--dsw-alias-bg-layer-2)), var(--dsw-alias-bg-base))',
+            boxShadow: '0 10px 30px color-mix(in srgb, var(--watch-accent) 9%, transparent)',
+        }, children: [_jsxs("div", { style: {
+                    display: 'flex', alignItems: 'baseline', gap: '10px',
+                    justifyContent: 'space-between', flexWrap: 'wrap',
+                }, children: [_jsx("h3", { style: { fontSize: '13px', fontWeight: 600, margin: 0 }, children: card.title }), _jsx(StatusChip, { tone: "neutral", children: chat.status === 'bound_unverified' ? 'Configured · not tested' : 'Not ready' })] }), _jsx("p", { style: {
+                    fontSize: '12px', lineHeight: 1.55, margin: '6px 0 0',
+                    color: 'var(--dsw-alias-label-secondary)',
+                }, children: card.detail }), open
+                ? (_jsx(BindingEditor, { row: {
+                        role: PRIMARY_ROLE,
+                        provider: null,
+                        model: null,
+                        readiness: chat,
+                    }, providers: snapshot.providers, saving: snapshot.saving, onBind: (provider, model) => {
+                        void store.bind(PRIMARY_ROLE, provider, model).then(() => { setOpen(false); });
+                    }, onCancel: () => { setOpen(false); } }))
+                : (_jsxs("div", { style: CONTROL.row, children: [_jsx("button", { type: "button", style: CONTROL.primary, disabled: !snapshot.writable || snapshot.testingRole !== null, "aria-describedby": snapshot.writable ? undefined : 'watch-chat-gate-readonly', onClick: () => {
+                                if (chat.primaryBlocker === 'provider_untested')
+                                    void store.testRole(PRIMARY_ROLE);
+                                else
+                                    setOpen(true);
+                            }, children: snapshot.testingRole === PRIMARY_ROLE ? 'Testing provider…' : card.action }), snapshot.writable
+                            ? null
+                            : (_jsx("span", { id: "watch-chat-gate-readonly", style: { fontSize: '12px', color: 'var(--dsw-alias-label-tertiary)' }, children: "This Workspace cannot change settings here, so Chat cannot be bound from this screen. What is shown is still read from the running system." })), _jsx("span", { style: { fontSize: '12px', color: 'var(--dsw-alias-label-tertiary)' }, children: "Settings \u2192 Role Bindings has the full view." })] }))] }));
+}
+//# sourceMappingURL=chat-gate.js.map

package/lib/client/chat-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-gate.js","sourceRoot":"","sources":["../../src/client/chat-gate.tsx"],"names":[],"mappings":"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"}

package/lib/client/components.d.ts

@@ -0,0 +1,194 @@
+/**
+ * The Technology & Capability Center.
+ *
+ * Seven surfaces that answer one question each, and one rule that governs all
+ * of them: **nothing here may claim a capability works.** Every status shown is
+ * either read from a descriptor that says what was actually established, or
+ * labelled as not established. A settings page that flatters the installation
+ * is worse than no settings page, because it is the screen a person checks
+ * before trusting a result.
+ *
+ * That is why there is no "Ready" anywhere that is not backed by
+ * `machine_tested`, and no accuracy or speed figure at all for an engine that
+ * has not run on this machine.
+ *
+ * @module @deepwatch/dsh-client-settings/components
+ */
+import type { ReactNode } from 'react';
+import type { CoreHealthReport } from '@deepwatch/dsh-contracts/query/wire';
+import type { BrandTone } from '@deepwatch/dsh-client-brand';
+import type { RoleRow } from './binding-state.js';
+/** What a settings section is handed by DSH. */
+export interface SectionProps {
+    readonly close?: () => void;
+}
+/**
+ * The panel vocabulary every surface here shares.
+ *
+ * Exported because Role Bindings moved into its own file once it stopped being
+ * static copy, and two settings screens with independently-invented padding is
+ * how a panel starts looking like two products.
+ */
+export declare const T: {
+    page: {
+        padding: string;
+        maxWidth: string;
+        background: string;
+    };
+    lead: {
+        fontSize: string;
+        lineHeight: number;
+        color: string;
+        margin: string;
+        maxWidth: string;
+    };
+    card: {
+        border: string;
+        borderRadius: string;
+        padding: string;
+        marginBottom: string;
+        background: string;
+        boxShadow: string;
+    };
+    cardHead: {
+        display: string;
+        alignItems: string;
+        gap: string;
+        justifyContent: string;
+        flexWrap: "wrap";
+    };
+    title: {
+        fontSize: string;
+        fontWeight: number;
+        margin: number;
+        letterSpacing: string;
+    };
+    meta: {
+        display: string;
+        gridTemplateColumns: string;
+        columnGap: string;
+        rowGap: string;
+        fontSize: string;
+        marginTop: string;
+    };
+    key: {
+        color: string;
+    };
+    value: {
+        color: string;
+    };
+    note: {
+        fontSize: string;
+        lineHeight: number;
+        color: string;
+        borderInlineStart: string;
+        paddingInlineStart: string;
+        margin: string;
+    };
+    h2: {
+        fontSize: string;
+        fontWeight: number;
+        letterSpacing: string;
+        textTransform: "uppercase";
+        color: string;
+        margin: string;
+    };
+};
+/**
+ * The tones a settings chip may use.
+ *
+ * `success` is deliberately not among them. Green is reserved for a VERIFIED
+ * verdict, and nothing on a settings page is a verdict — a configured
+ * capability reads as `active`, which is a different colour and a different
+ * claim.
+ */
+export type ChipTone = Exclude<BrandTone, 'success'>;
+/**
+ * A status chip.
+ *
+ * The tone vocabulary is the brand's, and `success` is deliberately absent:
+ * nothing in a settings page is a verification verdict, so nothing here is
+ * allowed to be green. A capability that is genuinely working reads as
+ * `active`, which is a different colour and a different claim.
+ */
+export declare function StatusChip({ tone, children }: {
+    readonly tone: ChipTone;
+    readonly children: ReactNode;
+}): ReactNode;
+/**
+ * The empty state every surface here needs.
+ *
+ * A capability that is not configured must still render something a person can
+ * act on. A dead control that fails when clicked teaches people the product is
+ * broken; a sentence explaining what is missing and what would fix it does not.
+ */
+export declare function NotConfigured({ what, why, fix }: {
+    readonly what: string;
+    readonly why: string;
+    readonly fix: string;
+}): ReactNode;
+/**
+ * Perception Engines.
+ *
+ * An Engine Runtime is not a Provider Connection, and the distinction is the
+ * whole point of the screen: a provider is a credential and an endpoint, an
+ * engine is software that runs here. Presence on disk is not readiness, so the
+ * lifecycle state is shown verbatim rather than collapsed into a tick.
+ *
+ * No engine shows a quality or speed number. On a machine where nothing has
+ * been measured, every such number would be invented.
+ */
+export declare function EnginesSection(): ReactNode;
+/**
+ * Sources & Devices.
+ *
+ * Nothing here asks the operating system for anything. A permission prompt on
+ * page load trains people to click Allow without reading, so a permission is
+ * requested when a capability is first used and not before — which is also why
+ * every row says when it would ask.
+ */
+export declare function SourcesSection(): ReactNode;
+/**
+ * Memory & Retrieval.
+ *
+ * The encryption row is the one that matters. The ledger is a plain file with
+ * the profile's permissions, and saying so is the difference between a product
+ * a person can calibrate their trust against and one that misleads them about
+ * where their data sits.
+ */
+export declare function MemorySection(): ReactNode;
+/**
+ * Verification.
+ *
+ * The screen leads with the distinction the whole product rests on, because
+ * this is where somebody configures how much proof they want and needs to know
+ * what a verdict does and does not mean.
+ */
+export declare function VerificationSection(): ReactNode;
+/**
+ * Diagnostics. What is actually running, and what is not.
+ *
+ * The capability readiness list lives here rather than in the first-run notice.
+ * It needs the settings panel's width; the onboarding seat is 256 pixels wide,
+ * and putting this there once already spilled two thousand pixels out of a
+ * clipped sidebar column.
+ */
+export declare function DiagnosticsSection({ openSection, roles, health, reading, onRefresh }?: {
+    readonly openSection?: ((id: string) => void) | undefined;
+    /** Live role readiness, so this screen and Role Bindings agree. */
+    readonly roles?: readonly RoleRow[] | undefined;
+    /** The engine, as the Host last read it. Null when it could not be read. */
+    readonly health?: CoreHealthReport | null | undefined;
+    readonly reading?: boolean | undefined;
+    readonly onRefresh?: (() => void) | undefined;
+}): ReactNode;
+/**
+ * About.
+ *
+ * This is where the foundation becomes explicit. Watch is the product and
+ * DeepSeek Harness is what it is built on; both statements belong on the same
+ * screen, and the independence disclosure belongs beside them so the
+ * attribution cannot be read as an endorsement.
+ */
+export declare function AboutSection(): ReactNode;
+//# sourceMappingURL=components.d.ts.map

package/lib/client/components.js

@@ -0,0 +1,273 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ATTRIBUTION, INDEPENDENCE, PRODUCT_NAME, WATCH_MARK_PNG, tokenFor } from '@deepwatch/dsh-client-brand';
+// The `/descriptors` subpath, not the package root: the root re-exports the
+// OCR worker, which imports `node:child_process` to supervise a real process.
+// Correct on the host, fatal in a browser bundle.
+import { OCR_ENGINES } from '@deepwatch/dsh-technology/descriptors';
+import { ReadinessList } from './readiness.js';
+import { OCR_BY_WORKLOAD, OCR_DEVICE, OCR_ENGINE, OCR_MEASURED } from '../ocr-measured.js';
+/* ── shared presentation ────────────────────────────────────────────────── */
+/**
+ * The panel vocabulary every surface here shares.
+ *
+ * Exported because Role Bindings moved into its own file once it stopped being
+ * static copy, and two settings screens with independently-invented padding is
+ * how a panel starts looking like two products.
+ */
+export const T = {
+    page: {
+        padding: '6px 4px 30px', maxWidth: '880px',
+        background: 'radial-gradient(circle at 0 0, color-mix(in srgb, var(--watch-accent) 5%, transparent), transparent 34%)',
+    },
+    lead: {
+        fontSize: '13.5px', lineHeight: 1.65,
+        color: 'var(--dsw-alias-label-secondary)', margin: '0 0 20px', maxWidth: '72ch',
+    },
+    card: {
+        border: '1px solid color-mix(in srgb, var(--watch-accent) 9%, var(--dsw-alias-border-l2))',
+        borderRadius: '14px',
+        padding: '16px 18px',
+        marginBottom: '12px',
+        background: 'linear-gradient(145deg, color-mix(in srgb, var(--watch-accent) 3%, var(--dsw-alias-bg-layer-2)), var(--dsw-alias-bg-base))',
+        boxShadow: '0 10px 28px color-mix(in srgb, black 8%, transparent)',
+    },
+    cardHead: {
+        display: 'flex', alignItems: 'baseline', gap: '10px',
+        justifyContent: 'space-between', flexWrap: 'wrap',
+    },
+    title: { fontSize: '14px', fontWeight: 620, margin: 0, letterSpacing: '-0.01em' },
+    meta: {
+        display: 'grid',
+        gridTemplateColumns: 'max-content 1fr',
+        columnGap: '14px', rowGap: '4px',
+        fontSize: '12px', marginTop: '10px',
+    },
+    key: { color: 'var(--dsw-alias-label-tertiary)' },
+    value: { color: 'var(--dsw-alias-label-secondary)' },
+    note: {
+        fontSize: '12px', lineHeight: 1.55,
+        color: 'var(--dsw-alias-label-tertiary)',
+        borderInlineStart: '2px solid var(--watch-accent)',
+        paddingInlineStart: '10px', margin: '14px 0 0',
+    },
+    h2: { fontSize: '11px', fontWeight: 700, letterSpacing: '0.11em', textTransform: 'uppercase', color: 'var(--watch-accent)', margin: '24px 0 9px' },
+};
+/**
+ * A status chip.
+ *
+ * The tone vocabulary is the brand's, and `success` is deliberately absent:
+ * nothing in a settings page is a verification verdict, so nothing here is
+ * allowed to be green. A capability that is genuinely working reads as
+ * `active`, which is a different colour and a different claim.
+ */
+export function StatusChip({ tone, children }) {
+    // `tokenFor` rather than a colour: a feature package asks for a tone and gets
+    // a custom property, which is what keeps the palette from being re-invented
+    // slightly differently in every panel and makes a theme change one edit.
+    const colour = tokenFor(tone);
+    return (_jsx("span", { style: {
+            display: 'inline-flex', alignItems: 'center', gap: '5px',
+            fontSize: '11px', lineHeight: 1.4, padding: '2px 8px',
+            borderRadius: '999px', whiteSpace: 'nowrap',
+            border: `1px solid color-mix(in srgb, ${colour} 60%, transparent)`, color: colour,
+            background: `color-mix(in srgb, ${colour} 8%, transparent)`,
+        }, children: children }));
+}
+/** A local/remote label, because where the data goes is a product fact. */
+function Where({ local }) {
+    return _jsx(StatusChip, { tone: local ? 'active' : 'info', children: local ? 'Local' : 'Remote' });
+}
+function Row({ label, children }) {
+    return (_jsxs(_Fragment, { children: [_jsx("span", { style: T.key, children: label }), _jsx("span", { style: T.value, children: children })] }));
+}
+/**
+ * The empty state every surface here needs.
+ *
+ * A capability that is not configured must still render something a person can
+ * act on. A dead control that fails when clicked teaches people the product is
+ * broken; a sentence explaining what is missing and what would fix it does not.
+ */
+export function NotConfigured({ what, why, fix }) {
+    return (_jsxs("div", { style: { ...T.card, borderStyle: 'dashed' }, children: [_jsxs("div", { style: T.cardHead, children: [_jsx("h3", { style: T.title, children: what }), _jsx(StatusChip, { tone: "neutral", children: "Not configured" })] }), _jsx("p", { style: { ...T.lead, margin: '8px 0 0' }, children: why }), _jsx("p", { style: { ...T.note, marginTop: '10px' }, children: fix })] }));
+}
+/* ── 2. Perception Engines ──────────────────────────────────────────────── */
+/**
+ * Lifecycle words a person can act on, and the tone each earns.
+ *
+ * `not_tested` is the state every engine is in on a machine where no capability
+ * check has run, and it is what `untestedHealth` returns. It is deliberately
+ * not styled as an error: nothing is broken, nobody has looked.
+ */
+function lifecycleChip(state) {
+    const map = {
+        machine_tested: { tone: 'active', text: 'Machine tested' },
+        ready: { tone: 'active', text: 'Ready' },
+        probed: { tone: 'caution', text: 'Probed, not measured' },
+        installed: { tone: 'caution', text: 'Installed, not tested' },
+        discovered: { tone: 'neutral', text: 'Not tested' },
+        not_tested: { tone: 'neutral', text: 'Not tested' },
+        not_installed: { tone: 'neutral', text: 'Not installed' },
+        installing: { tone: 'caution', text: 'Installing' },
+        degraded: { tone: 'error', text: 'Degraded' },
+        unavailable: { tone: 'error', text: 'Unavailable' },
+        incompatible: { tone: 'error', text: 'Incompatible' },
+        disabled: { tone: 'neutral', text: 'Disabled' },
+    };
+    const entry = map[state] ?? { tone: 'neutral', text: state };
+    return _jsx(StatusChip, { tone: entry.tone, children: entry.text });
+}
+function gigabytes(bytes) {
+    if (bytes === null)
+        return 'unknown';
+    return `${(bytes / 1_000_000_000).toFixed(1)} GB`;
+}
+/**
+ * Perception Engines.
+ *
+ * An Engine Runtime is not a Provider Connection, and the distinction is the
+ * whole point of the screen: a provider is a credential and an endpoint, an
+ * engine is software that runs here. Presence on disk is not readiness, so the
+ * lifecycle state is shown verbatim rather than collapsed into a tick.
+ *
+ * No engine shows a quality or speed number. On a machine where nothing has
+ * been measured, every such number would be invented.
+ */
+export function EnginesSection() {
+    return (_jsxs("div", { style: T.page, children: [_jsx("p", { style: T.lead, children: "An engine runs on this machine; a provider is something you connect to. Presence on disk is not readiness, so each engine shows the furthest state actually reached. Nothing here shows an accuracy or speed figure: none has been measured on this hardware, and a figure that was not measured would be fiction." }), _jsx("h2", { style: T.h2, children: "OCR and layout" }), OCR_ENGINES.map((engine) => (_jsxs("div", { style: T.card, children: [_jsxs("div", { style: T.cardHead, children: [_jsx("h3", { style: T.title, children: engine.displayName }), _jsxs("span", { style: { display: 'flex', gap: '6px' }, children: [_jsx(Where, { local: engine.runtime !== 'remote' }), lifecycleChip('not_tested')] })] }), _jsxs("div", { style: T.meta, children: [_jsx(Row, { label: "Version", children: engine.version }), _jsx(Row, { label: "Runtime", children: engine.runtime }), _jsx(Row, { label: "Hardware", children: engine.hardware.gpu === 'required'
+                                    ? `GPU required${engine.hardware.minVramGb === null ? '' : `, ${String(engine.hardware.minVramGb)} GB VRAM`}`
+                                    : engine.hardware.gpu === 'optional' ? 'GPU optional' : 'CPU only' }), _jsx(Row, { label: "Egress", children: engine.privacy.egress === 'none'
+                                    ? 'Nothing leaves this machine'
+                                    : engine.privacy.egress === 'metadata_only' ? 'Metadata only' : 'Sends content off this machine' }), _jsx(Row, { label: "Offline", children: engine.privacy.worksOffline ? 'Works offline' : 'Requires network' }), _jsxs(Row, { label: "Install", children: [engine.install.method === 'bundled' ? 'Bundled' : engine.install.method, engine.install.downloadBytes === null ? '' : ` · ${gigabytes(engine.install.downloadBytes)} download`] }), _jsx(Row, { label: "Quality", children: OCR_MEASURED && engine.id.includes(OCR_ENGINE)
+                                    ? 'Measured on this machine — see the table below.'
+                                    : 'Not measured on this machine' }), _jsx(Row, { label: "How it would be checked", children: engine.testMethod ?? engine.probeMethod ?? 'No check is defined for this engine' })] })] }, engine.id))), OCR_MEASURED
+                ? (_jsxs(_Fragment, { children: [_jsx("h2", { style: T.h2, children: `Measured accuracy — ${OCR_ENGINE} on ${OCR_DEVICE}` }), _jsxs("div", { style: T.card, children: [_jsx("p", { style: { ...T.lead, margin: '0 0 10px' }, children: "A real run over a versioned ground-truth corpus, scored against thresholds committed before the benchmark existed. Reported per workload rather than as one average: an engine can be entirely fit for reading a settings panel and entirely unfit for reading grey-on-grey, and a single number hides both." }), _jsx("div", { style: T.meta, children: OCR_BY_WORKLOAD.map(row => (_jsxs(Row, { label: row.workload, children: [_jsx(StatusChip, { tone: row.passes ? 'active' : 'error', children: row.passes ? 'Qualified' : 'Not qualified' }), ` CER ${String(row.cer)} · word accuracy ${String(row.wordAccuracy)} `, `· invented words ${String(row.hallucination)} · ${String(row.samples)} sample(s)`] }, row.workload))) }), _jsx("p", { style: T.note, children: "Accuracy is not a GPU question and is measured here. GPU throughput is not, because there is no GPU on this machine \u2014 that remains externally unvalidated." })] })] }))
+                : null, _jsx("p", { style: T.note, children: "An install is never automatic. Where a download is required, its size, hardware requirement and licence are shown before anything is fetched \u2014 multi-gigabyte weights are not something a product should acquire because a page was opened." })] }));
+}
+/* ── 3. Sources & Devices ───────────────────────────────────────────────── */
+const SOURCES = [
+    { id: 'files', name: 'Files', purpose: 'Documents and recordings you open.', local: true, permission: 'Granted per file, when you pick one' },
+    { id: 'video', name: 'Video', purpose: 'Recorded footage, indexed so a citation can point at a moment.', local: true, permission: 'Granted per file' },
+    { id: 'browser', name: 'Browser', purpose: 'A supervised browser that acts and reports a receipt.', local: true, permission: 'No OS permission needed' },
+    { id: 'screen', name: 'Screen', purpose: 'The whole display.', local: true, permission: 'Requested at first use' },
+    { id: 'window', name: 'Window', purpose: 'One application window.', local: true, permission: 'Requested at first use' },
+    { id: 'camera', name: 'Camera', purpose: 'Live visual input.', local: true, permission: 'Requested at first use' },
+    { id: 'microphone', name: 'Microphone', purpose: 'Live audio input.', local: true, permission: 'Requested at first use' },
+    { id: 'live', name: 'Live session', purpose: 'A continuous session over one or more of the above.', local: true, permission: 'Inherits its sources' },
+];
+/**
+ * Sources & Devices.
+ *
+ * Nothing here asks the operating system for anything. A permission prompt on
+ * page load trains people to click Allow without reading, so a permission is
+ * requested when a capability is first used and not before — which is also why
+ * every row says when it would ask.
+ */
+export function SourcesSection() {
+    return (_jsxs("div", { style: T.page, children: [_jsx("p", { style: T.lead, children: "Opening this page requests nothing. A permission is asked for when a capability is first used, because a prompt on load teaches people to allow without reading. Every source below is local: what it captures stays on this machine unless a separate media-upload consent is given." }), SOURCES.map(source => (_jsxs("div", { style: T.card, children: [_jsxs("div", { style: T.cardHead, children: [_jsx("h3", { style: T.title, children: source.name }), _jsxs("span", { style: { display: 'flex', gap: '6px' }, children: [_jsx(Where, { local: source.local }), _jsx(StatusChip, { tone: "neutral", children: "Not requested" })] })] }), _jsx("p", { style: { ...T.lead, margin: '6px 0 0' }, children: source.purpose }), _jsx("div", { style: T.meta, children: _jsx(Row, { label: "Permission", children: source.permission }) })] }, source.id)))] }));
+}
+/* ── 4. Memory & Retrieval ──────────────────────────────────────────────── */
+const MEMORY_MODES = [
+    { id: 'off', name: 'Off', detail: 'Nothing is written and nothing is recalled.' },
+    { id: 'session_only', name: 'Session only', detail: 'Kept for this session and never reaches a later one.' },
+    { id: 'local_personal', name: 'Local Personal', detail: 'A ledger on this machine, for this profile.' },
+    { id: 'workspace_shared', name: 'Workspace Shared', detail: 'Knowledge and decisions are shared; personal taste is not.' },
+];
+/**
+ * Memory & Retrieval.
+ *
+ * The encryption row is the one that matters. The ledger is a plain file with
+ * the profile's permissions, and saying so is the difference between a product
+ * a person can calibrate their trust against and one that misleads them about
+ * where their data sits.
+ */
+export function MemorySection() {
+    return (_jsxs("div", { style: T.page, children: [_jsx("p", { style: T.lead, children: "Memory is a product capability, not a plugin. The ledger is the authority and every projection \u2014 taste, index, log \u2014 is rebuilt from it, which is what makes Forget remove a record rather than hide it." }), _jsx("h2", { style: T.h2, children: "Mode" }), MEMORY_MODES.map(mode => (_jsxs("div", { style: T.card, children: [_jsxs("div", { style: T.cardHead, children: [_jsx("h3", { style: T.title, children: mode.name }), mode.id === 'local_personal'
+                                ? _jsx(StatusChip, { tone: "active", children: "Selected in this profile" })
+                                : _jsx(StatusChip, { tone: "neutral", children: "Available" })] }), _jsx("p", { style: { ...T.lead, margin: '6px 0 0' }, children: mode.detail })] }, mode.id))), _jsx("h2", { style: T.h2, children: "Storage" }), _jsxs("div", { style: T.card, children: [_jsxs("div", { style: T.meta, children: [_jsx(Row, { label: "Ledger", children: "An append-only event log on this machine" }), _jsx(Row, { label: "Projections", children: "Rebuilt from the ledger, never edited in place" }), _jsx(Row, { label: "Embeddings", children: "Unbound \u2014 see Role Bindings. Retrieval falls back to lexical matching." }), _jsx(Row, { label: "Retention", children: "Kept until forgotten. Forget writes a tombstone." }), _jsx(Row, { label: "Encryption at rest", children: _jsx(StatusChip, { tone: "caution", children: "Not encrypted" }) })] }), _jsx("p", { style: T.note, children: "The ledger is a plain file. It is created owner-only \u2014 no group, no others \u2014 on systems that enforce file permissions; Windows has no equivalent and the file inherits the folder it sits in. On Desktop it is intended to move behind the OS keychain; until that is implemented and tested, this page will keep saying it is not encrypted. Claiming otherwise would be the one thing a privacy setting must never do." })] })] }));
+}
+/* ── 5. Verification ────────────────────────────────────────────────────── */
+/**
+ * Verification.
+ *
+ * The screen leads with the distinction the whole product rests on, because
+ * this is where somebody configures how much proof they want and needs to know
+ * what a verdict does and does not mean.
+ */
+export function VerificationSection() {
+    return (_jsxs("div", { style: T.page, children: [_jsxs("div", { style: { ...T.card, borderColor: 'var(--watch-accent)' }, children: [_jsx("h3", { style: T.title, children: "Agent completed \u2260 Verified" }), _jsx("p", { style: { ...T.lead, margin: '8px 0 0' }, children: "A tool returning without an error means the call finished. It does not mean the thing happened. Only a verification against the world produces a verdict, and only Watch Core produces one \u2014 no plugin, no client and no model can mint a verdict, by construction rather than by convention." })] }), _jsx("h2", { style: T.h2, children: "Verifier" }), _jsxs("div", { style: T.card, children: [_jsxs("div", { style: T.cardHead, children: [_jsx("h3", { style: T.title, children: "Deterministic checks" }), _jsxs("span", { style: { display: 'flex', gap: '6px' }, children: [_jsx(Where, { local: true }), _jsx(StatusChip, { tone: "active", children: "Available" })] })] }), _jsx("p", { style: { ...T.lead, margin: '6px 0 0' }, children: "Reads a row, an HTTP status, a file, an exit code. Needs no model, so it works offline and its result does not depend on a provider." })] }), _jsxs("div", { style: T.card, children: [_jsxs("div", { style: T.cardHead, children: [_jsx("h3", { style: T.title, children: "Model-assisted checks" }), _jsx(StatusChip, { tone: "neutral", children: "Verifier role not bound" })] }), _jsx("p", { style: { ...T.lead, margin: '6px 0 0' }, children: "For expectations a deterministic check cannot express. Bind the Verifier role to enable them; until then, expectations that need one return INCONCLUSIVE rather than a guess." })] }), _jsx("h2", { style: T.h2, children: "Verdicts" }), _jsxs("div", { style: T.card, children: [_jsxs("div", { style: T.meta, children: [_jsx(Row, { label: "VERIFIED", children: "Checked against the world, and it held." }), _jsx(Row, { label: "FAILED", children: "Checked, and it did not hold." }), _jsx(Row, { label: "UNVERIFIED", children: "Not checked. Not a failure \u2014 an absence." }), _jsx(Row, { label: "INCONCLUSIVE", children: "Checked, and the evidence did not settle it." })] }), _jsx("p", { style: T.note, children: "Green is reserved for VERIFIED and nothing else reaches it \u2014 not a high confidence, not a completed turn, not five checks out of six." })] })] }));
+}
+/* ── 6. Diagnostics ─────────────────────────────────────────────────────── */
+/**
+ * What the engine is doing, in one chip.
+ *
+ * `connected` is the only state that gets the active tone. Everything else —
+ * including the mock backend, which is *working* and is still not the product
+ * — reads as a problem, because on this screen it is one.
+ */
+function CoreStateChip({ health, reading }) {
+    if (health === null || health === undefined) {
+        return (_jsx(StatusChip, { tone: "neutral", children: reading ? 'Reading…' : 'Could not be read' }));
+    }
+    if (health.blocker === 'connected')
+        return _jsx(StatusChip, { tone: "active", children: "Connected" });
+    if (health.isTestOnlyMock)
+        return _jsx(StatusChip, { tone: "caution", children: "Test-only mock" });
+    return _jsx(StatusChip, { tone: "caution", children: health.phase });
+}
+/**
+ * Diagnostics. What is actually running, and what is not.
+ *
+ * The capability readiness list lives here rather than in the first-run notice.
+ * It needs the settings panel's width; the onboarding seat is 256 pixels wide,
+ * and putting this there once already spilled two thousand pixels out of a
+ * clipped sidebar column.
+ */
+export function DiagnosticsSection({ openSection, roles, health, reading, onRefresh } = {}) {
+    return (_jsxs("div", { style: T.page, children: [_jsx("p", { style: T.lead, children: "What this installation actually consists of. Where a value cannot be read from the running system it says so, rather than showing a plausible default." }), _jsx("h2", { style: T.h2, children: "Capability readiness" }), _jsx(ReadinessList, { openSection: openSection, roles: roles, health: health, reading: reading }), _jsx("h2", { style: T.h2, children: "Versions" }), _jsx("div", { style: T.card, children: _jsxs("div", { style: T.meta, children: [_jsx(Row, { label: "DeepWatch", children: "0.1.0" }), _jsx(Row, { label: "DeepSeek Harness", children: "0.1.1-rc.2" }), _jsx(Row, { label: "Watch Core", children: health === null || health === undefined || health.coreVersion === null
+                                ? _jsx(StatusChip, { tone: "neutral", children: "Not reported" })
+                                : health.coreVersion }), _jsx(Row, { label: "Bridge protocol", children: health === null || health === undefined || health.protocolVersion === null
+                                ? _jsx(StatusChip, { tone: "neutral", children: "Not reported" })
+                                : `${String(health.protocolVersion)} (Core supports ${health.protocolMin === null ? '?' : String(health.protocolMin)}-${health.protocolVersion === null ? '?' : String(health.protocolVersion)})` }), _jsx(Row, { label: "Memory store schema", children: "1" })] }) }), _jsx("h2", { style: T.h2, children: "Health" }), _jsxs("div", { style: T.card, children: [_jsxs("div", { style: T.meta, children: [_jsx(Row, { label: "Watch Core", children: _jsxs("span", { style: { display: 'inline-flex', alignItems: 'center', gap: '8px' }, children: [_jsx(CoreStateChip, { health: health, reading: reading === true }), onRefresh === undefined
+                                            ? null
+                                            : (_jsx("button", { type: "button", onClick: onRefresh, disabled: reading === true, style: {
+                                                    background: 'none', border: 'none', padding: 0,
+                                                    font: 'inherit', fontSize: '12px', cursor: 'pointer',
+                                                    color: tokenFor('info'), textDecoration: 'underline',
+                                                }, children: "Re-read" }))] }) }), _jsx(Row, { label: "Bridge transport", children: health === null || health === undefined
+                                    ? _jsx(StatusChip, { tone: "neutral", children: "Not reported" })
+                                    : health.isTestOnlyMock
+                                        ? _jsx(StatusChip, { tone: "caution", children: "Test-only mock backend" })
+                                        : health.transport === null
+                                            ? _jsx(StatusChip, { tone: "neutral", children: "Not reported" })
+                                            : health.transport }), _jsx(Row, { label: "Contract", children: health === null || health === undefined
+                                    ? _jsx(StatusChip, { tone: "neutral", children: "Not reported" })
+                                    : health.contractsMatch
+                                        ? _jsx(StatusChip, { tone: "active", children: "Matches this build" })
+                                        : _jsx(StatusChip, { tone: "caution", children: health.contractDrift.length === 0
+                                                ? 'Unverified'
+                                                : `Drifted: ${health.contractDrift.join(', ')}` }) }), _jsx(Row, { label: "Capabilities", children: health === null || health === undefined
+                                    ? _jsx(StatusChip, { tone: "neutral", children: "Not reported" })
+                                    : `${String(health.capabilities.ready)} ready · `
+                                        + `${String(health.capabilities.degraded)} degraded · `
+                                        + `${String(health.capabilities.unavailable)} unavailable · `
+                                        + `${String(health.capabilities.unknown)} unknown` }), _jsx(Row, { label: "Last handshake", children: health === null || health === undefined || health.lastHandshakeAt === null
+                                    ? _jsx(StatusChip, { tone: "neutral", children: "Never" })
+                                    : health.lastHandshakeAt }), _jsx(Row, { label: "Engine starts", children: health === null || health === undefined
+                                    ? _jsx(StatusChip, { tone: "neutral", children: "Not reported" })
+                                    : String(health.restartCount) }), health !== null && health !== undefined && health.blocker !== 'connected'
+                                ? (_jsx(Row, { label: "Blocker", children: _jsxs("span", { children: [_jsx(StatusChip, { tone: "caution", children: health.blocker }), health.fix === '' ? null : _jsxs("span", { style: T.note, children: [" ", health.fix] })] }) }))
+                                : null, _jsx(Row, { label: "Offline", children: _jsx(StatusChip, { tone: "active", children: "Offline only" }) }), _jsx(Row, { label: "Media upload consent", children: _jsx(StatusChip, { tone: "neutral", children: "Not given" }) })] }), _jsx("p", { style: T.note, children: "Offline-only and media-upload consent are two separate settings on purpose. Holding a provider credential is not permission to upload a frame, a transcript or a screen capture, and no agent can change either from inside a session." })] })] }));
+}
+/* ── 7. About ───────────────────────────────────────────────────────────── */
+/**
+ * About.
+ *
+ * This is where the foundation becomes explicit. Watch is the product and
+ * DeepSeek Harness is what it is built on; both statements belong on the same
+ * screen, and the independence disclosure belongs beside them so the
+ * attribution cannot be read as an endorsement.
+ */
+export function AboutSection() {
+    return (_jsxs("div", { style: T.page, children: [_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: '14px', marginBottom: '4px' }, children: [_jsx("img", { src: WATCH_MARK_PNG, width: 44, height: 44, alt: "", "aria-hidden": "true", style: { width: '44px', height: '44px', objectFit: 'contain', flexShrink: 0 } }), _jsxs("div", { children: [_jsx("h3", { style: { ...T.title, fontSize: '19px' }, children: PRODUCT_NAME }), _jsx("p", { style: { ...T.lead, margin: '2px 0 0' }, children: "An agent that sees, remembers, and can prove what actually happened." })] })] }), _jsx("div", { style: T.card, children: _jsxs("div", { style: T.meta, children: [_jsx(Row, { label: "DeepWatch", children: "0.1.0" }), _jsx(Row, { label: "Watch Core", children: "Reported by the Bridge, not read from here" }), _jsx(Row, { label: "Built on", children: "DeepSeek Harness 0.1.1-rc.2" }), _jsx(Row, { label: "DSH commit", children: "b150a551b8d465e31e418e1b2eaf5e79bbb7d28e" })] }) }), _jsxs("div", { style: { ...T.card, borderColor: 'var(--watch-accent)' }, children: [_jsx("p", { style: { margin: 0, fontSize: '13px', lineHeight: 1.6 }, children: ATTRIBUTION }), _jsx("p", { style: { margin: '8px 0 0', fontSize: '13px', lineHeight: 1.6, color: 'var(--dsw-alias-label-secondary)' }, children: INDEPENDENCE })] }), _jsx("h2", { style: T.h2, children: "Licences" }), _jsx("div", { style: T.card, children: _jsxs("div", { style: T.meta, children: [_jsx(Row, { label: "DeepWatch", children: "MIT" }), _jsx(Row, { label: "DeepSeek Harness", children: "MIT, and its notice is carried unmodified" }), _jsx(Row, { label: "Third-party notices", children: "THIRD_PARTY_NOTICES.md, shipped with this distribution" }), _jsx(Row, { label: "Model weights", children: "Distributed with none. A code licence is not a weights licence." })] }) })] }));
+}
+//# sourceMappingURL=components.js.map