youiyoux 0.1.2 → 0.1.4

package/dist/chunks/{src-7ENJHYG4.js → chunk-RDTHHRZN.js}

@@ -1,21 +1,24 @@
-import { createRequire as __youiRequire } from "node:module"; const require = __youiRequire(import.meta.url);
+import { createRequire as __youiRequire } from "node:module"; import { dirname as __youiDir } from "node:path"; import { fileURLToPath as __youiPath } from "node:url"; const require = __youiRequire(import.meta.url); const __youiDirname = __youiDir(__youiPath(import.meta.url));
 import {
+  PICTURE_SCALE,
   SCANNER_VERSION,
-  buildTokens,
   checkInputFor,
-  contrastText,
-  cssValue,
-  gradePairs,
   loadProject,
-  resolverLayout,
-  ringOffset,
   ruleCapability,
   runChecks,
   scanProject,
-  systemPairs,
+  screenSlug,
   tokenImpact
-} from "./chunk-3ZHGONNA.js";
-import "./chunk-S7UV34H5.js";
+} from "./chunk-52KOKYY6.js";
+import {
+  buildTokens,
+  contrastText,
+  cssValue,
+  gradePairs,
+  resolverLayout,
+  ringOffset,
+  systemPairs
+} from "./chunk-YJ7WMBTT.js";
 import {
   BUILT_IN_CHECKS,
   COMPONENT_STATES,
@@ -23,6 +26,10 @@ import {
   ElementId,
   LIBRARY_DIR,
   LibraryEntry,
+  REQUEST_ID,
+  REQUEST_STATUSES,
+  RequestDoc,
+  RequestTarget,
   RuleCheck,
   RuleRollout,
   RuleSpec,
@@ -38,10 +45,10 @@ import {
   toPosix,
   tokenValueProblems,
   writeFileAtomic
-} from "./chunk-ZLRFD5JI.js";
+} from "./chunk-NYDJYMID.js";
 import {
   __toESM
-} from "./chunk-E4HNK7VF.js";
+} from "./chunk-WNTS7ZO4.js";
 
 // ../workflow/src/design-files.ts
 var import_yaml2 = __toESM(require_dist(), 1);
@@ -356,10 +363,10 @@ async function git(cwd, args, options = {}) {
   }
 }
 function gitWithInput(cwd, args, options) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const child = execFile("git", args, { cwd, maxBuffer: MAX_BUFFER, env: { ...process.env, ...options.env } }, (error, stdout, stderr) => {
       if (error) reject(Object.assign(error, { stderr }));
-      else resolve2(stdout);
+      else resolve(stdout);
     });
     child.stdin?.end(options.input);
   });
@@ -407,12 +414,8 @@ async function isAncestor(top, commit, tip) {
     return false;
   }
 }
-async function listAt(top, commit, dir) {
-  const out = await gitOrNull(top, ["ls-tree", "--name-only", `${commit}:${dir}`]);
-  return out ? out.split("\n").filter(Boolean) : [];
-}
-async function listTreeAt(top, commit, dir) {
-  const out = await gitOrNull(top, ["ls-tree", "-r", "--name-only", `${commit}:${dir}`]);
+async function listAt(top, commit, dir, options = {}) {
+  const out = await gitOrNull(top, ["ls-tree", ...options.recursive ? ["-r"] : [], "--name-only", `${commit}:${dir}`]);
   return out ? out.split("\n").filter(Boolean) : [];
 }
 async function hasChanges(top, paths) {
@@ -436,14 +439,14 @@ async function fileDigest(file) {
   return sha256(await readFile(file));
 }
 function streamDigest(cwd, args) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
     const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stderr = "";
     child.stdout.on("data", (chunk) => hash.update(chunk));
     child.stderr.on("data", (chunk) => stderr += chunk.toString());
     child.on("error", reject);
-    child.on("close", (code) => code === 0 ? resolve2(hash.digest("hex")) : reject(new GitError(`git ${args.join(" ")} failed in ${cwd}: ${stderr.trim()}`)));
+    child.on("close", (code) => code === 0 ? resolve(hash.digest("hex")) : reject(new GitError(`git ${args.join(" ")} failed in ${cwd}: ${stderr.trim()}`)));
   });
 }
 var FALLBACK_IDENTITY = { name: "YouIyouX rule editor", email: "rule-editor@youiyoux.local" };
