@lotics/ui 20.0.1 → 20.1.0

package/LICENSE.md

@@ -0,0 +1,39 @@
+Copyright (c) 2026 Lotics Technology Company Limited. All rights reserved.
+
+This software is proprietary. It is published to the public npm registry for one
+purpose: building on the Lotics platform.
+
+In this license, **Lotics** means Lotics Technology Company Limited, and **the
+Lotics platform** means the hosted services Lotics operates at lotics.ai and its
+subdomains, together with applications, packages and integrations that run on or
+communicate with those services.
+
+## Permitted
+
+You may install this package and use it **solely in connection with the Lotics
+platform** — including bundling it, in whole or in part, into an application that
+runs on or integrates with the Lotics platform.
+
+## Not permitted
+
+Without prior written permission from Lotics you may not:
+
+1. use this software, or any portion of it, independently of the Lotics platform
+   — including in any application, product or service that neither runs on nor
+   integrates with the Lotics platform;
+2. copy, republish, redistribute or sublicense the source code, in whole or in
+   part, other than as the bundled dependency described above;
+3. create derivative works from the source code, or incorporate any portion of it
+   into another library, product or package;
+4. reverse engineer, decompile or disassemble any compiled artifact, except to the
+   extent that restriction is unenforceable under applicable law;
+5. use the source code, or any portion of it, to train or fine-tune a machine
+   learning model.
+
+## No warranty
+
+This software is provided "as is", without warranty of any kind, express or
+implied. In no event shall Lotics be liable for any claim, damages or other
+liability arising from the software or its use.
+
+For any other use, contact minh@lotics.ai.

package/docs/ai_patterns.md

