@milesroxas/design-hub 0.0.0-stage → 0.1.1

package/dist/scripts/release-check.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+// The gate before a repo is published: no tracked file may contain a
+// term from the list, case-insensitive (a client's name, a person's name).
+// Tracked means `git ls-files`, so an untracked plan never trips it and a
+// gitignored secret never hides a hit.
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ROOT } from '../server/paths.js';
+import { CliError } from './lib/cli.js';
+export const spec = {
+    name: 'release-check',
+    summary: 'Fail when any tracked file contains one of the given terms.',
+    flags: { term: { type: 'list', description: 'A term to refuse, case-insensitive. Repeat for more.' } },
+    output: '{ ok, terms, files, hits: { <file>: [terms] } }',
+};
+export function main({ flags }) {
+    const terms = flags.term.map((t) => t.toLowerCase()).filter(Boolean);
+    if (!terms.length)
+        throw new CliError('Give at least one --term.');
+    const files = execFileSync('git', ['-C', ROOT, 'ls-files', '-z'], { encoding: 'utf8' })
+        .split('\0')
+        .filter(Boolean);
+    const hits = {};
+    for (const file of files) {
+        let text;
+        try {
+            text = readFileSync(join(ROOT, file), 'utf8').toLowerCase();
+        }
+        catch {
+            continue;
+        }
+        const found = terms.filter((t) => text.includes(t));
+        if (found.length)
+            hits[file] = found;
+    }
+    return { ok: Object.keys(hits).length === 0, terms, files: files.length, hits };
+}

package/dist/scripts/skill-hint.d.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import type { Args } from './lib/cli.ts';
+import { judge } from './lib/judge.ts';
+export declare const spec: {
+    readonly name: 'skill-hint';
+    readonly summary: 'Suggest the miles-* skill for a prompt. Normally runs as the UserPromptSubmit hook.';
+    readonly positionals: [{
+        readonly name: 'prompt';
+        readonly description: 'The prompt to judge';
+        readonly required: true;
+    }];
+    readonly flags: {};
+    readonly output: '{ ok, skill: string | null, gate, fits }';
+};
+export type Skill = {
+    name: string;
+    description: string;
+};
+export declare function roster(dir?: string): Skill[];
+export type Hint = {
+    skill: string | null;
+    gate: number | null;
+    fits: number | null;
+};
+/** `ask` is Jev through the log (lib/judge.ts); tests pass their own. */
+export declare function suggest(prompt: string, skills?: Skill[], ask?: typeof judge): Promise<Hint>;
+export declare function skillHintHook(): Promise<void>;
+export declare const main: ({ positionals }: Args<typeof spec>) => Promise<{
+    skill: string | null;
+    gate: number | null;
+    fits: number | null;
+}>;

