windows-development-sandbox 1.10.0 → 1.11.3

package/dist/app/features/health/health.def.d.ts

@@ -0,0 +1,275 @@
+import { z } from 'zod';
+import { type Page, type Tone } from '../../kernel/index.js';
+export declare const StatusSchema: z.ZodEnum<{
+    fixed: "fixed";
+    ok: "ok";
+    warn: "warn";
+    "needs-you": "needs-you";
+    skipped: "skipped";
+}>;
+export declare const CheckRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    group: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        fixed: "fixed";
+        ok: "ok";
+        warn: "warn";
+        "needs-you": "needs-you";
+        skipped: "skipped";
+    }>;
+    detail: z.ZodString;
+    means: z.ZodOptional<z.ZodString>;
+    fix: z.ZodOptional<z.ZodString>;
+    plan: z.ZodOptional<z.ZodString>;
+    lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fixable: z.ZodBoolean;
+    timedOut: z.ZodOptional<z.ZodBoolean>;
+    applied: z.ZodOptional<z.ZodObject<{
+        done: z.ZodString;
+        before: z.ZodString;
+        after: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CheckRow = z.output<typeof CheckRowSchema>;
+export declare const SummarySchema: z.ZodObject<{
+    total: z.ZodNumber;
+    ok: z.ZodNumber;
+    fixed: z.ZodNumber;
+    warn: z.ZodNumber;
+    needsYou: z.ZodNumber;
+    skipped: z.ZodNumber;
+    fixable: z.ZodNumber;
+}, z.core.$strip>;
+export type HealthSummary = z.output<typeof SummarySchema>;
+export declare const SetupRowSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        ok: "ok";
+        warn: "warn";
+        action: "action";
+    }>;
+    detail: z.ZodString;
+}, z.core.$strip>;
+export declare const HealthLastSchema: z.ZodObject<{
+    at: z.ZodString;
+    mode: z.ZodEnum<{
+        check: "check";
+        repair: "repair";
+    }>;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        group: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            fixed: "fixed";
+            ok: "ok";
+            warn: "warn";
+            "needs-you": "needs-you";
+            skipped: "skipped";
+        }>;
+        detail: z.ZodString;
+        means: z.ZodOptional<z.ZodString>;
+        fix: z.ZodOptional<z.ZodString>;
+        plan: z.ZodOptional<z.ZodString>;
+        lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fixable: z.ZodBoolean;
+        timedOut: z.ZodOptional<z.ZodBoolean>;
+        applied: z.ZodOptional<z.ZodObject<{
+            done: z.ZodString;
+            before: z.ZodString;
+            after: z.ZodString;
+        }, z.core.$strip>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        total: z.ZodNumber;
+        ok: z.ZodNumber;
+        fixed: z.ZodNumber;
+        warn: z.ZodNumber;
+        needsYou: z.ZodNumber;
+        skipped: z.ZodNumber;
+        fixable: z.ZodNumber;
+    }, z.core.$strip>;
+    details: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+    setup: z.ZodNullable<z.ZodObject<{
+        checks: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            status: z.ZodEnum<{
+                ok: "ok";
+                warn: "warn";
+                action: "action";
+            }>;
+            detail: z.ZodString;
+        }, z.core.$strip>>;
+        canEnable: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    log: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type HealthLast = z.output<typeof HealthLastSchema>;
+/** "6 ok, 1 fixed, 1 needs you, 1 warning": the parts that are zero are left out (except ok). */
+export declare function summaryText(s: HealthSummary): string;
+export interface ResultLine {
+    readonly text: string;
+    readonly tone?: Tone;
+}
+/**
+ * The lines of one result as the plain printer writes them (HealthPrinter.result with animate off), without the group
+ * heading. The tone paints the first line only.
+ */
+export declare function resultLines(r: CheckRow): ResultLine[];
+export declare const lastHealth: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    last: z.ZodNullable<z.ZodObject<{
+        at: z.ZodString;
+        mode: z.ZodEnum<{
+            check: "check";
+            repair: "repair";
+        }>;
+        checks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            group: z.ZodString;
+            name: z.ZodString;
+            status: z.ZodEnum<{
+                fixed: "fixed";
+                ok: "ok";
+                warn: "warn";
+                "needs-you": "needs-you";
+                skipped: "skipped";
+            }>;
+            detail: z.ZodString;
+            means: z.ZodOptional<z.ZodString>;
+            fix: z.ZodOptional<z.ZodString>;
+            plan: z.ZodOptional<z.ZodString>;
+            lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fixable: z.ZodBoolean;
+            timedOut: z.ZodOptional<z.ZodBoolean>;
+            applied: z.ZodOptional<z.ZodObject<{
+                done: z.ZodString;
+                before: z.ZodString;
+                after: z.ZodString;
+            }, z.core.$strip>>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        summary: z.ZodObject<{
+            total: z.ZodNumber;
+            ok: z.ZodNumber;
+            fixed: z.ZodNumber;
+            warn: z.ZodNumber;
+            needsYou: z.ZodNumber;
+            skipped: z.ZodNumber;
+            fixable: z.ZodNumber;
+        }, z.core.$strip>;
+        details: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+        setup: z.ZodNullable<z.ZodObject<{
+            checks: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                status: z.ZodEnum<{
+                    ok: "ok";
+                    warn: "warn";
+                    action: "action";
+                }>;
+                detail: z.ZodString;
+            }, z.core.$strip>>;
+            canEnable: z.ZodBoolean;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        log: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "health.last">;
+export declare const checkHealth: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    harness: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    summary: z.ZodObject<{
+        total: z.ZodNumber;
+        ok: z.ZodNumber;
+        fixed: z.ZodNumber;
+        warn: z.ZodNumber;
+        needsYou: z.ZodNumber;
+        skipped: z.ZodNumber;
+        fixable: z.ZodNumber;
+    }, z.core.$strip>;
+    changed: z.ZodBoolean;
+    log: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, "health.check">;
+export declare const repairHealth: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    summary: z.ZodObject<{
+        total: z.ZodNumber;
+        ok: z.ZodNumber;
+        fixed: z.ZodNumber;
+        warn: z.ZodNumber;
+        needsYou: z.ZodNumber;
+        skipped: z.ZodNumber;
+        fixable: z.ZodNumber;
+    }, z.core.$strip>;
+    changed: z.ZodBoolean;
+    log: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, "health.repair">;
+export declare const enableSandbox: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "health.enableSandbox">;
+/** The health page: before any check, the two things to do; after one, what it found. Pure. */
+export declare function healthPage(o: {
+    last: HealthLast | null;
+}): Page;
+export declare const healthView: import("../../kernel/define.js").ViewDef<{
+    last: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        last: z.ZodNullable<z.ZodObject<{
+            at: z.ZodString;
+            mode: z.ZodEnum<{
+                check: "check";
+                repair: "repair";
+            }>;
+            checks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                group: z.ZodString;
+                name: z.ZodString;
+                status: z.ZodEnum<{
+                    fixed: "fixed";
+                    ok: "ok";
+                    warn: "warn";
+                    "needs-you": "needs-you";
+                    skipped: "skipped";
+                }>;
+                detail: z.ZodString;
+                means: z.ZodOptional<z.ZodString>;
+                fix: z.ZodOptional<z.ZodString>;
+                plan: z.ZodOptional<z.ZodString>;
+                lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                fixable: z.ZodBoolean;
+                timedOut: z.ZodOptional<z.ZodBoolean>;
+                applied: z.ZodOptional<z.ZodObject<{
+                    done: z.ZodString;
+                    before: z.ZodString;
+                    after: z.ZodString;
+                }, z.core.$strip>>;
+                error: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            summary: z.ZodObject<{
+                total: z.ZodNumber;
+                ok: z.ZodNumber;
+                fixed: z.ZodNumber;
+                warn: z.ZodNumber;
+                needsYou: z.ZodNumber;
+                skipped: z.ZodNumber;
+                fixable: z.ZodNumber;
+            }, z.core.$strip>;
+            details: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+            setup: z.ZodNullable<z.ZodObject<{
+                checks: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    status: z.ZodEnum<{
+                        ok: "ok";
+                        warn: "warn";
+                        action: "action";
+                    }>;
+                    detail: z.ZodString;
+                }, z.core.$strip>>;
+                canEnable: z.ZodBoolean;
+                error: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            log: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, "health.last">;
+}, Record<string, never>, "health">;

package/dist/app/features/health/health.def.js

@@ -0,0 +1,281 @@
+// The health of this PC and the sandbox: the last check or repair (saved), checking, repairing, and turning Windows
+// Sandbox on. Pure: schemas, the line format the surfaces print, and the view. The checks and the saving are in
+// health.run.ts (Node side).
+import { z } from 'zod';
+import { action, ago, defineOperation, defineQuery, defineView, } from '../../kernel/index.js';
+const CLI_DOCTOR = 'sandbox doctor and sandbox repair are hand-written renderers of this run (lines redrawn in place, --json alone, repair before the settings load)';
+export const StatusSchema = z.enum(['ok', 'fixed', 'needs-you', 'warn', 'skipped']).describe('What the check found');
+export const CheckRowSchema = z.object({
+    id: z.string().describe('The check'),
+    group: z.string().describe('Its heading (This PC, Install ...)'),
+    name: z.string().describe('What was checked'),
+    status: StatusSchema,
+    detail: z.string().describe('What was found'),
+    means: z.string().optional().describe('What it means for you'),
+    fix: z.string().optional().describe('What to do yourself'),
+    plan: z.string().optional().describe('What repair would change'),
+    lines: z.array(z.string()).optional().describe('More lines (a diff, folders)'),
+    fixable: z.boolean().describe('Repair can mend it'),
+    timedOut: z.boolean().optional().describe('It took too long'),
+    applied: z
+        .object({ done: z.string(), before: z.string(), after: z.string() })
+        .optional()
+        .describe('What a fix changed'),
+    error: z.string().optional().describe('Why a fix did not work'),
+});
+export const SummarySchema = z
+    .object({
+    total: z.number().describe('Checks that ran'),
+    ok: z.number().describe('Checks that are fine'),
+    fixed: z.number().describe('Problems repair fixed'),
+    warn: z.number().describe('Warnings'),
+    needsYou: z.number().describe('Problems you need to fix'),
+    skipped: z.number().describe('Checks that did not run'),
+    fixable: z.number().describe('Problems repair can still mend'),
+})
+    .describe('How many checks ended how');
+export const SetupRowSchema = z.object({
+    name: z.string().describe('What was looked at'),
+    status: z.enum(['ok', 'warn', 'action']).describe('OK, a warning, or something to do'),
+    detail: z.string().describe('What was found'),
+});
+export const HealthLastSchema = z.object({
+    at: z.string().describe('When it ran (ISO time)'),
+    mode: z.enum(['check', 'repair']).describe('A check or a repair'),
+    checks: z.array(CheckRowSchema).describe('The results'),
+    summary: SummarySchema,
+    details: z.array(z.tuple([z.string(), z.string()])).describe('The doctor details: name and value'),
+    setup: z
+        .object({
+        checks: z.array(SetupRowSchema),
+        canEnable: z.boolean().describe('Windows Sandbox can be turned on from here'),
+        error: z.string().nullable().describe('Why the setup could not be read'),
+    })
+        .nullable()
+        .describe('What sandbox setup found'),
+    log: z.string().nullable().describe('The repair log, if one was written'),
+});
+/** "6 ok, 1 fixed, 1 needs you, 1 warning": the parts that are zero are left out (except ok). */
+export function summaryText(s) {
+    const parts = [
+        s.ok + ' ok',
+        s.fixed && s.fixed + ' fixed',
+        s.needsYou && s.needsYou + ' ' + (s.needsYou === 1 ? 'needs' : 'need') + ' you',
+        s.warn && s.warn + (s.warn === 1 ? ' warning' : ' warnings'),
+        s.skipped && s.skipped + ' skipped',
+    ];
+    return parts.filter(Boolean).join(', ');
+}
+const MARK = {
+    ok: '[ok]',
+    fixed: '[fixed]',
+    warn: '[!]',
+    'needs-you': '[x]',
+    skipped: '[-]',
+};
+const TONE = {
+    ok: undefined,
+    fixed: 'accent',
+    warn: 'warn',
+    'needs-you': 'danger',
+    skipped: 'muted',
+};
+const MAX_LINES = 6;
+/**
+ * The lines of one result as the plain printer writes them (HealthPrinter.result with animate off), without the group
+ * heading. The tone paints the first line only.
+ */
+export function resultLines(r) {
+    const first = {
+        text: '  ' + MARK[r.status] + ' ' + r.name + ': ' + r.detail + (r.timedOut ? ' (took too long)' : ''),
+        ...(TONE[r.status] ? { tone: TONE[r.status] } : {}),
+    };
+    if (r.status === 'ok')
+        return [first];
+    const out = [first];
+    if (r.means)
+        out.push({ text: '      What it means: ' + r.means });
+    if (r.fixable && r.plan)
+        out.push({ text: '      Fix: sandbox repair will ' + r.plan });
+    else if (r.fix)
+        out.push({ text: '      Fix: ' + r.fix });
+    const lines = r.lines ?? [];
+    for (const line of lines.slice(0, MAX_LINES))
+        out.push({ text: '        ' + line });
+    if (lines.length > MAX_LINES)
+        out.push({ text: '        ... and ' + (lines.length - MAX_LINES) + ' more' });
+    return out;
+}
+const BADGE = {
+    ok: 'OK',
+    fixed: 'FIXED',
+    'needs-you': 'NEEDS YOU',
+    warn: 'WARNING',
+    skipped: 'SKIPPED',
+};
+function cut(text, max) {
+    return text.length <= max ? text : text.slice(0, max - 1) + '…';
+}
+const OutcomeSchema = z.object({
+    summary: SummarySchema,
+    changed: z.boolean().describe('Fixes were applied'),
+    log: z.string().nullable().describe('The repair log, if one was written'),
+});
+export const lastHealth = defineQuery({
+    id: 'health.last',
+    title: 'Health',
+    summary: 'the last check or repair of this PC and the sandbox',
+    input: z.object({}),
+    output: z.object({ last: HealthLastSchema.nullable().describe('Nothing yet: no check has run') }),
+    surfaces: { except: { cli: 'the command line prints results as it checks (sandbox doctor)' } },
+});
+export const checkHealth = defineOperation({
+    id: 'health.check',
+    title: 'Check this PC',
+    summary: 'check this PC, the install, your settings and the sandbox (changes nothing)',
+    input: z.object({ harness: z.string().optional().describe('agent to check') }),
+    output: OutcomeSchema,
+    text: (o) => 'Summary: ' + summaryText(o.summary),
+    surfaces: { except: { cli: CLI_DOCTOR } },
+});
+export const repairHealth = defineOperation({
+    id: 'health.repair',
+    title: 'Run the checks and fix what can be fixed',
+    summary: 'find and fix problems (install, data folder, settings, stale state, half-installed tools)',
+    input: z.object({}),
+    output: OutcomeSchema,
+    danger: true,
+    text: (o) => 'Summary: ' +
+        summaryText(o.summary) +
+        (o.log ? '. Log: ' + o.log : '. No log was written (the storage folder does not exist yet).'),
+    surfaces: { except: { cli: CLI_DOCTOR } },
+});
+export const enableSandbox = defineOperation({
+    id: 'health.enableSandbox',
+    title: 'Turn on Windows Sandbox',
+    summary: 'turn on the Windows Sandbox feature (Windows asks for admin permission; restart to finish)',
+    input: z.object({}),
+    output: z.object({ message: z.string().describe('What happened') }),
+    danger: true,
+    text: (o) => o.message,
+    surfaces: {
+        except: {
+            cli: 'sandbox setup asks and turns it on (hand-written: it also offers to restart Windows)',
+            web: 'Windows asks for admin permission on this PC; use the menu or sandbox setup',
+        },
+    },
+});
+function checkItems(last) {
+    return last.checks.map((r, i) => {
+        const lines = resultLines(r)
+            .slice(1)
+            .map((l) => l.text.trim());
+        return {
+            id: 'repair:' + i,
+            label: r.name,
+            hint: BADGE[r.status],
+            ...(TONE[r.status] ? { tone: TONE[r.status] } : {}),
+            badges: [{ text: BADGE[r.status], ...(TONE[r.status] ? { tone: TONE[r.status] } : {}) }],
+            description: r.detail,
+            ...(lines.length ? { details: lines } : {}),
+        };
+    });
+}
+/** The health page: before any check, the two things to do; after one, what it found. Pure. */
+export function healthPage(o) {
+    const last = o.last;
+    const check = action(checkHealth, {}, { verb: 'check' });
+    const repair = action(repairHealth, {}, { verb: 'check and fix' });
+    if (!last) {
+        return {
+            title: 'Health',
+            sections: [
+                {
+                    id: 'doctor',
+                    title: 'Doctor',
+                    cards: true,
+                    items: [
+                        {
+                            id: 'health:check',
+                            label: 'Check this PC',
+                            description: 'Looks at this PC: Windows features, the install, the folders and the sandbox. It takes a few seconds, so it only runs when you ask.',
+                            primary: check,
+                        },
+                    ],
+                },
+                {
+                    id: 'repair',
+                    title: 'Repair',
+                    cards: true,
+                    items: [
+                        {
+                            id: 'repair:run',
+                            label: 'Run the checks and fix what can be fixed',
+                            description: 'Checks the install, data folder, settings and sandbox, lists what it would change, and asks before it fixes anything.',
+                            primary: repair,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    const canEnable = Boolean(last.setup?.canEnable);
+    const sections = [
+        {
+            id: 'status',
+            summary: (last.mode === 'repair' ? 'Repaired ' : 'Checked ') + ago(last.at),
+            facts: last.log ? [{ id: 'log', label: 'Log', value: last.log }] : [],
+        },
+        {
+            id: 'doctor',
+            title: 'Doctor',
+            items: last.details.map(([name, detail], i) => ({
+                id: 'doctor:' + i,
+                label: name,
+                hint: cut(detail, 50),
+                details: [detail],
+            })),
+        },
+        {
+            id: 'repair',
+            title: 'Repair',
+            items: checkItems(last),
+        },
+    ];
+    if (last.setup) {
+        const setup = last.setup;
+        sections.push({
+            id: 'setup',
+            title: 'Set up this PC',
+            items: setup.error
+                ? [{ id: 'setup:error', label: setup.error }]
+                : setup.checks.map((c, i) => ({
+                    id: 'setup:' + i,
+                    label: c.name,
+                    hint: c.status === 'ok' ? 'OK' : c.status === 'warn' ? 'WARNING' : 'ACTION NEEDED',
+                    tone: c.status === 'ok' ? 'ok' : c.status === 'warn' ? 'warn' : 'danger',
+                    description: c.detail,
+                })),
+            notes: canEnable
+                ? [{ text: 'Turn Windows Sandbox on from the menu or with sandbox setup.', tone: 'muted', only: 'web' }]
+                : [],
+        });
+    }
+    return {
+        title: 'Health',
+        sections,
+        actions: [
+            action(repairHealth, {}, { key: 'f', verb: 'check and fix', importance: 1 }),
+            action(checkHealth, {}, { key: 'l', verb: last ? 'check again' : 'check', importance: 2 }),
+            ...(canEnable ? [action(enableSandbox, {}, { key: 'e', verb: 'turn on Windows Sandbox', importance: 3 })] : []),
+        ],
+    };
+}
+export const healthView = defineView({
+    id: 'health',
+    title: 'Health',
+    summary: 'Checks this PC and your settings, repairs problems, and sets up Windows Sandbox.',
+    queries: { last: lastHealth },
+    operations: [checkHealth, repairHealth, enableSandbox],
+    build: ({ last }) => healthPage(last),
+});

package/dist/app/features/health/health.run.d.ts

@@ -0,0 +1,125 @@
+import { type UserError } from '../../../core/util/index.js';
+import { type Context } from '../../../cli/commands/context.js';
+import { type HealthEvents, type HealthReport } from '../../../cli/commands/repair/health-run.js';
+import { type OperationIO } from '../../kernel/index.js';
+import { type HealthLast } from './health.def.js';
+/** Where a run's results go on the surfaces that have no terminal: the shared core's io. */
+export declare function ioEvents(io: OperationIO): HealthEvents;
+export interface HealthSurface {
+    /** Where results go while they are found (null: nothing is printed, for --json). */
+    readonly events: HealthEvents | null;
+    /** May ask (the CLI: a terminal and not --json; the menu and web: yes for repair). */
+    readonly mayAsk: boolean;
+    readonly confirmFix: (question: string) => Promise<boolean>;
+}
+export interface HealthRequest {
+    readonly mode: 'doctor' | 'repair';
+    /** Fix without asking (--fix, --yes). */
+    readonly yes: boolean;
+    /** The agent to check (--agent). */
+    readonly harness?: string;
+    /** Repair with a broken settings file: the checks run on the defaults and report it. */
+    readonly configError?: UserError | null;
+    /** What sandbox setup found, saved with the rest (null from the command line). */
+    readonly setup?: HealthLast['setup'];
+}
+export interface HealthOutcome {
+    readonly report: HealthReport;
+    readonly details: string[][];
+    readonly log: string | null;
+}
+/**
+ * The one run of doctor and repair, for every surface: look, ask (when allowed), fix, write the repair log, and save
+ * the results. The CLI prints what this returns; the menu and the web show the saved results.
+ */
+export declare function healthWith(ctx: Context, request: HealthRequest, surface: HealthSurface): Promise<HealthOutcome>;
+export declare const checkHealthRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    harness: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    summary: import("zod").ZodObject<{
+        total: import("zod").ZodNumber;
+        ok: import("zod").ZodNumber;
+        fixed: import("zod").ZodNumber;
+        warn: import("zod").ZodNumber;
+        needsYou: import("zod").ZodNumber;
+        skipped: import("zod").ZodNumber;
+        fixable: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    changed: import("zod").ZodBoolean;
+    log: import("zod").ZodNullable<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, "health.check">, Context>;
+export declare const repairHealthRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    summary: import("zod").ZodObject<{
+        total: import("zod").ZodNumber;
+        ok: import("zod").ZodNumber;
+        fixed: import("zod").ZodNumber;
+        warn: import("zod").ZodNumber;
+        needsYou: import("zod").ZodNumber;
+        skipped: import("zod").ZodNumber;
+        fixable: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    changed: import("zod").ZodBoolean;
+    log: import("zod").ZodNullable<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, "health.repair">, Context>;
+export declare const enableSandboxRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "health.enableSandbox">, Context>;
+/** The saved results for the menu and the web (the page reads them; nothing is checked). */
+export declare const lastHealthRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    last: import("zod").ZodNullable<import("zod").ZodObject<{
+        at: import("zod").ZodString;
+        mode: import("zod").ZodEnum<{
+            check: "check";
+            repair: "repair";
+        }>;
+        checks: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            group: import("zod").ZodString;
+            name: import("zod").ZodString;
+            status: import("zod").ZodEnum<{
+                fixed: "fixed";
+                ok: "ok";
+                warn: "warn";
+                "needs-you": "needs-you";
+                skipped: "skipped";
+            }>;
+            detail: import("zod").ZodString;
+            means: import("zod").ZodOptional<import("zod").ZodString>;
+            fix: import("zod").ZodOptional<import("zod").ZodString>;
+            plan: import("zod").ZodOptional<import("zod").ZodString>;
+            lines: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            fixable: import("zod").ZodBoolean;
+            timedOut: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            applied: import("zod").ZodOptional<import("zod").ZodObject<{
+                done: import("zod").ZodString;
+                before: import("zod").ZodString;
+                after: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            error: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        summary: import("zod").ZodObject<{
+            total: import("zod").ZodNumber;
+            ok: import("zod").ZodNumber;
+            fixed: import("zod").ZodNumber;
+            warn: import("zod").ZodNumber;
+            needsYou: import("zod").ZodNumber;
+            skipped: import("zod").ZodNumber;
+            fixable: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        details: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodString, import("zod").ZodString], null>>;
+        setup: import("zod").ZodNullable<import("zod").ZodObject<{
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ok: "ok";
+                    warn: "warn";
+                    action: "action";
+                }>;
+                detail: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            canEnable: import("zod").ZodBoolean;
+            error: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        log: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, "health.last">, Context>;