@@ -157,9 +157,10 @@ PUT and rolls the calls out BELOW it on press. The run ALWAYS ends on the agent'
 no global terminal node.
 
 **Tool labels.** A tool part carries the RAW tool name (`update_records` from `tool-update_records`,
-or a `dynamic-tool`'s `toolName`), resolved via a built-in map of the platform record/document
-tools + an optional **`labelForCall`** override (localize THERE — the kit stays English). It gets
-the whole call — `{ toolName, input, state }` (`AgentToolCall`) — so a caller can phrase by what the
+or a `dynamic-tool`'s `toolName`), resolved through the active locale's **`agentRun.tools`** map —
+so a `vi` provider renders Vietnamese tool rows with no per-app wiring, the same way the rest of the
+feed's chrome already resolved. An optional **`labelForCall`** override still wins, for phrasing a
+call by what it TARGETS rather than by which tool ran. It gets the whole call — `{ toolName, input, state }` (`AgentToolCall`) — so a caller can phrase by what the
 call targets or by whether it's awaiting; return `undefined` to fall back. Unknown names fall back
 to a prettified form. `stepsLabel` localizes the "{n} steps" suffix. The tool `state` folds ai's
 7-state lifecycle to **running / awaiting / done / error**: `approval-requested` → `awaiting` (the
@@ -206,8 +207,12 @@ feed**; the starting row IS the placeholder, consistent and localized.
 **Localization.** The feed's fixed chrome — the "Thinking" label, the "Input"/"Output"/"Error"
 panel titles, the "awaiting" annotation, and the "Retry" action — resolves through the
 `LoticsLocale` `agentRun` slice (translate once at the provider; a `vi` app gets them for free).
-It is provider-localized, not per-instance prop-overridable; `labelForCall`/`stepsLabel` localize
-the tool labels and the "{n} steps" suffix per call site.
+— **and so are the tool labels** (`agentRun.tools`, keyed by raw tool name). Translating a tool
+row is no longer each app's job: an English row under a Vietnamese "Đang suy nghĩ…" was the kit
+contradicting itself. The "{n} steps" suffix is locale-backed too (`agentRun.steps`). `labelForCall`
+and `stepsLabel` remain as per-call-site OVERRIDES — for phrasing a row by what
+it targets — not as the only route to a translation. A tool name in neither the locale map nor
+`labelForCall` falls back to its prettified form.
 
 **Answering an awaiting call — `ApprovalPrompt`.** The `awaiting` row inside `AgentRun` is
 READ-ONLY — it only NAMES that a call is parked on a human decision. The surface that ANSWERS it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/ui",
-  "version": "20.0.1",
+  "version": "20.1.0",
   "type": "module",
   "exports": {
     "./vite": {
@@ -248,7 +248,9 @@
     "examples",
     "AGENTS.md",
     "MIGRATION.md",
-    "docs"
+    "docs",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx"
   ],
   "publishConfig": {
     "access": "public"
@@ -258,7 +260,7 @@
     "url": "https://github.com/lotics/lotics.git",
     "directory": "packages/ui"
   },
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
     "@lotics/docx": "^0.1.0",
     "@lotics/xlsx": "^0.1.0",

package/src/agent_progress.tsx

@@ -6,6 +6,7 @@ import { WaveAvatar } from "./wave_avatar";
 import { FollowScroll } from "./follow_scroll";
 import { PressableHighlight } from "./pressable_highlight";
 import { AgentRun, resolveToolMeta, type AgentRunProps, type AgentToolCall } from "./agent_run";
+import { useLoticsLocale } from "./locale";
 import { toSegments, lastRunningStep, type AgentUIPart } from "./agent_transform";
 
 export interface AgentProgressProps {
@@ -43,7 +44,14 @@ export function AgentProgress(props: AgentProgressProps) {
   const [expanded, setExpanded] = useState(defaultExpanded ?? false);
 
   const running = lastRunningStep(toSegments(parts));
-  const runningLabel = running ? resolveToolMeta({ toolName: running.toolName, input: running.input, state: running.status }, labelForCall).label : undefined;
+  const locale = useLoticsLocale();
+  const runningLabel = running
+    ? resolveToolMeta(
+        { toolName: running.toolName, input: running.input, state: running.status },
+        labelForCall,
+        locale.agentRun.tools,
+      ).label
+    : undefined;
   const compact = label ?? runningLabel ?? (state === "done" ? "Done" : state === "error" ? "Stopped" : "Working…");
   const streaming = state === "streaming";
 

package/src/agent_run.tsx

@@ -69,19 +69,28 @@ export interface AgentRunProps {
 }
 
 // ── Tool → display meta ───────────────────────────────────────────────────────
-// The bounded set of platform tools an app agent can call. English by default
-// (the kit is locale-neutral; apps localize via `labelForCall`). A tool the map
-// doesn't know falls back to a prettified name + a neutral icon.
-const TOOL_META: Record<string, { label: string; icon: IconName }> = {
-  query_records: { label: "Searching records", icon: "search" },
-  get_record: { label: "Reading a record", icon: "file-text" },
-  get_records: { label: "Reading records", icon: "file-text" },
-  create_records: { label: "Creating records", icon: "plus" },
-  update_records: { label: "Updating records", icon: "square-pen" },
-  delete_records: { label: "Removing records", icon: "trash" },
-  generate_pdf_from_template: { label: "Generating PDF", icon: "file-down" },
-  generate_excel_from_template: { label: "Generating spreadsheet", icon: "file-spreadsheet" },
-  generate_docx_from_template: { label: "Generating document", icon: "file-text" },
+// The ICON per platform tool. The LABEL lives in the locale (`agentRun.tools`)
+// because it is language, and this component already renders localized chrome
+// around these rows — an English tool row under a Vietnamese "Đang suy nghĩ…"
+// was the kit contradicting itself. An icon is not language, so it stays here.
+// A tool neither map knows falls back to a prettified name + a neutral icon.
+const TOOL_ICONS: Record<string, IconName> = {
+  query_records: "search",
+  get_record: "file-text",
+  get_records: "file-text",
+  create_records: "plus",
+  update_records: "square-pen",
+  delete_records: "trash",
+  run_app_query: "search",
+  run_app_workflow: "play",
+  grep_knowledge: "search",
+  read_knowledge: "book-open",
+  list_knowledge: "list",
+  view_files: "file-text",
+  ask_user_choice: "message-circle-question-mark",
+  generate_pdf_from_template: "file-down",
+  generate_excel_from_template: "file-spreadsheet",
+  generate_docx_from_template: "file-text",
 };
 
 function prettifyToolName(name: string): string {
@@ -90,26 +99,37 @@ function prettifyToolName(name: string): string {
 }
 
 /** Resolve a tool's display label + icon: a caller override wins on the label,
- *  then the built-in map, then a prettified fallback. Exported so other agent
- *  surfaces (e.g. `AgentProgress`) render the same labels. */
+ *  then the active locale's `agentRun.tools`, then a prettified fallback.
+ *  Exported so other agent surfaces (e.g. `AgentProgress`) render the same
+ *  labels; `toolLabels` is optional so an existing external caller keeps
+ *  working (it just falls back to the prettified name). */
 export function resolveToolMeta(
   call: AgentToolCall,
   labelForCall?: (call: AgentToolCall) => string | undefined,
+  toolLabels?: Record<string, string>,
 ): { label: string; icon: IconName } {
-  const def =
-    TOOL_META[call.toolName] ??
-    (call.toolName.startsWith("generate_") && call.toolName.endsWith("_from_template")
-      ? { label: "Generating document", icon: "file-text" as IconName }
-      : undefined);
+  const generated =
+    call.toolName.startsWith("generate_") && call.toolName.endsWith("_from_template");
+  const label =
+    toolLabels?.[call.toolName] ??
+    (generated ? toolLabels?.generate_docx_from_template : undefined);
   return {
-    label: labelForCall?.(call) ?? def?.label ?? prettifyToolName(call.toolName),
-    icon: def?.icon ?? "list",
+    label: labelForCall?.(call) ?? label ?? prettifyToolName(call.toolName),
+    icon: TOOL_ICONS[call.toolName] ?? (generated ? "file-text" : "list"),
   };
 }
 
 /** Resolve a tool step's display label from its call. */
-function stepLabel(s: AgentStep, labelForCall?: (call: AgentToolCall) => string | undefined): string {
-  return resolveToolMeta({ toolName: s.toolName, input: s.input, state: s.status }, labelForCall).label;
+function stepLabel(
+  s: AgentStep,
+  labelForCall?: (call: AgentToolCall) => string | undefined,
+  toolLabels?: Record<string, string>,
+): string {
+  return resolveToolMeta(
+    { toolName: s.toolName, input: s.input, state: s.status },
+    labelForCall,
+    toolLabels,
+  ).label;
 }
 
 const INK = colors.zinc[700];
@@ -124,7 +144,7 @@ const INK = colors.zinc[700];
  * Pair with `Composer` + `ChangeReview`.
  */
 export function AgentRun(props: AgentRunProps) {
-  const { parts, labelForCall, renderToolOutput, onRetry, stepsLabel = (n) => `${n} steps`, accessibilityLabel } = props;
+  const { parts, labelForCall, renderToolOutput, onRetry, stepsLabel, accessibilityLabel } = props;
   const locale = useLoticsLocale();
   const segments = toSegments(parts);
   const state = props.state ?? (anyRunning(segments) ? "streaming" : "done");
@@ -163,7 +183,7 @@ export function AgentRun(props: AgentRunProps) {
             onToggle={() => toggle(seg.id)}
             labelForCall={labelForCall}
             renderToolOutput={renderToolOutput}
-            stepsLabel={stepsLabel}
+            stepsLabel={stepsLabel ?? locale.agentRun.steps}
           />
         );
       })}
@@ -369,7 +389,7 @@ function ToolGroup(props: {
 }) {
   const { steps, active, expanded, onToggle, labelForCall, renderToolOutput, stepsLabel } = props;
   const locale = useLoticsLocale();
-  const resolve = (s: AgentStep) => stepLabel(s, labelForCall);
+  const resolve = (s: AgentStep) => stepLabel(s, labelForCall, locale.agentRun.tools);
 
   // ACTIVE — one pulsing row whose label swaps in place as each call fires (the
   // label is keyed by the current step's id, so a new call rises + fades into the

package/src/locale.tsx

@@ -132,9 +132,27 @@ export interface LoticsLocale {
   /** `AgentRun`: the reasoning disclosure's label (settled / streaming), the
    *  auto-built tool peek's Input / Error / Output panel titles, the `awaiting`
    *  annotation on a call parked on a human decision, and the terminal error's
-   *  `retry` action. (Tool-step labels and the "{n} steps" suffix stay
-   *  prop-localized — `labelForCall` / `stepsLabel`.) */
-  agentRun: { starting: string; thinking: string; thinkingStreaming: string; input: string; error: string; output: string; awaiting: string; retry: string };
+   *  `retry` action, the per-tool labels (`tools`) and the "{n} steps" suffix
+   *  (`steps`). `labelForCall` / `stepsLabel` remain as per-call-site
+   *  OVERRIDES, not as the only way to get a translation. */
+  /** `AgentRun` / `AgentProgress` chrome, plus `tools` — the display label per
+   *  PLATFORM tool name. The tool set is bounded and kit-known, so localizing it
+   *  here means every app inherits it; leaving it to each call site's
+   *  `labelForCall` made a Vietnamese surface render Vietnamese chrome around
+   *  English tool rows. A name absent from the map still falls back to its
+   *  prettified form, and `labelForCall` still overrides per call. */
+  agentRun: {
+    starting: string;
+    thinking: string;
+    thinkingStreaming: string;
+    input: string;
+    error: string;
+    output: string;
+    awaiting: string;
+    retry: string;
+    tools: Record<string, string>;
+    steps: (n: number) => string;
+  };
   /** `ApprovalPrompt`: the default prompt line (overridable per instance) and
    *  the Approve / Deny button labels — the surface that ANSWERS `AgentRun`'s
    *  read-only `awaiting` row (approve/deny = the ai-sdk approval vocabulary). */
@@ -237,7 +255,35 @@ export const en: LoticsLocale = {
   matrix: { total: "Total", less: "Less", more: "More" },
   scrollToBottom: { tooltip: "Scroll to bottom" },
   textInputField: { clear: "Clear" },
-  agentRun: { starting: "Starting…", thinking: "Thinking", thinkingStreaming: "Thinking…", input: "Input", error: "Error", output: "Output", awaiting: "Awaiting", retry: "Retry" },
+  agentRun: {
+    starting: "Starting…",
+    thinking: "Thinking",
+    thinkingStreaming: "Thinking…",
+    input: "Input",
+    error: "Error",
+    output: "Output",
+    awaiting: "Awaiting",
+    retry: "Retry",
+    tools: {
+      query_records: "Searching records",
+      get_record: "Reading a record",
+      get_records: "Reading records",
+      create_records: "Creating records",
+      update_records: "Updating records",
+      delete_records: "Removing records",
+      run_app_query: "Reading data",
+      run_app_workflow: "Running an action",
+      grep_knowledge: "Searching reference material",
+      read_knowledge: "Reading reference material",
+      list_knowledge: "Listing reference material",
+      view_files: "Reading files",
+      ask_user_choice: "Asking a question",
+      generate_pdf_from_template: "Generating PDF",
+      generate_excel_from_template: "Generating spreadsheet",
+      generate_docx_from_template: "Generating document",
+    },
+    steps: (n) => `${n} steps`,
+  },
   approvalPrompt: { message: "The assistant wants to perform an action that needs your approval.", approve: "Approve", deny: "Deny" },
   messageActions: { copy: "Copy", copied: "Copied", regenerate: "Regenerate", edit: "Edit", previousVersion: "Previous version", nextVersion: "Next version" },
 };
@@ -335,7 +381,35 @@ export const vi: LoticsLocale = {
   matrix: { total: "Tổng", less: "Ít", more: "Nhiều" },
   scrollToBottom: { tooltip: "Cuộn xuống cuối" },
   textInputField: { clear: "Xóa" },
-  agentRun: { starting: "Đang bắt đầu…", thinking: "Suy nghĩ", thinkingStreaming: "Đang suy nghĩ…", input: "Đầu vào", error: "Lỗi", output: "Kết quả", awaiting: "Chờ duyệt", retry: "Thử lại" },
+  agentRun: {
+    starting: "Đang bắt đầu…",
+    thinking: "Suy nghĩ",
+    thinkingStreaming: "Đang suy nghĩ…",
+    input: "Đầu vào",
+    error: "Lỗi",
+    output: "Kết quả",
+    awaiting: "Chờ duyệt",
+    retry: "Thử lại",
+    tools: {
+      query_records: "Đang tìm dữ liệu",
+      get_record: "Đang đọc một bản ghi",
+      get_records: "Đang đọc dữ liệu",
+      create_records: "Đang tạo dữ liệu",
+      update_records: "Đang cập nhật dữ liệu",
+      delete_records: "Đang xoá dữ liệu",
+      run_app_query: "Đang đọc dữ liệu",
+      run_app_workflow: "Đang chạy tác vụ",
+      grep_knowledge: "Đang tra tài liệu",
+      read_knowledge: "Đang đọc tài liệu",
+      list_knowledge: "Đang liệt kê tài liệu",
+      view_files: "Đang đọc tệp",
+      ask_user_choice: "Đang hỏi thêm",
+      generate_pdf_from_template: "Đang tạo PDF",
+      generate_excel_from_template: "Đang tạo bảng tính",
+      generate_docx_from_template: "Đang tạo văn bản",
+    },
+    steps: (n) => `${n} bước`,
+  },
   approvalPrompt: { message: "Trợ lý muốn thực hiện thao tác cần bạn duyệt.", approve: "Cho phép", deny: "Từ chối" },
   messageActions: { copy: "Sao chép", copied: "Đã sao chép", regenerate: "Tạo lại", edit: "Chỉnh sửa", previousVersion: "Phiên bản trước", nextVersion: "Phiên bản sau" },
 };

package/src/agent_transform.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toSegments, anyRunning, lastRunningStep, type AgentUIPart, type AgentSegment, type AgentStep } from "./agent_transform";
-
-// RN-free logic test for the parts → timeline fold. The renderer (agent_run.tsx)
-// is verified visually in the gallery; the mapping — ai's 7-state tool machine to
-// the feed's 4 states, plus grouping — is unit-tested here. Fixtures are the ai-sdk
-// `dynamic-tool` part shape (contextually typed as `AgentUIPart`, so each concrete
-// `state` discriminates to the right member — no casts).
-
-function groups(parts: AgentUIPart[]): Extract<AgentSegment, { kind: "group" }>[] {
-  return toSegments(parts).filter((s): s is Extract<AgentSegment, { kind: "group" }> => s.kind === "group");
-}
-
-function onlyStep(parts: AgentUIPart[]): AgentStep {
-  const [group, ...rest] = groups(parts);
-  expect(rest).toHaveLength(0);
-  expect(group.steps).toHaveLength(1);
-  return group.steps[0];
-}
-
-describe("agent_transform — tool state mapping", () => {
-  it("input-streaming → running", () => {
-    expect(onlyStep([{ type: "dynamic-tool", toolName: "update_records", toolCallId: "t", state: "input-streaming", input: {} }]).status).toBe("running");
-  });
-
-  it("input-available → running", () => {
-    expect(onlyStep([{ type: "dynamic-tool", toolName: "update_records", toolCallId: "t", state: "input-available", input: {} }]).status).toBe("running");
-  });
-
-  it("approval-requested → awaiting (parked on a human decision)", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "approval-requested", input: { table: "Containers" }, approval: { id: "a1" } }]);
-    expect(step.status).toBe("awaiting");
-    // The input still rides along for the on-demand peek.
-    expect(step.input).toEqual({ table: "Containers" });
-  });
-
-  it("approval-responded → running (the decision is in, work resumes)", () => {
-    expect(onlyStep([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "approval-responded", input: {}, approval: { id: "a1", approved: true } }]).status).toBe("running");
-  });
-
-  it("output-available → done, carrying the output", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "query_records", toolCallId: "t", state: "output-available", input: { q: 1 }, output: { rows: 3 } }]);
-    expect(step.status).toBe("done");
-    expect(step.output).toEqual({ rows: 3 });
-  });
-
-  it("output-error → error, carrying errorText", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "query_records", toolCallId: "t", state: "output-error", input: {}, errorText: "Unknown field" }]);
-    expect(step.status).toBe("error");
-    expect(step.errorText).toBe("Unknown field");
-  });
-
-  it("output-denied → error, with the denial reason as the error text", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "output-denied", input: {}, approval: { id: "a1", approved: false, reason: "Delete not permitted" } }]);
-    expect(step.status).toBe("error");
-    expect(step.errorText).toBe("Delete not permitted");
-  });
-
-  it("output-denied without a reason → error with no error text", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "output-denied", input: {}, approval: { id: "a1", approved: false } }]);
-    expect(step.status).toBe("error");
-    expect(step.errorText).toBeUndefined();
-  });
-});
-
-describe("agent_transform — streaming signals", () => {
-  it("anyRunning is true while a call runs, false once every call has settled", () => {
-    const running = toSegments([{ type: "dynamic-tool", toolName: "query_records", toolCallId: "t", state: "input-available", input: {} }]);
-    expect(anyRunning(running)).toBe(true);
-
-    const settled = toSegments([{ type: "dynamic-tool", toolName: "query_records", toolCallId: "t", state: "output-available", input: {}, output: {} }]);
-    expect(anyRunning(settled)).toBe(false);
-  });
-
-  it("an awaiting call is NOT running — it's parked, so the feed never pulses it", () => {
-    const parked = toSegments([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "approval-requested", input: {}, approval: { id: "a1" } }]);
-    expect(anyRunning(parked)).toBe(false);
-    expect(lastRunningStep(parked)).toBeUndefined();
-  });
-});
-
-describe("agent_transform — grouping", () => {
-  it("folds consecutive tool parts into ONE group, split by prose", () => {
-    const parts: AgentUIPart[] = [
-      { type: "text", text: "First" },
-      { type: "dynamic-tool", toolName: "query_records", toolCallId: "a", state: "output-available", input: {}, output: {} },
-      { type: "dynamic-tool", toolName: "query_records", toolCallId: "b", state: "output-available", input: {}, output: {} },
-      { type: "text", text: "Then" },
-      { type: "dynamic-tool", toolName: "delete_records", toolCallId: "c", state: "approval-requested", input: {}, approval: { id: "a1" } },
-    ];
-    expect(toSegments(parts).map((s) => s.kind)).toEqual(["text", "group", "text", "group"]);
-    const [first, second] = groups(parts);
-    expect(first.steps.map((s) => s.id)).toEqual(["a", "b"]);
-    expect(second.steps.map((s) => s.status)).toEqual(["awaiting"]);
-  });
-});