package/dist/scripts/skill-hint.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+// The skill hint: a UserPromptSubmit hook (`design-hub hook skill-hint`) that, with TypeSafe on,
+// names the miles-* skill the prompt most likely needs, in one line of
+// context. Off without TYPESAFE_API_KEY, silent on any failure.
+//
+// It follows TypeSafe's skill-suggestion cookbook in one request: a Choice
+// over the skills says which; three gate Nouls about whether the prompt asks
+// for action at all say whether to speak; one `fits` Noul per skill confirms
+// the winner. A Choice has no reliable "none" option, which is why the gates
+// exist. Thresholds: checks.json `skillHint`.
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { reaches } from '../core/checks.js';
+import { frontmatter } from '../core/frontmatter.js';
+import { choiceOf, noulOf } from '../core/jev.js';
+import { checks } from '../server/checks.js';
+import { SKILLS } from '../server/paths.js';
+import { judge } from './lib/judge.js';
+export const spec = {
+    name: 'skill-hint',
+    summary: 'Suggest the miles-* skill for a prompt. Normally runs as the UserPromptSubmit hook.',
+    positionals: [{ name: 'prompt', description: 'The prompt to judge', required: true }],
+    flags: {},
+    output: '{ ok, skill: string | null, gate, fits }',
+};
+// miles-design-hub starts a project from outside one; inside a project it is never the answer.
+const GLOBAL_ONLY = new Set(['miles-design-hub']);
+const MAX_PROMPT_CHARS = 4000;
+const GATES = {
+    acts: "Is the assistant being asked to act on the user's files, project or online services, rather than only to explain or advise?",
+    procedure: 'Would a careful expert answering `request` consult a specific documented procedure or set of commands, rather than answer from general understanding?',
+    prose: "Could a knowledgeable generalist fully satisfy `request` in prose, with no tools, no documentation and no access to the user's files?",
+};
+export function roster(dir = SKILLS) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.startsWith('miles-') && !GLOBAL_ONLY.has(name))
+        .map((name) => join(dir, name, 'SKILL.md'))
+        .filter(existsSync)
+        .map((file) => frontmatter(readFileSync(file, 'utf8')).data)
+        .filter((d) => d.name && d.description)
+        .map((d) => ({ name: d.name, description: d.description }));
+}
+/** `ask` is Jev through the log (lib/judge.ts); tests pass their own. */
+export async function suggest(prompt, skills = roster(), ask = judge) {
+    const none = { skill: null, gate: null, fits: null };
+    if (!checks || !skills.length || !prompt.trim() || prompt.trimStart().startsWith('/'))
+        return none;
+    // A prompt that already names a skill needs no hint.
+    if (skills.some((s) => prompt.includes(s.name)))
+        return none;
+    const questions = {
+        which: {
+            type: 'choice',
+            instructions: 'Which of these skills is the right one to load to help with `request`?',
+            criteria: Object.fromEntries(skills.map((s) => [s.name, s.description])),
+        },
+        ...Object.fromEntries(Object.entries(GATES).map(([k, q]) => [k, { type: 'noul', instructions: q }])),
+        ...Object.fromEntries(skills.map((s) => [
+            `fits:${s.name}`,
+            {
+                type: 'noul',
+                instructions: `Does the skill '${s.name}' do the specific thing \`request\` asks for? It is described as: ${s.description}`,
+            },
+        ])),
+    };
+    const judged = await ask({
+        check: 'skillHint',
+        subject: 'prompt',
+        state: { request: prompt.slice(0, MAX_PROMPT_CHARS) },
+        questions,
+        excerpt: prompt.slice(0, 500),
+    });
+    if (!judged)
+        return none;
+    const [acts, procedure, prose] = ['acts', 'procedure', 'prose'].map((k) => noulOf(judged.answers, k));
+    const which = choiceOf(judged.answers, 'which');
+    if (acts === null || procedure === null || prose === null || !which)
+        return none;
+    const gate = (acts + procedure + (1 - prose)) / 3;
+    const fits = noulOf(judged.answers, `fits:${which.choice}`);
+    const speak = reaches(gate, checks.skillHint.gateAt) && fits !== null && reaches(fits, checks.skillHint.fitsAt);
+    return { skill: speak ? which.choice : null, gate, fits };
+}
+export async function skillHintHook() {
+    let prompt = '';
+    try {
+        prompt = JSON.parse(readFileSync(0, 'utf8')).prompt ?? '';
+    }
+    catch {
+        return;
+    }
+    const { skill, fits } = await suggest(prompt);
+    if (!skill || fits === null)
+        return;
+    const text = `Skill hint: ${skill} looks like the skill for this request (fit ${fits.toFixed(2)}). Load it if its trigger matches; ignore this line if it does not.`;
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: text } }));
+}
+export const main = async ({ positionals }) => ({
+    ...(await suggest(positionals.join(' '))),
+});

package/dist/scripts/skills.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import type { Args } from './lib/cli.ts';
+export declare const spec: {
+    readonly name: 'skills';
+    readonly summary: "Install or update the project's miles-* skills from this package into .claude/skills/.";
+    readonly flags: {};
+    readonly output: '{ ok, installed: [name], into }';
+};
+export declare function installSkills(from?: string, into?: string): string[];
+export declare function main(_args: Args<typeof spec>): {
+    installed: string[];
+    into: string;
+};

package/dist/scripts/skills.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+// `design-hub skills`: the project-facing miles-* skills from this package
+// into the project's .claude/skills/, replacing what is there. The skills
+// ship with the package so a version bump updates them; a project never
+// edits its copies. `miles-design-hub` stays out: it starts a project from
+// outside one and is installed globally.
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { PACKAGE_SKILLS, SKILLS } from '../server/paths.js';
+export const spec = {
+    name: 'skills',
+    summary: "Install or update the project's miles-* skills from this package into .claude/skills/.",
+    flags: {},
+    output: '{ ok, installed: [name], into }',
+};
+const GLOBAL_ONLY = new Set(['miles-design-hub']);
+export function installSkills(from = PACKAGE_SKILLS, into = SKILLS) {
+    const names = readdirSync(from, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && d.name.startsWith('miles-') && !GLOBAL_ONLY.has(d.name))
+        .map((d) => d.name)
+        .sort();
+    mkdirSync(into, { recursive: true });
+    for (const name of names) {
+        const dest = join(into, name);
+        if (existsSync(dest))
+            rmSync(dest, { recursive: true, force: true });
+        cpSync(join(from, name), dest, { recursive: true });
+    }
+    return names;
+}
+export function main(_args) {
+    return { installed: installSkills(), into: SKILLS };
+}