@@ -685,8 +688,10 @@ var DesignFiles = class {
   }
   /** The path a rule lives at, or would be created at. */
   async rulePath(commit, ruleId) {
-    const existing = (await this.ruleFiles(commit)).get(ruleId);
-    if (existing) return existing.path;
+    return (await this.ruleFiles(commit)).get(ruleId)?.path ?? this.newRulePath(ruleId);
+  }
+  /** Where a rule not in the design repository yet is created. */
+  newRulePath(ruleId) {
     return `${this.rulesDir}/${parseId(ruleId)?.name ?? "new-rule"}.rule.yaml`;
   }
   async contractPath(commit, componentId) {
@@ -712,7 +717,7 @@ var DesignFiles = class {
     const existing = rules.get(rule.id);
     const sibling = [...rules.values()][0]?.text;
     const schemaRef = (sibling ? (0, import_yaml2.parse)(sibling)?.$schema : void 0) ?? DEFAULT_SCHEMA_REF;
-    const path = existing?.path ?? await this.rulePath(commit, rule.id);
+    const path = existing?.path ?? this.newRulePath(rule.id);
     const files = {};
     const ruleText = renderRuleYaml(rule, existing?.text ?? null, schemaRef);
     if (ruleText !== existing?.text) files[path] = ruleText;
@@ -735,7 +740,7 @@ var DesignFiles = class {
   /** Every file in the tokens directory at `commit` (design-root-relative path → text): what a token build reads. */
   async tokenTree(commit) {
     const dir = this.tokensDir;
-    const names = await listTreeAt(this.repo.top, commit, this.top(dir));
+    const names = await listAt(this.repo.top, commit, this.top(dir), { recursive: true });
     const entries = await Promise.all(names.map(async (name) => [`${dir}/${name}`, await this.read(commit, `${dir}/${name}`) ?? ""]));
     return new Map(entries);
   }
@@ -801,11 +806,10 @@ var scannerExecution = {
 // ../workflow/src/http.ts
 import { createServer } from "node:http";
 import { timingSafeEqual } from "node:crypto";
-import { readFile as readFile2, stat } from "node:fs/promises";
-import { extname, join as join3, normalize, resolve, sep } from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
 
 // ../workflow/src/policy.ts
-var PERSON_ONLY = /* @__PURE__ */ new Set(["approve", "handoff"]);
+var PERSON_ONLY = /* @__PURE__ */ new Set(["approve", "handoff", "close"]);
 var WorkflowError = class extends Error {
   name = "WorkflowError";
   code;
@@ -817,7 +821,7 @@ var WorkflowError = class extends Error {
   }
 };
 function authorize(actor, action) {
-  if (PERSON_ONLY.has(action) && actor.kind !== "person") throw new WorkflowError("forbidden", `an ${actor.kind} cannot ${action}: approving a design change is a person's decision`);
+  if (PERSON_ONLY.has(action) && actor.kind !== "person") throw new WorkflowError("forbidden", action === "close" ? `an ${actor.kind} cannot close or reopen a request: mark it addressed, and a person closes it` : `an ${actor.kind} cannot ${action}: approving a design change is a person's decision`);
 }
 
 // ../workflow/src/http.ts
@@ -846,22 +850,14 @@ var CreateInput = external_exports.union([
   external_exports.discriminatedUnion("mode", [external_exports.object({ kind: external_exports.literal("rule").optional(), mode: external_exports.literal("edit"), ruleId: ElementId }), external_exports.object({ kind: external_exports.literal("rule").optional(), mode: external_exports.literal("create") })])
 ]);
 var SaveInput = external_exports.object({ revision: external_exports.number().int().positive(), content: external_exports.union([DraftContentInput, StyleContentInput, LibraryContentInput]) });
+var RequestInput = external_exports.object({ kind: external_exports.enum(["comment", "change"]), body: external_exports.string().min(1).max(4e3), target: RequestTarget });
+var ReplyInput = external_exports.object({ body: external_exports.string().min(1).max(4e3) });
+var StatusInput = external_exports.object({ status: external_exports.enum(REQUEST_STATUSES), body: external_exports.string().max(4e3).optional() });
 function styleContent(content) {
   return { ...content, tokens: content.tokens.map((t) => Object.fromEntries(Object.entries(t).filter(([, v]) => v !== void 0))) };
 }
 var ApproveInput = external_exports.object({ revision: external_exports.number().int().positive(), previewId: external_exports.string().min(1).max(40), acknowledgeContrast: external_exports.array(external_exports.string().min(1).max(600)).max(1e3).optional() });
 var STATUS = { "bad-request": 400, forbidden: 403, "not-found": 404, conflict: 409, stale: 409, invalid: 422, internal: 500 };
-var TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  ".png": "image/png",
-  ".woff2": "font/woff2",
-  ".ico": "image/x-icon"
-};
 var LOOPBACK_HOST = /^(?:127\.0\.0\.1|localhost|\[::1\])(?::\d+)?$/;
 var LOOPBACK_ORIGIN = /^http:\/\/(?:127\.0\.0\.1|localhost|\[::1\])(?::\d+)?$/;
 var BASE_HEADERS = { "x-content-type-options": "nosniff", "x-frame-options": "DENY", "content-security-policy": "frame-ancestors 'none'" };
@@ -927,6 +923,31 @@ async function api(req, res, path, options) {
     if ("kind" in input && input.kind === "library") return send(res, 201, await workflow.create(actor, { kind: "library", content: input.content }));
     return send(res, 201, await workflow.create(actor, "kind" in input && input.kind === "style" ? { kind: "style", ...input.content ? { content: styleContent(input.content) } : {} } : input));
   }
+  if (path === "/api/requests" && method === "GET") return send(res, 200, await (await workflow.requests()).list());
+  if (path === "/api/requests" && method === "POST") return send(res, 201, await (await workflow.requests()).create(actor, parse2(RequestInput, await readJson(req))));
+  const request = /^\/api\/requests\/(r-[0-9a-f]{10})(?:\/(replies|status|compare|before\.webp|after\.webp))?$/.exec(path);
+  if (request) {
+    const [, id, action] = request;
+    const store = await workflow.requests();
+    if (!action && method === "GET") return send(res, 200, await store.get(id));
+    if (action === "compare" && method === "GET") {
+      const { before, after } = await store.compare(id);
+      const view = (picture, which) => picture ? { ...picture, file: void 0, url: `/api/requests/${id}/${which}.webp` } : null;
+      return send(res, 200, { before: view(before, "before"), after: view(after, "after") });
+    }
+    if ((action === "before.webp" || action === "after.webp") && method === "GET") {
+      const picture = (await store.compare(id))[action === "before.webp" ? "before" : "after"];
+      if (!picture) throw new WorkflowError("not-found", `${id} has no ${action.replace(".webp", "")} picture`);
+      res.writeHead(200, { ...BASE_HEADERS, "content-type": "image/webp", "cache-control": "no-store" });
+      res.end(await readFile2(picture.file));
+      return;
+    }
+    if (action === "replies" && method === "POST") return send(res, 200, await store.reply(actor, id, parse2(ReplyInput, await readJson(req)).body));
+    if (action === "status" && method === "POST") {
+      const input = parse2(StatusInput, await readJson(req));
+      return send(res, 200, await store.setStatus(actor, id, input.status, input.body ?? ""));
+    }
+  }
   const match = /^\/api\/drafts\/(d-[0-9a-f]{10})(?:\/(preview|approve|rebase|handoff))?$/.exec(path);
   if (match) {
     const id = match[1];
@@ -944,27 +965,6 @@ async function api(req, res, path, options) {
   }
   throw new WorkflowError("not-found", `no endpoint ${method} ${path}`);
 }
-async function staticFile(res, root, path) {
-  const base = resolve(root);
-  let decoded;
-  try {
-    decoded = decodeURIComponent(path);
-  } catch {
-    throw new HttpError(400, "malformed path");
-  }
-  const wanted = resolve(base, `.${normalize(decoded)}`);
-  if (wanted !== base && !wanted.startsWith(`${base}${sep}`)) throw new HttpError(404, "not found");
-  let file = wanted;
-  const info = await stat(file).catch(() => null);
-  if (!info?.isFile()) {
-    if (extname(path) in TYPES || /\.(?:map|txt)$/.test(path)) throw new HttpError(404, "not found");
-    file = join3(base, "index.html");
-  }
-  const body = await readFile2(file);
-  const immutable = file.includes(`${sep}assets${sep}`);
-  res.writeHead(200, { ...BASE_HEADERS, "content-type": TYPES[extname(file)] ?? "application/octet-stream", "cache-control": immutable ? "public, max-age=31536000, immutable" : "no-cache" });
-  res.end(body);
-}
 function createHandler(options) {
   return (req, res) => {
     void (async () => {
@@ -972,8 +972,7 @@ function createHandler(options) {
         const path = new URL(req.url ?? "/", "http://loopback").pathname;
         screen(req, options.sessionKey);
         if (path === "/api" || path.startsWith("/api/")) return await api(req, res, path, options);
-        if (!options.webRoot || req.method !== "GET" && req.method !== "HEAD") throw new HttpError(404, "not found");
-        await staticFile(res, options.webRoot, path);
+        throw new HttpError(404, "not found");
       } catch (error) {
         fail(res, error);
       }
@@ -1059,7 +1058,7 @@ var ORDER = { new: 0, kept: 1, resolved: 2 };
 function finding(v, change) {
   return { file: v.file, line: v.line, column: v.column, text: v.text, message: v.message, ...v.suggestion ? { suggestion: v.suggestion } : {}, severity: v.severity, change };
 }
-var notRun = (run2) => run2 && (run2.state === "unsupported" || run2.state === "error") ? run2.reason ?? run2.state : null;
+var notRunReason = (run2) => run2 && (run2.state === "unsupported" || run2.state === "error") ? run2.reason ?? run2.state : null;
 function limitsOf(rule, baseline, scan, flagged, kept, baselineNotRun) {
   const limits = [];
   if (baselineNotRun) limits.push(`The published rule could not run on this snapshot (${baselineNotRun}), so nothing counts as already flagged or no longer flagged.`);
@@ -1077,10 +1076,10 @@ function limitsOf(rule, baseline, scan, flagged, kept, baselineNotRun) {
 function comparePreview(input) {
   const { project, scan, execution, draft, baseline } = input;
   const next = execution.evaluate(project, scan, [draft]);
-  const draftNotRun = notRun(next.checks[0]);
+  const draftNotRun = notRunReason(next.checks[0]);
   if (draftNotRun) throw new WorkflowError("invalid", `the draft's check did not run: ${draftNotRun}`, [`check: ${draftNotRun}`]);
   const published = baseline ? execution.evaluate(project, scan, [baseline]) : null;
-  const baselineNotRun = notRun(published?.checks[0]);
+  const baselineNotRun = notRunReason(published?.checks[0]);
   const before = published && !baselineNotRun ? published.violations : [];
   const beforeKeys = new Set(before.map(keyOf));
   const nextKeys = new Set(next.violations.map(keyOf));
@@ -1101,11 +1100,173 @@ function comparePreview(input) {
   };
 }
 
-// ../workflow/src/service.ts
+// ../workflow/src/requests.ts
 import { randomBytes } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import { copyFile, mkdir, readdir, readFile as readFile3, stat } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var REQUESTS_DIR = ".youi/requests";
+var FILE = /^(r-[0-9a-f]{10})\.json$/;
+var authorOf = (actor) => ({ kind: actor.kind, name: actor.name });
+var screensDir = (root) => join3(root, ".youi/screens");
+var filedAt = (request) => request.thread.filter((e) => e.status === "open").at(-1)?.at ?? request.createdAt;
+var RequestStore = class {
+  dir;
+  root;
+  project;
+  options;
+  /** `root`: the product's root, where `.youi/` lives; `project`: its id. */
+  constructor(root, project, options = {}) {
+    this.dir = join3(root, REQUESTS_DIR);
+    this.root = root;
+    this.project = project;
+    this.options = options;
+  }
+  now() {
+    return (this.options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  }
+  file(id) {
+    if (!REQUEST_ID.test(id)) throw new WorkflowError("bad-request", `"${id.slice(0, 40)}" is not a request id (r-<10 hex>)`);
+    return join3(this.dir, `${id}.json`);
+  }
+  async write(request) {
+    const checked = RequestDoc.parse(request);
+    await writeFileAtomic(this.file(checked.id), `${JSON.stringify(checked, null, 2)}
+`);
+    return checked;
+  }
+  /** Every request, newest first. */
+  async list() {
+    const names = await readdir(this.dir).catch(() => []);
+    const requests = [];
+    const unreadable = [];
+    for (const name of names.sort()) {
+      const match = FILE.exec(name);
+      if (!match) continue;
+      const file = join3(REQUESTS_DIR, name);
+      let value;
+      try {
+        value = JSON.parse(await readFile3(join3(this.dir, name), "utf8"));
+      } catch (error) {
+        unreadable.push({ file, reason: error instanceof Error ? error.message.split("\n")[0] : String(error) });
+        continue;
+      }
+      const result = RequestDoc.safeParse(value);
+      if (!result.success) unreadable.push({ file, reason: result.error.issues.map((i) => `${i.path.join(".") || "file"}: ${i.message}`).join("; ") });
+      else if (result.data.id !== match[1]) unreadable.push({ file, reason: "its id is not its file name" });
+      else requests.push(result.data);
+    }
+    requests.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || a.id.localeCompare(b.id));
+    return { requests, unreadable };
+  }
+  async get(id) {
+    const text = await readFile3(this.file(id), "utf8").catch(() => null);
+    if (text === null) throw new WorkflowError("not-found", `no request ${id}`);
+    const parsed = RequestDoc.safeParse(JSON.parse(text));
+    if (!parsed.success) throw new WorkflowError("invalid", `${REQUESTS_DIR}/${id}.json is not a valid youi.request/v1`, parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`));
+    return parsed.data;
+  }
+  async create(actor, input) {
+    authorize(actor, "draft");
+    const body = input.body.trim();
+    if (!body) throw new WorkflowError("invalid", "a request needs words: what to look at, or what to change");
+    const at = this.now();
+    const id = (this.options.newId ?? (() => `r-${randomBytes(5).toString("hex")}`))();
+    const shot = join3(screensDir(this.root), `${screenSlug(input.target.route)}.light.webp`);
+    let before;
+    if (existsSync(shot)) {
+      before = `${id}.before.webp`;
+      await mkdir(this.dir, { recursive: true });
+      await copyFile(shot, join3(this.dir, before));
+    }
+    return this.write({ schema: "youi.request/v1", id, project: this.project, kind: input.kind, status: "open", body, author: authorOf(actor), createdAt: at, updatedAt: at, target: input.target, ...before ? { before } : {}, thread: [] });
+  }
+  async reply(actor, id, body) {
+    authorize(actor, "draft");
+    const text = body.trim();
+    if (!text) throw new WorkflowError("invalid", "a reply needs words");
+    const request = await this.get(id);
+    const at = this.now();
+    return this.write({ ...request, updatedAt: at, thread: [...request.thread, { author: authorOf(actor), at, body: text }] });
+  }
+  /**
+   * Before and after for a request: the picture kept when it was filed, and the screen's picture
+   * now, with the component found again on it by its file and line (from the new capture's places).
+   */
+  async compare(id) {
+    const request = await this.get(id);
+    const t = request.target;
+    const before = request.before === `${request.id}.before.webp` && existsSync(join3(this.dir, request.before)) ? { file: join3(this.dir, request.before), box: t.box ?? null, page: t.page ?? null, at: request.createdAt } : null;
+    const slug = screenSlug(t.route);
+    const shot = join3(screensDir(this.root), `${slug}.light.webp`);
+    const info = await stat(shot).catch(() => null);
+    if (!info) return { before, after: null };
+    let box = t.box ?? null;
+    let page = t.page ?? null;
+    let found = false;
+    try {
+      const places = JSON.parse(await readFile3(join3(screensDir(this.root), `${slug}.places.json`), "utf8"));
+      const again = t.file && t.line ? places.places?.find((p) => p.file === t.file && p.line === t.line && p.name === t.name) : void 0;
+      if (places.size) page = places.size;
+      if (again) {
+        box = again.box;
+        found = true;
+      }
+    } catch {
+    }
+    const at = info.mtime.toISOString();
+    return { before, after: { file: shot, box, page, at, sinceFiled: at > filedAt(request), found } };
+  }
+  /**
+   * Move a request on: `addressed` (anyone; an agent says what it did), or `closed` and `open`
+   * (a person's: closing accepts the work, reopening says it is not done).
+   */
+  async setStatus(actor, id, status, body = "") {
+    if (status !== "addressed") authorize(actor, "close");
+    else authorize(actor, "draft");
+    const request = await this.get(id);
+    if (request.status === status) throw new WorkflowError("conflict", `${id} is already ${status}`);
+    if (status === "addressed" && request.status === "closed") throw new WorkflowError("conflict", `${id} is closed: a person reopens it first`);
+    const at = this.now();
+    return this.write({ ...request, status, updatedAt: at, thread: [...request.thread, { author: authorOf(actor), at, body: body.trim(), status }] });
+  }
+};
+function requestBrief(request, root) {
+  const t = request.target;
+  const picture = join3(root, ".youi/screens", `${screenSlug(t.route)}.light.webp`);
+  const at = t.file && t.line ? `${t.file}:${t.line}` : null;
+  const every = t.scope === "element" && t.element;
+  const where = every ? `every use of ${t.element} (system_where_used lists them)` : at ? `${at}` : `the ${t.name} on ${t.route} (its line was not captured: find it from the picture and the route)`;
+  const shot = existsSync(picture) ? statSync(picture).mtime.toISOString() : null;
+  const recaptured = shot === null ? null : shot > filedAt(request);
+  const capture = `screens_capture with route ${t.route} (or youiyoux screens capture --base <the app in development> --route ${t.route})`;
+  const next = request.status === "closed" ? "Closed by a person: nothing to do." : request.status === "addressed" && recaptured === false ? `Marked addressed, but ${t.route} has not been captured since this was filed, so the person compares against the old picture: run ${capture}. A person then checks it and closes or reopens it.` : request.status === "addressed" ? "Marked addressed: a person checks it and closes or reopens it. Reply only if asked." : request.kind === "comment" ? `A comment on ${where}: reply with request_reply if it asks something; change code only if it asks for a change.` : `Make the change at ${where}${t.lookalike && t.element ? `, using the System's ${t.element} rather than the hand-built lookalike where that is the fix` : ""}; capture the screen again (${capture}) so the person sees it after; then call request_addressed with what you changed (file:line). Ask with request_reply first if it is unclear. A person closes it.`;
+  return {
+    id: request.id,
+    kind: request.kind,
+    status: request.status,
+    ask: request.body,
+    from: `${request.author.kind} ${request.author.name}`,
+    createdAt: request.createdAt,
+    route: t.route,
+    component: t.name,
+    element: t.element ?? null,
+    lookalike: t.lookalike === true,
+    at,
+    scope: every ? `everywhere ${t.element} is used` : "this one, on this screen",
+    picture: existsSync(picture) ? picture : null,
+    recaptured,
+    box: t.box ? { x: Math.round(t.box.x * PICTURE_SCALE), y: Math.round(t.box.y * PICTURE_SCALE), width: Math.round(t.box.width * PICTURE_SCALE), height: Math.round(t.box.height * PICTURE_SCALE) } : null,
+    thread: request.thread.map((e) => `${e.author.kind} ${e.author.name}${e.status ? ` (marked ${e.status})` : ""}: ${e.body || "(no words)"}`),
+    next
+  };
+}
+
+// ../workflow/src/service.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
 
 // ../workflow/src/style-preview.ts
-import { mkdir, mkdtemp as mkdtemp2, rm as rm2, writeFile } from "node:fs/promises";
+import { mkdir as mkdir2, mkdtemp as mkdtemp2, rm as rm2, writeFile } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname, join as join4 } from "node:path";
 var MAX_LISTED = 5e3;
@@ -1113,7 +1274,7 @@ async function buildFrom(project, tree) {
   const root = await mkdtemp2(join4(tmpdir2(), "youi-style-"));
   try {
     for (const [path, text] of tree) {
-      await mkdir(dirname(join4(root, path)), { recursive: true });
+      await mkdir2(dirname(join4(root, path)), { recursive: true });
       await writeFile(join4(root, path), text);
     }
     return (await buildTokens(root, project.system.config, project.config.outputs)).tokens;
@@ -1271,7 +1432,8 @@ function previewSummary(draft) {
   const p = draft.preview;
   return p ? `changes ${p.totals.tokens} token(s) and ${p.totals.contracts} component(s): ${p.totals.sites} site(s) and ${p.totals.direct} direct use(s) in ${p.totals.files} file(s) on ${p.totals.routes} screen(s)` : "no preview";
 }
-var randomId = (prefix) => `${prefix}-${randomBytes(5).toString("hex")}`;
+var capitalized = (text) => `${text[0].toUpperCase()}${text.slice(1)}`;
+var randomId = (prefix) => `${prefix}-${randomBytes2(5).toString("hex")}`;
 var RuleWorkflow = class {
   options;
   execution;
@@ -1282,6 +1444,26 @@ var RuleWorkflow = class {
     this.options = options;
     this.execution = options.execution ?? scannerExecution;
   }
+  /** The product's comments and change requests on its captured screens (requests.ts), in its `.youi/requests`. */
+  async requests() {
+    const project = await this.project();
+    return new RequestStore(project.root, project.config.id, this.options.now ? { now: this.options.now } : {});
+  }
+  /** The project and its design definitions, as they are on disk now. */
+  project() {
+    const { projectRoot, configPath, designRoot, productRoot } = this.options;
+    return loadProject(projectRoot, { ...configPath ? { configPath } : {}, ...designRoot ? { designRoot } : {}, ...productRoot ? { productRoot } : {} });
+  }
+  /** What every kind of preview starts with: the draft revision and snapshot it read, and how long it took. */
+  previewHead(draft, before, started) {
+    return { id: this.id("p"), at: this.now(), draftRevision: draft.revision, draftDigest: draft.digest, snapshot: before.snapshot, durationMs: Math.round(performance.now() - started) };
+  }
+  /** The design repository and project now, refused when they moved since `before` (while a preview ran). */
+  async unchangedSince(before) {
+    const after = await this.current();
+    if (after.snapshot.digest !== before.snapshot.digest) throw new WorkflowError("stale", "the project or design repository changed while the preview ran; run it again");
+    return after;
+  }
   now() {
     return (this.options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
   }
@@ -1300,8 +1482,7 @@ var RuleWorkflow = class {
     }
   }
   async current() {
-    const { projectRoot, configPath, designRoot, productRoot } = this.options;
-    const project = await loadProject(projectRoot, { ...configPath ? { configPath } : {}, ...designRoot ? { designRoot } : {}, ...productRoot ? { productRoot } : {} });
+    const project = await this.project();
     const repo = await locate(project.repo.root);
     if (!repo) throw new WorkflowError("invalid", `the design definitions at ${project.repo.root} are not in a git repository; drafts need a commit to start from`);
     const branch = await defaultBranch(repo.top);
@@ -1446,13 +1627,13 @@ var RuleWorkflow = class {
       current.project.system.rules.map(async (rule) => {
         const places = scan.report.violations.filter((v) => v.rule === rule.id);
         const run2 = scan.report.checks.find((c) => c.rule === rule.id);
-        const notRun2 = run2 && (run2.state === "unsupported" || run2.state === "error") ? run2.reason ?? run2.state : null;
+        const notRun = notRunReason(run2);
         return {
           rule: { ...rule, execution: ruleCapability(rule) },
           file: files.get(rule.id)?.path ?? await current.files.rulePath(current.tip, rule.id),
           components: current.project.system.components.filter((c) => c.contract.rules.includes(rule.id)).map((c) => c.contract.id),
-          flagged: notRun2 ? null : places.length,
-          ...notRun2 ? { notRun: notRun2 } : {},
+          flagged: notRun ? null : places.length,
+          ...notRun ? { notRun } : {},
           places: places.slice(0, MAX_PLACES).map(({ file, line, column, text, message }) => ({ file, line, column, text, message }))
         };
       })
@@ -1511,7 +1692,7 @@ var RuleWorkflow = class {
   }
   /** A style draft starts from the default branch tip, bound to every file it could touch. */
   async createStyle(actor, current, initial) {
-    const content = normalizeStyleContent(initial ?? { title: "", tokens: [], states: [] });
+    const content = normalizeStyleContent(initial ?? emptyStyleContent());
     const files = {};
     for (const path of await current.files.stylePaths(current.tip)) files[path] = await current.files.digest(current.tip, path);
     const at = this.now();
@@ -1563,7 +1744,7 @@ var RuleWorkflow = class {
       approval: null,
       handoff: null,
       discarded: false,
-      events: [this.event(actor, "created", `${describeLibrary(content)[0].toUpperCase()}${describeLibrary(content).slice(1)}, from ${current.branch}@${current.tip.slice(0, 7)}.`)]
+      events: [this.event(actor, "created", `${capitalized(describeLibrary(content))}, from ${current.branch}@${current.tip.slice(0, 7)}.`)]
     };
     await this.options.store.put(draft);
     return await this.view(draft, current);
@@ -1632,20 +1813,14 @@ var RuleWorkflow = class {
       const scan = await scanProject(before.project);
       const baseline = before.project.system.rules.find((r) => r.id === draft.ruleId) ?? null;
       const comparison = comparePreview({ project: before.project, scan, execution: this.execution, draft: rule, baseline: draft.mode === "edit" ? baseline : null });
-      const after = await this.current();
-      if (after.snapshot.digest !== before.snapshot.digest) throw new WorkflowError("stale", "the project or design repository changed while the preview ran; run it again");
+      const after = await this.unchangedSince(before);
       const { report } = scan;
       const designLimits = [
         ...before.designDirty ? ["The design repository has uncommitted changes or another branch checked out; this preview reads the working tree."] : [],
         ...before.snapshot.projectCommit === null ? [`${report.project} is not a git repository: later edits to it cannot be detected, so this preview cannot go stale.`] : []
       ];
       const preview = {
-        id: this.id("p"),
-        at: this.now(),
-        draftRevision: draft.revision,
-        draftDigest: draft.digest,
-        snapshot: before.snapshot,
-        durationMs: Math.round(performance.now() - started),
+        ...this.previewHead(draft, before, started),
         scan: { status: report.status, files: report.coverage.filesScanned, failed: report.coverage.failed },
         ...comparison,
         limits: [...comparison.limits, ...designLimits]
@@ -1676,20 +1851,14 @@ var RuleWorkflow = class {
       if (!impact) indexed = false;
       swaps.push({ target, kind: "family", name: null, looks: impact?.looks ?? null, files: impact?.files ?? null, routes: impact?.routes ?? null, listed: impact?.listed ?? null });
     }
-    const after = await this.current();
-    if (after.snapshot.digest !== before.snapshot.digest) throw new WorkflowError("stale", "the project or design repository changed while the preview ran; run it again");
+    const after = await this.unchangedSince(before);
     const entry = draft.content.entry;
     const preview = {
-      id: this.id("p"),
-      at: this.now(),
-      draftRevision: draft.revision,
-      draftDigest: draft.digest,
-      snapshot: before.snapshot,
-      durationMs: Math.round(performance.now() - started),
+      ...this.previewHead(draft, before, started),
       file,
       exists,
       stage: draft.content.request === "adopt" ? "candidate" : "library",
-      license: entry.license && entry.license !== "unknown" ? entry.license.spdx : "unknown",
+      license: licenceOf(draft.content),
       install: entry.install?.command ?? null,
       swaps,
       limits: [
@@ -1699,7 +1868,7 @@ var RuleWorkflow = class {
         ...swaps.some((s) => s.kind === "element") ? ["System elements are named, not counted: youiyoux where-used counts their sites."] : []
       ]
     };
-    const next = { ...draft, preview, updatedAt: this.now(), events: [...draft.events, this.event(actor, "previewed", `${previewSummary({ ...draft, preview })[0].toUpperCase()}${previewSummary({ ...draft, preview }).slice(1)}.`)] };
+    const next = { ...draft, preview, updatedAt: this.now(), events: [...draft.events, this.event(actor, "previewed", `${capitalized(previewSummary({ ...draft, preview }))}.`)] };
     await this.options.store.put(next);
     return this.refreshed(next, after);
   }
@@ -1711,16 +1880,10 @@ var RuleWorkflow = class {
     const started = performance.now();
     const scan = await scanProject(before.project);
     const impact = await previewStyle({ project: before.project, scan, files: before.files, commit: draft.base.commit, content: draft.content, published: await before.tokens() });
-    const after = await this.current();
-    if (after.snapshot.digest !== before.snapshot.digest) throw new WorkflowError("stale", "the project or design repository changed while the preview ran; run it again");
+    const after = await this.unchangedSince(before);
     const { report } = scan;
     const preview = {
-      id: this.id("p"),
-      at: this.now(),
-      draftRevision: draft.revision,
-      draftDigest: draft.digest,
-      snapshot: before.snapshot,
-      durationMs: Math.round(performance.now() - started),
+      ...this.previewHead(draft, before, started),
       scan: { status: report.status, files: report.coverage.filesScanned, failed: report.coverage.failed },
       ...impact,
       limits: [
@@ -1925,7 +2088,7 @@ function shellQuote(path) {
 }
 
 // ../workflow/src/store.ts
-import { mkdir as mkdir2, readdir, readFile as readFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 var DRAFT_ID = /^d-[0-9a-f]{10}$/;
 var FORMAT = "youiyoux.draft/v1";
@@ -1955,14 +2118,14 @@ var FileStore = class {
     this.artifacts = join5(dir, "handoffs");
   }
   async list() {
-    await mkdir2(this.drafts, { recursive: true });
-    const names = (await readdir(this.drafts)).filter((name) => /^d-[0-9a-f]{10}\.json$/.test(name)).sort();
+    await mkdir3(this.drafts, { recursive: true });
+    const names = (await readdir2(this.drafts)).filter((name) => /^d-[0-9a-f]{10}\.json$/.test(name)).sort();
     const drafts = [];
     const unreadable = [];
     for (const name of names) {
       const file = join5(this.drafts, name);
       try {
-        drafts.push(decode(await readFile3(file, "utf8"), file));
+        drafts.push(decode(await readFile4(file, "utf8"), file));
       } catch (error) {
         unreadable.push({ file, reason: error instanceof Error ? error.message : String(error) });
       }
@@ -1974,7 +2137,7 @@ var FileStore = class {
     const file = join5(this.drafts, `${id}.json`);
     let text;
     try {
-      text = await readFile3(file, "utf8");
+      text = await readFile4(file, "utf8");
     } catch (error) {
       if (error.code === "ENOENT") return null;
       throw error;
@@ -2012,72 +2175,63 @@ var MemoryStore = class {
     return `memory:${name}`;
   }
 };
+
 export {
-  DEFAULT_FILES,
-  DRAFT_ID,
-  DesignFiles,
-  RuleWorkflow as DesignWorkflow,
-  FileStore,
-  GitError,
-  JsonEditError,
-  MAX_FINDINGS,
-  MAX_LISTED,
-  MAX_TITLE,
-  MemoryStore,
-  RuleWorkflow,
-  SESSION_HEADER,
-  WORKFLOW_VERSION,
-  WorkflowError,
-  adoptionRefusal,
-  authorize,
-  branchTip,
-  changesDigest,
-  comparePreview,
-  componentChanges,
-  contentDigest,
-  createHandler,
-  createReviewBranch,
-  defaultBranch,
+  readJsonPath,
+  setJsonPath,
   deleteJsonPath,
-  describeContrast,
-  describeLibrary,
-  describeStyle,
-  draftStatus,
-  effectiveStateEdits,
-  effectiveTokenEdits,
-  emptyStyleContent,
   fieldsFromRule,
+  newRuleFields,
+  toRuleSpec,
+  validateContent,
+  contentDigest,
+  renderRuleYaml,
+  renderContract,
+  draftStatus,
+  componentChanges,
   git,
-  hasChanges,
+  locate,
+  defaultBranch,
+  branchTip,
   headCommit,
+  readAt,
   isAncestor,
-  libraryDigest,
-  libraryPath,
-  librarySlug,
   listAt,
-  listTreeAt,
-  locate,
-  newContrastFailures,
-  newRuleFields,
-  normalizeLibraryContent,
+  hasChanges,
+  changesDigest,
+  createReviewBranch,
+  emptyStyleContent,
   normalizeStyleContent,
-  previewStyle,
-  previewSummary,
-  readAt,
-  readJsonPath,
-  renderContract,
-  renderContractStates,
-  renderLibraryEntry,
-  renderRuleYaml,
+  styleDigest,
+  tokenPathOf,
+  validateStyleContent,
+  effectiveStateEdits,
   renderTokenEdits,
+  renderContractStates,
+  styleSlug,
+  describeStyle,
+  DesignFiles,
   scannerExecution,
+  WorkflowError,
+  authorize,
   serveWorkflow,
-  setJsonPath,
-  styleDigest,
-  styleSlug,
-  toRuleSpec,
-  tokenPathOf,
-  validateContent,
+  normalizeLibraryContent,
+  libraryDigest,
+  libraryPath,
+  librarySlug,
+  licenceOf,
+  adoptionRefusal,
   validateLibraryContent,
-  validateStyleContent
+  renderLibraryEntry,
+  describeLibrary,
+  notRunReason,
+  comparePreview,
+  REQUESTS_DIR,
+  RequestStore,
+  requestBrief,
+  MAX_LISTED,
+  previewStyle,
+  RuleWorkflow,
+  FileStore,
+  MemoryStore
 };