package/src/calendar/layout.test.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { layoutDayColumns, packEventLanes } from "./layout";
-import type { CalendarEvent } from "./types";
-
-const DAY = new Date(2026, 0, 15);
-const at = (h: number, m = 0) => new Date(2026, 0, 15, h, m);
-const ev = (id: string, sh: number, sm: number, eh: number, em: number): CalendarEvent => ({
-  id,
-  title: id,
-  start: at(sh, sm),
-  end: at(eh, em),
-});
-
-/** column/columns keyed by event id, for order-independent assertions. */
-function geom(events: CalendarEvent[]) {
-  return Object.fromEntries(
-    layoutDayColumns(DAY, events).map((c) => [c.event.id, { column: c.column, columns: c.columns }]),
-  );
-}
-
-describe("layoutDayColumns", () => {
-  it("returns nothing for an empty day", () => {
-    expect(layoutDayColumns(DAY, [])).toEqual([]);
-  });
-
-  it("stacks non-overlapping events in a single column", () => {
-    const g = geom([ev("a", 9, 0, 10, 0), ev("b", 11, 0, 12, 0)]);
-    expect(g.a).toEqual({ column: 0, columns: 1 });
-    expect(g.b).toEqual({ column: 0, columns: 1 });
-  });
-
-  it("splits two fully overlapping events into two columns", () => {
-    const g = geom([ev("a", 9, 0, 10, 0), ev("b", 9, 0, 10, 0)]);
-    expect(g.a.columns).toBe(2);
-    expect(g.b.columns).toBe(2);
-    expect(new Set([g.a.column, g.b.column])).toEqual(new Set([0, 1]));
-  });
-
-  it("gives three concurrent events three columns", () => {
-    const g = geom([ev("a", 9, 0, 12, 0), ev("b", 9, 0, 12, 0), ev("c", 9, 0, 12, 0)]);
-    expect(new Set([g.a.column, g.b.column, g.c.column])).toEqual(new Set([0, 1, 2]));
-    for (const k of ["a", "b", "c"]) expect(g[k].columns).toBe(3);
-  });
-
-  it("reuses a freed column within a transitive cluster (A→B→C chain)", () => {
-    // A 9-10, B 9:30-11 (overlaps A), C 10:30-12 (overlaps B, not A).
-    // One cluster via B; 2 columns; C reuses A's column once A ends.
-    const g = geom([ev("a", 9, 0, 10, 0), ev("b", 9, 30, 11, 0), ev("c", 10, 30, 12, 0)]);
-    expect(g.a.columns).toBe(2);
-    expect(g.a.column).toBe(0);
-    expect(g.b.column).toBe(1);
-    expect(g.c.column).toBe(0); // freed by A
-  });
-
-  it("treats time-separated events as independent clusters", () => {
-    const g = geom([ev("morn1", 9, 0, 10, 0), ev("morn2", 9, 0, 10, 0), ev("aft", 14, 0, 15, 0)]);
-    expect(g.morn1.columns).toBe(2);
-    expect(g.morn2.columns).toBe(2);
-    expect(g.aft).toEqual({ column: 0, columns: 1 }); // own cluster
-  });
-
-  it("positions and floors height; clamps to the day window", () => {
-    const [c] = layoutDayColumns(DAY, [ev("x", 9, 0, 9, 5)]);
-    expect(c.topMinutes).toBe(540); // 9:00
-    expect(c.heightMinutes).toBeGreaterThanOrEqual(20); // 5-min event floored
-    const spill = layoutDayColumns(DAY, [
-      { id: "y", title: "y", start: at(23, 0), end: new Date(2026, 0, 16, 2, 0) },
-    ])[0];
-    expect(spill.topMinutes).toBe(1380); // 23:00
-    expect(spill.topMinutes + spill.heightMinutes).toBeLessThanOrEqual(1440); // clamped
-  });
-});
-
-describe("packEventLanes", () => {
-  const WEEK = new Date(2026, 0, 12); // Mon
-  const allDay = (id: string, startDay: number, endDay: number): CalendarEvent => ({
-    id,
-    title: id,
-    start: new Date(2026, 0, 12 + startDay),
-    end: new Date(2026, 0, 12 + endDay),
-    allDay: true,
-  });
-
-  it("places non-overlapping spans in one lane", () => {
-    const { bars, lanes } = packEventLanes([allDay("a", 0, 1), allDay("b", 3, 4)], WEEK, 7);
-    expect(lanes).toBe(1);
-    expect(bars.find((b) => b.event.id === "a")).toMatchObject({ startCol: 0, span: 2, lane: 0 });
-    expect(bars.find((b) => b.event.id === "b")).toMatchObject({ startCol: 3, span: 2, lane: 0 });
-  });
-
-  it("stacks overlapping multi-day spans into separate lanes", () => {
-    const { lanes } = packEventLanes([allDay("a", 0, 3), allDay("b", 2, 5)], WEEK, 7);
-    expect(lanes).toBe(2);
-  });
-
-  it("clamps a span that starts before the window and filters out-of-range", () => {
-    const before: CalendarEvent = { id: "x", title: "x", start: new Date(2026, 0, 9), end: new Date(2026, 0, 13), allDay: true };
-    const after = allDay("y", 9, 10); // entirely after a 7-day window
-    const { bars } = packEventLanes([before, after], WEEK, 7);
-    expect(bars).toHaveLength(1);
-    expect(bars[0]).toMatchObject({ event: { id: "x" }, startCol: 0, span: 2 }); // clamped to days 0..1
-  });
-});