package/dist/scripts/visual-match.d.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { type ImageAsset } from '../core/jev.ts';
+import { type Args } from './lib/cli.ts';
+export declare const spec: {
+    readonly name: 'visual-match';
+    readonly summary: 'Experimental: ask Jev whether a prototype screenshot is missing, adds or reorders elements of its Paper comp.';
+    readonly positionals: [{
+        readonly name: 'prototype';
+        readonly description: 'The prototype slug, for the log';
+        readonly required: true;
+    }];
+    readonly flags: {
+        readonly comp: {
+            readonly type: 'string';
+            readonly required: true;
+            readonly description: 'The Paper frame export (PNG or JPEG).';
+        };
+        readonly shot: {
+            readonly type: 'string';
+            readonly required: true;
+            readonly description: 'The prototype screenshot in the same state (PNG or JPEG).';
+        };
+    };
+    readonly output: '{ ok, experimental, findings: [{ question, p, id }] }';
+};
+export declare const IMAGE_LIMITS: {
+    readonly side: readonly [280, 1568];
+    readonly pixels: readonly [78400, 2458624];
+    readonly bytes: number;
+};
+export declare function asset(path: string, flag: string): ImageAsset;
+export declare function main({ positionals: [prototype], flags }: Args<typeof spec>): Promise<{
+    ok: boolean;
+    error: string;
+    experimental: boolean;
+    findings?: undefined;
+} | {
+    ok?: undefined;
+    error?: undefined;
+    experimental: boolean;
+    findings: {
+        question: "Are the elements in the image `prototype` in a different order or arrangement than in the image `comp`?" | "Does the image `prototype` show an element that the image `comp` does not have?" | "Is any element that is visible in the image `comp` missing from the image `prototype`?";
+        p: number;
+        id: string;
+    }[];
+}>;

