gbs-add-block 2.0.4 → 2.3.0

package/tools/passport/merge.cjs

@@ -0,0 +1,131 @@
+/*
+ * Passport merge: derived <- manual <- local.
+ *
+ *   derived   generator output; regenerated from source every run
+ *   manual    passport.manual.json, authored by the library, never overwritten
+ *   local     passport.local.json, owned by the consuming developer, never
+ *             written by the CLI
+ *
+ * Precedence is explicit per field rather than "deep merge everything", because
+ * some fields must always come from source. A manual file that could redefine a
+ * prop's type would make the passport lie about the code.
+ */
+
+/** Fields that are ALWAYS regenerated. Manual/local may annotate, never replace. */
+const SOURCE_OWNED = new Set(["passportVersion", "source", "inherits", "events", "slots", "states"]);
+
+/** Fields that only manual/local provide. The generator emits empty shells. */
+const AUTHORED = new Set([
+  "accessibility",
+  "composition",
+  "operations",
+  "intentDomains",
+  "safeMutations",
+  "examples",
+  "purpose",
+]);
+
+/*
+ * Keys that mean something to JavaScript's object model rather than to a
+ * passport. `JSON.parse` hands `__proto__` back as an ordinary own property,
+ * but `out[k] = v` would run Object.prototype's setter and reparent the
+ * merged object. No passport field needs these names, so an overlay carrying
+ * one has it dropped here and flagged as an error by `validateReferences` —
+ * dropped silently would be the worse half of that pair.
+ */
+const UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+
+function deepMerge(base, overlay) {
+  if (!isObject(base) || !isObject(overlay)) return overlay === undefined ? base : overlay;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(overlay)) {
+    if (UNSAFE_KEYS.has(k)) continue;
+    out[k] = isObject(v) && isObject(base[k]) ? deepMerge(base[k], v) : v;
+  }
+  return out;
+}
+
+/**
+ * Overlay prop annotations by name. An overlay entry may add `description`,
+ * `note` or `deprecated` to a derived prop, and may introduce a wholly new prop
+ * (a locally added one) — which is marked with the overlay's origin.
+ */
+function mergeProps(derived, overlayProps, origin) {
+  if (!Array.isArray(overlayProps) || overlayProps.length === 0) return derived;
+  const byName = new Map(derived.map((p) => [p.name, { ...p }]));
+
+  for (const entry of overlayProps) {
+    if (!entry || typeof entry.name !== "string") continue;
+    if (UNSAFE_KEYS.has(entry.name)) continue;
+    const existing = byName.get(entry.name);
+    if (existing) {
+      // Annotate only. Type/required/origin stay source-derived.
+      const { name, type, values, signature, typeText, required, origin: _o, ...annotations } = entry;
+      Object.assign(existing, annotations);
+      if (annotations.description) existing.descriptionOrigin = origin;
+    } else {
+      byName.set(entry.name, { ...entry, origin });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/**
+ * Produce the effective passport written to passport.json.
+ *
+ * @param {object} derived   generator output
+ * @param {object} manual    passport.manual.json contents, or {}
+ * @param {object} local     passport.local.json contents, or {} (consumer side)
+ */
+function mergePassport(derived, manual = {}, local = {}) {
+  let out = { ...derived };
+
+  for (const [overlay, origin] of [
+    [manual, "manual"],
+    [local, "local"],
+  ]) {
+    if (!overlay || Object.keys(overlay).length === 0) continue;
+
+    for (const [key, value] of Object.entries(overlay)) {
+      if (key.startsWith("$") || key === "component") continue;
+      if (UNSAFE_KEYS.has(key)) continue; // validator reports it
+      if (SOURCE_OWNED.has(key)) continue; // silently ignored; validator reports it
+
+      if (key === "props") {
+        out.props = mergeProps(out.props, value, origin);
+        continue;
+      }
+      if (key === "propNotes" && isObject(value)) {
+        out.props = out.props.map((p) =>
+          value[p.name] ? { ...p, note: value[p.name] } : p,
+        );
+        continue;
+      }
+      if (AUTHORED.has(key)) {
+        out[key] = isObject(out[key]) && isObject(value) ? deepMerge(out[key], value) : value;
+        continue;
+      }
+      out[key] = isObject(out[key]) && isObject(value) ? deepMerge(out[key], value) : value;
+    }
+  }
+
+  // Coverage is recomputed after overlays, since manual descriptions count.
+  const described = out.props.filter((p) => p.description).length;
+  const authoredSections = [...AUTHORED].filter((k) => {
+    const v = out[k];
+    return Array.isArray(v) ? v.length > 0 : isObject(v) ? Object.keys(v).length > 0 : Boolean(v);
+  }).sort();
+
+  out.coverage = {
+    propsTotal: out.props.length,
+    propsDescribed: described,
+    describedPct: out.props.length ? Math.round((described / out.props.length) * 100) : 0,
+    authoredSections,
+  };
+
+  return out;
+}
+
+module.exports = { mergePassport, deepMerge, mergeProps, SOURCE_OWNED, AUTHORED, UNSAFE_KEYS };

package/tools/passport/policy.cjs

@@ -0,0 +1,65 @@
+/*
+ * Which inherited (library) properties are worth surfacing inline.
+ *
+ * A component like Button extends `ButtonHTMLAttributes<HTMLButtonElement>`,
+ * which resolves to several hundred DOM properties. Enumerating them buries the
+ * real API; omitting them entirely hides props people genuinely pass. So the
+ * generator keeps the inheritance edge AND inlines a short, per-element list.
+ *
+ * This file is policy only. It states what is WORTH surfacing; the extractor
+ * emits an entry only when the TypeChecker confirms the property actually
+ * exists on that component's resolved type. Nothing here is assumed.
+ */
+
+/** Surfaced for every element kind, when present. */
+const COMMON = ["className", "style", "id", "title", "tabIndex", "role", "hidden"];
+
+/**
+ * Keyed by the React attributes interface a component extends. The extractor
+ * reads the resolved base type name and looks it up here; an unknown base gets
+ * COMMON only.
+ */
+const BY_BASE = {
+  ButtonHTMLAttributes: ["disabled", "type", "form", "name", "value", "autoFocus"],
+  InputHTMLAttributes: [
+    "disabled", "readOnly", "required", "placeholder", "name", "type", "value",
+    "defaultValue", "checked", "defaultChecked", "autoComplete", "autoFocus",
+    "maxLength", "minLength", "min", "max", "step", "pattern", "inputMode", "form",
+  ],
+  TextareaHTMLAttributes: [
+    "disabled", "readOnly", "required", "placeholder", "name", "value",
+    "defaultValue", "rows", "cols", "maxLength", "autoFocus", "form",
+  ],
+  SelectHTMLAttributes: ["disabled", "required", "name", "value", "defaultValue", "multiple", "form"],
+  FormHTMLAttributes: ["action", "method", "noValidate", "name"],
+  AnchorHTMLAttributes: ["href", "target", "rel", "download"],
+  ImgHTMLAttributes: ["src", "alt", "loading", "width", "height"],
+  DialogHTMLAttributes: ["open"],
+  FieldsetHTMLAttributes: ["disabled", "form", "name"],
+  LabelHTMLAttributes: ["htmlFor", "form"],
+  HTMLAttributes: [],
+  // `children` is meaningful on every container; the checker decides.
+};
+
+/** ARIA props are never bulk-inlined — too many — but these carry real meaning. */
+const ARIA = ["aria-label", "aria-labelledby", "aria-describedby"];
+
+/**
+ * The names worth surfacing for a component, given the external base types its
+ * Props interface extends. Returns a de-duplicated, stable-ordered list.
+ *
+ * @param {string[]} baseNames e.g. ["ButtonHTMLAttributes"]
+ * @returns {string[]}
+ */
+function allowlistFor(baseNames) {
+  const out = [...COMMON];
+  for (const base of baseNames) {
+    for (const name of BY_BASE[base] ?? []) {
+      if (!out.includes(name)) out.push(name);
+    }
+  }
+  for (const name of ARIA) if (!out.includes(name)) out.push(name);
+  return out;
+}
+
+module.exports = { COMMON, BY_BASE, ARIA, allowlistFor };

package/tools/passport/validate.cjs

@@ -0,0 +1,277 @@
+/*
+ * Passport validation.
+ *
+ * Two layers, both returning typed issues rather than throwing:
+ *
+ *   structural  the passport matches Passport v1's shape
+ *   referential the authored overlays point at things that still exist
+ *
+ * A dependency-free structural check is used deliberately: the schema is ours,
+ * and adding a JSON Schema runtime would be a dependency the source-first model
+ * does not want. `schema/passport-v1.schema.json` is still published so external
+ * consumers can validate with whatever they like.
+ */
+
+const issue = (level, code, component, message, detail) => ({
+  level, code, component, message, ...(detail ? { detail } : {}),
+});
+
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const PROP_TYPES = new Set(["string", "number", "boolean", "enum", "function", "other"]);
+const ORIGINS = new Set(["derived", "inherited", "manual", "local"]);
+const DESCRIPTION_ORIGINS = new Set(["jsdoc", "readme", "manual", "local"]);
+
+/** Structural validation against Passport v1. */
+function validateStructure(passport, component) {
+  const out = [];
+  const need = (cond, code, message, detail) => {
+    if (!cond) out.push(issue("error", code, component, message, detail));
+  };
+
+  need(passport.passportVersion === "1.0.0", "bad-version",
+    `passportVersion must be "1.0.0", got ${JSON.stringify(passport.passportVersion)}`);
+
+  need(isObject(passport.identity) && typeof passport.identity.component === "string",
+    "bad-identity", "identity.component is required");
+  need(isObject(passport.source) && typeof passport.source.sourceHash === "string",
+    "bad-source", "source.sourceHash is required");
+  need(Array.isArray(passport.source?.files) && passport.source.files.length > 0,
+    "bad-source-files", "source.files must be a non-empty array");
+
+  need(Array.isArray(passport.props), "bad-props", "props must be an array");
+  if (Array.isArray(passport.props)) {
+    const seen = new Set();
+    for (const p of passport.props) {
+      if (!isObject(p) || typeof p.name !== "string") {
+        out.push(issue("error", "bad-prop", component, "every prop needs a string name"));
+        continue;
+      }
+      if (seen.has(p.name)) out.push(issue("error", "duplicate-prop", component, `duplicate prop "${p.name}"`));
+      seen.add(p.name);
+      if (!PROP_TYPES.has(p.type))
+        out.push(issue("error", "bad-prop-type", component, `prop "${p.name}" has unknown type ${JSON.stringify(p.type)}`));
+      if (typeof p.required !== "boolean")
+        out.push(issue("error", "bad-prop-required", component, `prop "${p.name}" needs a boolean required`));
+      if (!ORIGINS.has(p.origin))
+        out.push(issue("error", "bad-origin", component, `prop "${p.name}" has unknown origin ${JSON.stringify(p.origin)}`));
+      if (p.type === "enum" && !Array.isArray(p.values))
+        out.push(issue("error", "enum-without-values", component, `enum prop "${p.name}" has no values`));
+      if (p.description !== undefined && !DESCRIPTION_ORIGINS.has(p.descriptionOrigin))
+        out.push(issue("error", "description-without-origin", component,
+          `prop "${p.name}" has a description but no valid descriptionOrigin`));
+    }
+  }
+
+  if (passport.inherits !== undefined) {
+    need(Array.isArray(passport.inherits), "bad-inherits", "inherits must be an array");
+    for (const edge of passport.inherits ?? []) {
+      if (!isObject(edge) || typeof edge.from !== "string")
+        out.push(issue("error", "bad-inherits-edge", component, "each inherits entry needs a string `from`"));
+    }
+  }
+
+  for (const key of ["events", "slots", "states", "intentDomains", "examples"]) {
+    need(Array.isArray(passport[key]), `bad-${key}`, `${key} must be an array`);
+  }
+  for (const key of ["accessibility", "composition", "operations", "safeMutations", "coverage"]) {
+    need(isObject(passport[key]), `bad-${key}`, `${key} must be an object`);
+  }
+
+  return out;
+}
+
+const UNSAFE_KEYS = ["__proto__", "constructor", "prototype"];
+
+/** Object-model keys anywhere in an overlay, by their path. */
+function unsafeKeysIn(value, path = "") {
+  if (Array.isArray(value)) return value.flatMap((item, i) => unsafeKeysIn(item, `${path}[${i}]`));
+  if (!isObject(value)) return [];
+  const found = [];
+  for (const key of Object.getOwnPropertyNames(value)) {
+    const at = path ? `${path}.${key}` : key;
+    if (UNSAFE_KEYS.includes(key)) found.push(at);
+    else found.push(...unsafeKeysIn(value[key], at));
+  }
+  return found;
+}
+
+/**
+ * Referential validation: do the authored overlays still match the source?
+ * This is what catches a manual file left behind by a refactor.
+ */
+function validateReferences(effective, { manual = {}, local = {}, component, api = [] }) {
+  const out = [];
+  const propNames = new Set(effective.props.map((p) => p.name));
+
+  const checkPropRefs = (names, where, origin) => {
+    for (const name of names ?? []) {
+      if (!propNames.has(name)) {
+        out.push(issue("error", "missing-prop-reference", component,
+          `${origin} metadata references prop "${name}", which no longer exists in the source`,
+          { where, prop: name }));
+      }
+    }
+  };
+
+  for (const [overlay, origin] of [[manual, "manual"], [local, "local"]]) {
+    if (!overlay || Object.keys(overlay).length === 0) continue;
+
+    /*
+     * `JSON.parse` returns `__proto__` as an ordinary own property, so an
+     * overlay can carry one. The merge drops it; this is what makes that
+     * visible, because a silent drop looks the same as a key that was never
+     * there.
+     */
+    for (const key of unsafeKeysIn(overlay)) {
+      out.push(issue("error", "unsafe-key", component,
+        `${origin} metadata contains "${key}", which is a JavaScript object-model key ` +
+        `and not a passport field; it was ignored`, { where: key }));
+    }
+
+    checkPropRefs(overlay.safeMutations?.allowed, "safeMutations.allowed", origin);
+    checkPropRefs(overlay.safeMutations?.forbidden, "safeMutations.forbidden", origin);
+    checkPropRefs(Object.keys(overlay.propNotes ?? {}), "propNotes", origin);
+
+    // Manual must not try to redefine source-owned facts.
+    for (const key of ["source", "inherits", "slots", "states", "events", "passportVersion"]) {
+      if (overlay[key] !== undefined) {
+        out.push(issue("error", "overrides-source-owned", component,
+          `${origin} metadata sets "${key}", which is always regenerated from source`,
+          { where: key }));
+      }
+    }
+
+    // Overlay props may annotate or add, but not contradict a derived type.
+    for (const p of overlay.props ?? []) {
+      const existing = effective.props.find((e) => e.name === p.name);
+      if (existing && p.type && p.type !== existing.type) {
+        out.push(issue("error", "contradicts-source", component,
+          `${origin} metadata gives prop "${p.name}" type "${p.type}" but the source says "${existing.type}"`,
+          { prop: p.name }));
+      }
+      if (!existing && origin === "manual") {
+        out.push(issue("error", "unknown-prop", component,
+          `manual metadata declares prop "${p.name}", which is not in the source; ` +
+          `only passport.local.json may introduce props`, { prop: p.name }));
+      }
+    }
+
+    // Operations must name a real API method when one is declared.
+    for (const [opName, op] of Object.entries(overlay.operations ?? {})) {
+      if (op?.apiMethod && api.length && !api.includes(op.apiMethod)) {
+        out.push(issue("error", "unknown-api-method", component,
+          `operation "${opName}" names apiMethod "${op.apiMethod}", which the component API does not expose`,
+          { operation: opName }));
+      }
+    }
+  }
+
+  return out;
+}
+
+/** Coverage is a warning signal, never a hard failure in v1. */
+function coverageIssues(effective, component, threshold) {
+  const out = [];
+  const { describedPct, propsTotal, propsDescribed } = effective.coverage;
+  if (typeof threshold === "number" && describedPct < threshold) {
+    out.push(issue("warn", "coverage-below-threshold", component,
+      `${describedPct}% of props described (${propsDescribed}/${propsTotal}), threshold ${threshold}%`));
+  }
+  return out;
+}
+
+/* ------------------------------------------------------------ text hygiene */
+
+/*
+ * A passport is read by coding agents. That is the point of it, and it is also
+ * the only way a passport can hurt you: nothing parses it into code and no
+ * file path is derived from it, but an agent that reads
+ * "this component requires calling fetch('https://…') on mount" will write
+ * that. The text is documentation; it is never an instruction.
+ *
+ * These checks cannot decide whether a sentence is honest. What they can do is
+ * make the shapes injection needs — hidden characters, a script tag, a wall of
+ * text, a line telling the reader to disregard what it was told — visible in
+ * `npm run passport:check` instead of invisible in a diff that looks like
+ * documentation. The current 27 passports have a longest string of 217
+ * characters and 8.7 kB of text at most, so the caps are far above anything
+ * written in good faith.
+ */
+
+const MAX_TEXT = 1000;
+const MAX_TEXT_TOTAL = 40000;
+
+/** Everything except tab, newline and carriage return. */
+const CONTROL_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/;
+
+/** A real link, not the bare `"https://"` that appears in an example. */
+const LINK = /https?:\/\/[^\s"'<>)]*\.[^\s"'<>)]+/i;
+
+const HIGH_SIGNAL = [
+  [/<script\b/i, "an HTML script tag"],
+  [/ignore (?:all |any )?(?:the )?(?:previous|prior|above|earlier)/i, "an instruction to ignore earlier context"],
+  [/disregard (?:all |any )?(?:the )?(?:previous|prior|above|earlier)/i, "an instruction to disregard earlier context"],
+  [/\bsystem prompt\b/i, "a reference to a system prompt"],
+  [/\b(?:you are|act as) (?:an? )?(?:ai|assistant|agent|language model)\b/i, "a role instruction aimed at an agent"],
+  [/\bnew instructions?\b/i, "a claim of new instructions"],
+  [/\bdo not (?:tell|mention|inform|reveal)\b/i, "an instruction to conceal something"],
+  [/\bexfiltrat/i, "exfiltration"],
+  [/\bcurl\s+https?:/i, "a shell download"],
+  [/\bnpm (?:install|i|exec)\s/i, "a package installation"],
+  [/\bchild_process\b|\bprocess\.env\b|\beval\(/i, "code that reaches outside the component"],
+];
+
+/** Every string in the passport, with a readable path to it. */
+function walkStrings(value, path, visit) {
+  if (typeof value === "string") visit(value, path);
+  else if (Array.isArray(value)) value.forEach((item, i) => walkStrings(item, `${path}[${i}]`, visit));
+  else if (isObject(value)) {
+    for (const [key, item] of Object.entries(value)) walkStrings(item, path ? `${path}.${key}` : key, visit);
+  }
+}
+
+/** Length, hidden characters, and the phrasings injection needs. */
+function textIssues(passport, component) {
+  const out = [];
+  let total = 0;
+
+  walkStrings(passport, "", (text, where) => {
+    total += text.length;
+
+    if (text.length > MAX_TEXT) {
+      out.push(issue("error", "text-too-long", component,
+        `${where} is ${text.length} characters; the limit is ${MAX_TEXT}`, { where }));
+    }
+    if (CONTROL_CHARS.test(text)) {
+      out.push(issue("error", "control-characters", component,
+        `${where} contains control characters, which can hide text from a reader`, { where }));
+    }
+    for (const [pattern, what] of HIGH_SIGNAL) {
+      if (pattern.test(text)) {
+        out.push(issue("error", "suspicious-text", component,
+          `${where} contains ${what}. Passport text is documentation an agent reads; ` +
+          `it must not instruct one.`, { where }));
+      }
+    }
+    if (text.includes("```")) {
+      out.push(issue("warn", "code-fence", component,
+        `${where} contains a fenced code block, which an agent may copy verbatim`, { where }));
+    }
+    if (LINK.test(text)) {
+      out.push(issue("warn", "contains-link", component,
+        `${where} contains a link; an agent may follow it`, { where }));
+    }
+  });
+
+  if (total > MAX_TEXT_TOTAL) {
+    out.push(issue("error", "text-budget-exceeded", component,
+      `${total} characters of text across the passport; the limit is ${MAX_TEXT_TOTAL}`));
+  }
+
+  return out;
+}
+
+module.exports = {
+  validateStructure, validateReferences, coverageIssues, textIssues, issue,
+  MAX_TEXT, MAX_TEXT_TOTAL,
+};

package/tools/ts-require.cjs

@@ -0,0 +1,79 @@
+/*
+ * Lets a CommonJS tool `require()` the library's TypeScript directly.
+ *
+ * The evaluation harness has to run the *real* runtime — the same contract
+ * emitter, the same validator, the same coercion — because a harness that
+ * reimplements any of that is measuring itself. The runtime is TypeScript and
+ * the harness is a CLI, so something has to bridge them.
+ *
+ * Three options were available: add a loader dependency (tsx, jiti), compile
+ * to a build directory, or transpile on demand with the compiler that is
+ * already a devDependency for the passport generator. The third adds nothing
+ * to install and nothing to keep in sync, so that is this file.
+ *
+ * Transpile-only, like `isolatedModules`: no type checking happens here. That
+ * is fine — `tsc --noEmit` and the test suite do the checking, and doing it
+ * twice would only make the CLI slow.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const Module = require("module");
+
+let registered = false;
+
+/** Resolve the same way a bundler would: bare path, then `.ts`, then `/index.ts`. */
+function resolveTs(request, parent) {
+  if (!request.startsWith(".") && !path.isAbsolute(request)) return null;
+  const base = path.resolve(path.dirname(parent?.filename ?? process.cwd()), request);
+  for (const candidate of [base, `${base}.ts`, `${base}.tsx`, path.join(base, "index.ts")]) {
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+
+function register() {
+  if (registered) return;
+  registered = true;
+
+  let ts;
+  try {
+    ts = require("typescript");
+  } catch {
+    throw new Error(
+      "The evaluation harness needs the TypeScript compiler to load the runtime. " +
+        "Run `npm install` at the repository root.",
+    );
+  }
+
+  const compile = (module_, filename) => {
+    const source = fs.readFileSync(filename, "utf8");
+    const { outputText } = ts.transpileModule(source, {
+      fileName: filename,
+      compilerOptions: {
+        module: ts.ModuleKind.CommonJS,
+        target: ts.ScriptTarget.ES2022,
+        esModuleInterop: true,
+        isolatedModules: true,
+        jsx: ts.JsxEmit.ReactJSX,
+      },
+    });
+    module_._compile(outputText, filename);
+  };
+
+  Module._extensions[".ts"] = compile;
+  Module._extensions[".tsx"] = compile;
+
+  const resolveFilename = Module._resolveFilename;
+  Module._resolveFilename = function (request, parent, ...rest) {
+    try {
+      return resolveFilename.call(this, request, parent, ...rest);
+    } catch (error) {
+      const found = resolveTs(request, parent);
+      if (found) return found;
+      throw error;
+    }
+  };
+}
+
+module.exports = { register };

package/source/beta-components/accordion/__tests__/core.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { normalizeOpen, toggleOpen } from "../core/open";
-
-describe("toggleOpen", () => {
-  describe("one at a time", () => {
-    it("opens a panel and closes whatever was open", () => {
-      expect(toggleOpen(["a"], "b")).toEqual(["b"]);
-    });
-
-    it("closes the open panel when pressed again", () => {
-      expect(toggleOpen(["a"], "a")).toEqual([]);
-    });
-
-    it("keeps it open when the accordion cannot be empty", () => {
-      // Panels that are the whole page: closing the last leaves a dead end.
-      expect(toggleOpen(["a"], "a", { collapsible: false })).toEqual(["a"]);
-    });
-  });
-
-  describe("several at a time", () => {
-    it("adds and removes without touching the others", () => {
-      expect(toggleOpen(["a"], "b", { multiple: true })).toEqual(["a", "b"]);
-      expect(toggleOpen(["a", "b"], "a", { multiple: true })).toEqual(["b"]);
-    });
-
-    it("keeps the order panels were opened in", () => {
-      expect(toggleOpen(["b"], "a", { multiple: true })).toEqual(["b", "a"]);
-    });
-
-    it("refuses to close the last one when the accordion cannot be empty", () => {
-      expect(toggleOpen(["a"], "a", { multiple: true, collapsible: false })).toEqual(["a"]);
-      // Any other panel is still free to close, because one stays open.
-      expect(toggleOpen(["a", "b"], "a", { multiple: true, collapsible: false })).toEqual(["b"]);
-    });
-  });
-});
-
-describe("normalizeOpen", () => {
-  const values = ["a", "b", "c"];
-
-  it("drops values the accordion does not have", () => {
-    expect(normalizeOpen(["a", "z"], values, { multiple: true })).toEqual(["a"]);
-  });
-
-  it("keeps only the first for a single accordion", () => {
-    // Otherwise it starts showing two panels and can never show two again.
-    expect(normalizeOpen(["a", "b"], values)).toEqual(["a"]);
-  });
-
-  it("opens the first panel when the accordion cannot be empty", () => {
-    expect(normalizeOpen([], values, { collapsible: false })).toEqual(["a"]);
-    expect(normalizeOpen([], values)).toEqual([]);
-  });
-
-  it("has nothing to open when there are no panels", () => {
-    expect(normalizeOpen([], [], { collapsible: false })).toEqual([]);
-  });
-});

package/source/beta-components/alert/__tests__/core.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { liveness } from "../core/live";
-
-describe("liveness", () => {
-  it("interrupts for problems", () => {
-    // Someone whose card was declined needs to hear it now, not after the
-    // paragraph being read finishes.
-    expect(liveness("danger")).toEqual({ role: "alert", live: "assertive" });
-    expect(liveness("warning")).toEqual({ role: "alert", live: "assertive" });
-  });
-
-  it("waits its turn for everything else", () => {
-    for (const variant of ["info", "success", "neutral"] as const) {
-      expect(liveness(variant)).toEqual({ role: "status", live: "polite" });
-    }
-  });
-});