package/src/colors.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isColorName, asColorName } from "./colors";
-
-describe("isColorName", () => {
-  it("accepts palette family names", () => {
-    expect(isColorName("blue")).toBe(true);
-    expect(isColorName("emerald")).toBe(true);
-    expect(isColorName("zinc")).toBe(true);
-  });
-
-  it("rejects role keys and scalar colors (not selectable families)", () => {
-    expect(isColorName("border")).toBe(false);
-    expect(isColorName("border_shadow")).toBe(false);
-    expect(isColorName("background")).toBe(false);
-    expect(isColorName("shadow")).toBe(false);
-    expect(isColorName("black")).toBe(false);
-    expect(isColorName("white")).toBe(false);
-  });
-
-  it("rejects unknown tokens and non-strings", () => {
-    expect(isColorName("chartreuse")).toBe(false);
-    expect(isColorName("")).toBe(false);
-    expect(isColorName(undefined)).toBe(false);
-    expect(isColorName(null)).toBe(false);
-    expect(isColorName(42)).toBe(false);
-  });
-});
-
-describe("asColorName", () => {
-  it("passes a valid family through", () => {
-    expect(asColorName("purple")).toBe("purple");
-  });
-
-  it("degrades an unknown/absent token to the neutral default", () => {
-    // The graceful-degradation contract: a select option whose color token this
-    // build doesn't recognize, or none at all, renders neutral rather than break.
-    expect(asColorName("chartreuse")).toBe("zinc");
-    expect(asColorName(undefined)).toBe("zinc");
-    expect(asColorName(null)).toBe("zinc");
-  });
-
-  it("honors a custom fallback", () => {
-    expect(asColorName(undefined, "slate")).toBe("slate");
-  });
-});