package/dist/scripts/visual-match.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+// Experimental, TypeSafe on: compares a Paper frame's export with a
+// screenshot of the prototype in the same state and asks Jev three narrow
+// questions: is an element of the comp missing, is there one the comp does
+// not have, is the order different. It never judges sizes or colours; those
+// come from get_computed_styles, because Jev is weak on numbers and a
+// screenshot drifts by pixels. TypeSafe marks image input as subject to
+// change, so this warns and never blocks. Threshold: checks.json visual.warnAt.
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { extname, resolve } from 'node:path';
+import { reaches } from '../core/checks.js';
+import { imageSize } from '../core/image.js';
+import { noulOf } from '../core/jev.js';
+import { checks } from '../server/checks.js';
+import { CliError } from './lib/cli.js';
+import { judge, typesafeKey } from './lib/judge.js';
+export const spec = {
+    name: 'visual-match',
+    summary: 'Experimental: ask Jev whether a prototype screenshot is missing, adds or reorders elements of its Paper comp.',
+    positionals: [{ name: 'prototype', description: 'The prototype slug, for the log', required: true }],
+    flags: {
+        comp: { type: 'string', required: true, description: 'The Paper frame export (PNG or JPEG).' },
+        shot: {
+            type: 'string',
+            required: true,
+            description: 'The prototype screenshot in the same state (PNG or JPEG).',
+        },
+    },
+    output: '{ ok, experimental, findings: [{ question, p, id }] }',
+};
+// TypeSafe's image limits: each side 280 to 1568 px, 78,400 to 2,458,624 pixels, 16 MiB a file.
+export const IMAGE_LIMITS = {
+    side: [280, 1568],
+    pixels: [78_400, 2_458_624],
+    bytes: 16 * 1024 * 1024,
+};
+const QUESTIONS = {
+    missing: 'Is any element that is visible in the image `comp` missing from the image `prototype`?',
+    extra: 'Does the image `prototype` show an element that the image `comp` does not have?',
+    order: 'Are the elements in the image `prototype` in a different order or arrangement than in the image `comp`?',
+};
+export function asset(path, flag) {
+    const file = resolve(path);
+    if (!existsSync(file))
+        throw new CliError(`${flag} ${path} does not exist.`);
+    if (statSync(file).size > IMAGE_LIMITS.bytes)
+        throw new CliError(`${flag} is over 16 MiB.`);
+    const data = readFileSync(file);
+    const size = imageSize(data);
+    if (!size || !['.png', '.jpg', '.jpeg'].includes(extname(file).toLowerCase()))
+        throw new CliError(`${flag} must be a PNG or JPEG.`, { got: path });
+    const { width, height } = size;
+    const [minSide, maxSide] = IMAGE_LIMITS.side;
+    const [minPx, maxPx] = IMAGE_LIMITS.pixels;
+    if (width < minSide ||
+        height < minSide ||
+        width > maxSide ||
+        height > maxSide ||
+        width * height < minPx ||
+        width * height > maxPx)
+        throw new CliError(`${flag} is ${width}×${height}; TypeSafe takes 280 to 1568 px a side and rejects anything else.`, {
+            fix: `sips -Z ${maxSide} "${path}" on macOS shrinks the long side to ${maxSide} px.`,
+        });
+    return { type: 'image', format: size.format, data_base64: data.toString('base64') };
+}
+export async function main({ positionals: [prototype], flags }) {
+    if (!typesafeKey())
+        throw new CliError('TypeSafe is off.', { fix: 'design-hub bootstrap --typesafe-key <key>' });
+    if (!checks)
+        throw new CliError('checks.json is invalid; every Jev check is off.', {
+            fix: 'design-hub preflight names the problem.',
+        });
+    // Opaque references, as TypeSafe asks: the image travels once in `assets` and is named where it is meant.
+    const comp = randomUUID();
+    const shot = randomUUID();
+    const judged = await judge({
+        check: 'visual',
+        subject: prototype,
+        state: { comp, prototype: shot },
+        assets: { [comp]: asset(flags.comp, '--comp'), [shot]: asset(flags.shot, '--shot') },
+        questions: Object.fromEntries(Object.entries(QUESTIONS).map(([k, q]) => [k, { type: 'noul', instructions: q }])),
+    });
+    if (!judged)
+        return { ok: false, error: 'Jev did not answer; the log has the reason.', experimental: true };
+    const { warnAt } = checks.visual;
+    const findings = Object.keys(QUESTIONS).flatMap((q) => {
+        const p = noulOf(judged.answers, q);
+        return p !== null && reaches(p, warnAt) ? [{ question: QUESTIONS[q], p, id: judged.ids[q] }] : [];
+    });
+    return { experimental: true, findings };
+}

package/dist/server/api.d.ts

@@ -0,0 +1,22 @@
+import type { Checks } from '../core/checks.ts';
+import type { Person } from '../core/review/model.ts';
+import { type Review } from '../core/review/service.ts';
+import { type Gate } from './session.ts';
+export declare const API_PATH = "/api/review";
+export type ApiContext = {
+    review: Review;
+    actor: Person | null;
+};
+export declare function handleReview(request: Request, ctx: ApiContext): Promise<Response>;
+/** The person a request's signed cookie names, while they may still sign in. */
+export declare function actorFrom(request: Request, review: Review, gate: Gate): Promise<Person | null>;
+export type Deployed = {
+    review: Review;
+    gate: Gate;
+} | {
+    error: string;
+};
+/** The review service as deployed: Upstash for the store, Jev for triage when its key is set and `checks` is given. */
+export declare function deployedReview(env: Record<string, string | undefined>, checks?: Checks | null): Deployed;
+/** The Vercel function's whole body; `checks` is the project's checks.json, bundled by its api/review.ts. */
+export declare function deployedHandler(request: Request, checks: Checks | null): Promise<Response>;

package/dist/server/api.js

@@ -0,0 +1,143 @@
+import { SLUG } from '../core/feature.js';
+import { createReview, ReviewError } from '../core/review/service.js';
+import { jevTriager } from '../core/review/triage.js';
+import { PERSON_COOKIE, readCookie, readGate, readPersonToken, sameOrigin } from './session.js';
+import { storeConfig, upstashKV } from './upstash.js';
+export const API_PATH = '/api/review';
+const MAX_BODY_BYTES = 64 * 1024;
+const STATUS = {
+    unauthorized: 401,
+    forbidden: 403,
+    not_found: 404,
+    invalid: 422,
+};
+const json = (status, body) => new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' },
+});
+/** What the browser may see of a person: everything but the session epoch. */
+const visible = ({ epoch: _epoch, ...p }) => p;
+const str = (v) => (typeof v === 'string' ? v : '');
+function prototypeOf(v) {
+    const s = str(v);
+    if (!SLUG.test(s))
+        throw new ReviewError('invalid', 'Name the prototype.', ['prototype: a prototype slug']);
+    return s;
+}
+async function query(op, params, { review, actor }) {
+    switch (op) {
+        case 'me':
+            return { person: actor ? visible(actor) : null };
+        case 'comments':
+            return { comments: await review.listComments(actor, prototypeOf(params.get('prototype'))) };
+        case 'people':
+            return { people: (await review.listPeople(actor)).map(visible) };
+        default:
+            return undefined;
+    }
+}
+async function command(op, b, { review, actor }) {
+    const at = () => ({ prototype: prototypeOf(b.prototype), id: str(b.id) });
+    const link = (r) => ({
+        person: visible(r.person),
+        link: `/invite/${r.token}`,
+    });
+    switch (op) {
+        case 'comment.add':
+            return { comment: await review.add(actor, { body: b.body, anchor: b.anchor, states: b.states }) };
+        case 'comment.reply':
+            return {
+                comment: await review.reply(actor, {
+                    prototype: prototypeOf(b.prototype),
+                    thread: str(b.thread),
+                    body: b.body,
+                }),
+            };
+        case 'comment.edit':
+            return { comment: await review.edit(actor, { ...at(), body: b.body }) };
+        case 'comment.remove':
+            return { removed: await review.remove(actor, at()) };
+        case 'comment.resolve':
+            return { comment: await review.resolve(actor, { ...at(), resolved: b.resolved === true }) };
+        case 'comment.triage':
+            return { comment: await review.retriage(actor, { ...at(), triage: b.triage, states: b.states }) };
+        case 'people.invite':
+            return link(await review.invite(actor, { name: b.name, team: b.team, role: b.role }));
+        case 'people.reissue':
+            return link(await review.reissue(actor, str(b.id)));
+        case 'people.revoke':
+            return { person: visible(await review.revoke(actor, str(b.id))) };
+        default:
+            return undefined;
+    }
+}
+async function readJson(request) {
+    if (!(request.headers.get('content-type') ?? '').startsWith('application/json'))
+        return null;
+    const text = await request.text();
+    if (new TextEncoder().encode(text).length > MAX_BODY_BYTES)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleReview(request, ctx) {
+    try {
+        if (request.method === 'GET') {
+            const params = new URL(request.url).searchParams;
+            const result = await query(params.get('op') ?? '', params, ctx);
+            return result === undefined ? json(400, { error: 'Unknown query.' }) : json(200, result);
+        }
+        if (request.method === 'POST') {
+            // JSON only and same origin: a cross-site form cannot send JSON without a CORS preflight, which this never answers.
+            if (!sameOrigin(request))
+                return json(403, { error: 'Cross-origin request refused.' });
+            const body = await readJson(request);
+            if (!body)
+                return json(400, { error: `Send a JSON object of ${MAX_BODY_BYTES / 1024} KB or less.` });
+            const result = await command(str(body.op), body, ctx);
+            return result === undefined ? json(400, { error: 'Unknown command.' }) : json(200, result);
+        }
+        return new Response('Method not allowed', { status: 405, headers: { allow: 'GET, POST' } });
+    }
+    catch (error) {
+        if (error instanceof ReviewError)
+            return json(STATUS[error.code], { error: error.message, problems: error.problems });
+        console.error('[review]', error);
+        return json(500, { error: 'The review store did not answer. Try again.' });
+    }
+}
+/** The person a request's signed cookie names, while they may still sign in. */
+export async function actorFrom(request, review, gate) {
+    const claim = await readPersonToken(gate, readCookie(request, PERSON_COOKIE));
+    return claim ? review.sessionPerson(claim.id, claim.epoch) : null;
+}
+/** The review service as deployed: Upstash for the store, Jev for triage when its key is set and `checks` is given. */
+export function deployedReview(env, checks = null) {
+    const gate = readGate(env);
+    if (!gate)
+        return { error: 'The prototype gate is not configured.' };
+    const store = storeConfig(env);
+    if (!store)
+        return { error: 'Review is not set up on this site: pnpm bootstrap --vercel <project> --review.' };
+    return {
+        gate,
+        review: createReview(upstashKV(store), { triage: jevTriager(env.TYPESAFE_API_KEY ?? '', checks) }),
+    };
+}
+/** The Vercel function's whole body; `checks` is the project's checks.json, bundled by its api/review.ts. */
+export async function deployedHandler(request, checks) {
+    const setup = deployedReview(process.env, checks);
+    if ('error' in setup)
+        return json(503, { error: setup.error });
+    return handleReview(request, {
+        review: setup.review,
+        actor: await actorFrom(request, setup.review, setup.gate),
+    });
+}

package/dist/server/checks.d.ts

@@ -0,0 +1,4 @@
+import { type Checks } from '../core/checks.ts';
+export declare const checkProblems: string[];
+/** The validated thresholds, or null when checks.json is invalid (every Jev check is then off). */
+export declare const checks: Checks | null;

package/dist/server/checks.js

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+// The project's checks, read once: .design-hub/checks.json when the project
+// has one, the package defaults when it does not. The scripts and the dev
+// server import `checks` from here; the Vercel function gets its copy bundled
+// by the project's api/review.ts.
+import { existsSync, readFileSync } from 'node:fs';
+import { DEFAULT_CHECKS, loadChecks } from '../core/checks.js';
+import { CHECKS_FILE } from './paths.js';
+function readChecks(file = CHECKS_FILE) {
+    if (!existsSync(file))
+        return { checks: DEFAULT_CHECKS, problems: [] };
+    try {
+        return loadChecks(JSON.parse(readFileSync(file, 'utf8')));
+    }
+    catch (error) {
+        return { checks: null, problems: [`${file}: ${error instanceof Error ? error.message : String(error)}`] };
+    }
+}
+const loaded = readChecks();
+export const checkProblems = loaded.problems;
+/** The validated thresholds, or null when checks.json is invalid (every Jev check is then off). */
+export const checks = loaded.checks;

package/dist/server/dev.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function devReview(): Plugin;

package/dist/server/dev.js

@@ -0,0 +1,54 @@
+import { createReview } from '../core/review/service.js';
+import { KEY } from '../core/review/store.js';
+import { jevTriager } from '../core/review/triage.js';
+import { API_PATH, handleReview } from './api.js';
+import { checks } from './checks.js';
+import { readEnv } from './env.js';
+import { fileKV } from './file-kv.js';
+import { LOCAL_STORE, localEditor } from './local.js';
+import { ROOT } from './paths.js';
+// Connect strips the mount path from req.url; originalUrl keeps the query the handler reads.
+async function toRequest(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    const headers = new Headers();
+    for (const [k, v] of Object.entries(req.headers))
+        if (typeof v === 'string')
+            headers.set(k, v);
+    const body = chunks.length ? Buffer.concat(chunks) : undefined;
+    return new Request(`http://${req.headers.host ?? 'localhost'}${req.originalUrl ?? req.url}`, {
+        method: req.method,
+        headers,
+        body: req.method === 'GET' || req.method === 'HEAD' ? undefined : body,
+    });
+}
+async function send(res, response) {
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+    });
+    res.end(Buffer.from(await response.arrayBuffer()));
+}
+export function devReview() {
+    return {
+        name: 'dev-review',
+        apply: 'serve',
+        configureServer(server) {
+            const kv = fileKV(LOCAL_STORE);
+            // The project's .env only, never the shell: TypeSafe is on only where the project opted in.
+            const review = createReview(kv, {
+                triage: jevTriager(readEnv(ROOT).TYPESAFE_API_KEY ?? '', checks),
+            });
+            const actor = localEditor();
+            // The local editor is in the people list like anyone else, so the people panel shows them.
+            void kv.hset(KEY.people, actor.id, JSON.stringify(actor));
+            server.middlewares.use(API_PATH, (req, res, nextMiddleware) => {
+                toRequest(req)
+                    .then((request) => handleReview(request, { review, actor }))
+                    .then((response) => send(res, response))
+                    .catch(nextMiddleware);
+            });
+        },
+    };
+}

package/dist/server/env.d.ts

@@ -0,0 +1,8 @@
+export declare function readEnv(dir: string): Record<string, string>;
+export declare function writeEnv(dir: string, updates: Record<string, string>): void;
+/**
+ * The dev server's port. Inside a Conductor workspace, Conductor's own port
+ * wins, because its Open button always points there; everywhere else it is
+ * the PORT that `pnpm bootstrap` wrote to .env.
+ */
+export declare function devPort(fileEnv: Record<string, string>, processEnv?: Record<string, string | undefined>): number | undefined;