@imfusion/web-ui 0.5.1-dev.25.gf0207a31 → 0.5.1-dev.3.g8e0a047a

package/bin/install.js

@@ -1,343 +0,0 @@
-#!/usr/bin/env node
-
-// Installs this package's agent tooling into the consumer project: the
-// skill family (../src/llms/skills/imf-web-ui*/) and the agent lifecycle
-// hooks the frontend-setup skill ships as templates. Runs in the
-// CONSUMER's environment, so it may only use this package's real runtime
-// dependencies (@clack/prompts). Never wire this into a postinstall hook:
-// ambient script execution on `npm install` is a live supply-chain attack
-// vector — install stays an explicit, user-run command.
-//
-// The skills cross-reference each other, so they install as one bundle.
-// When both targets are selected, .agents/skills/ holds the real copy and
-// .claude/skills/ symlinks it (this repo's own convention) so the two
-// can't drift apart.
-//
-// Flags: bare = skills only; --hooks adds the agent lifecycle hooks (driven
-// by the imf-web-ui-agent-setup skill, which checks the repo's existing hooks
-// first). --target claude|agents (repeatable) for scripted installs,
-// --reconfigure to re-open the target prompt on an existing install.
-
-import {
-  chmodSync,
-  cpSync,
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync
-} from "node:fs";
-import { dirname, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import * as p from "@clack/prompts";
-
-const SKILL_PREFIX = "imf-web-ui";
-const VERSION_MARKER = ".imf-web-ui-skill-version.json";
-
-const here = dirname(fileURLToPath(import.meta.url));
-// Source is relative to THIS SCRIPT's location (inside node_modules), not
-// the consumer's cwd — the script is invoked from the consumer's project
-// root, but the skills it copies ship alongside this file in the package.
-const skillsRoot = resolve(here, "..", "src", "llms", "skills");
-const packageJson = JSON.parse(readFileSync(resolve(here, "..", "package.json"), "utf-8"));
-const currentVersion = packageJson.version;
-
-// Destination is relative to the consumer's project root (cwd), since
-// that's where their `.claude/` or `.agents/` directory lives.
-const projectRoot = process.cwd();
-
-const TARGETS = {
-  claude: { label: "Claude Code", root: resolve(projectRoot, ".claude", "skills") },
-  agents: { label: "Vendor-neutral (.agents/)", root: resolve(projectRoot, ".agents", "skills") }
-};
-
-function discoverSkills() {
-  if (!existsSync(skillsRoot)) return [];
-  return readdirSync(skillsRoot, { withFileTypes: true })
-    .filter(entry => entry.isDirectory() && entry.name.startsWith(SKILL_PREFIX))
-    .map(entry => entry.name)
-    .sort();
-}
-
-function displayPath(absPath) {
-  return `./${relative(projectRoot, absPath)}`;
-}
-
-function readInstalledVersion(dir) {
-  const markerPath = resolve(dir, VERSION_MARKER);
-  if (!existsSync(markerPath)) return null;
-  try {
-    return JSON.parse(readFileSync(markerPath, "utf-8")).version ?? null;
-  } catch {
-    return null;
-  }
-}
-
-function writeRealCopy(sourceDir, destDir) {
-  mkdirSync(dirname(destDir), { recursive: true });
-  // force: true makes re-running after a version bump overwrite cleanly.
-  cpSync(sourceDir, destDir, { recursive: true, force: true });
-  writeFileSync(resolve(destDir, VERSION_MARKER), JSON.stringify({ version: currentVersion }, null, 2) + "\n");
-}
-
-function writeSymlink(linkPath, targetPath) {
-  mkdirSync(dirname(linkPath), { recursive: true });
-  // lstat (not existsSync, which follows symlinks) catches a broken/stale
-  // symlink left over from a prior run, not just a real file or directory.
-  if (lstatSync(linkPath, { throwIfNoEntry: false })) {
-    rmSync(linkPath, { recursive: true, force: true });
-  }
-  symlinkSync(relative(dirname(linkPath), targetPath), linkPath);
-}
-
-function removeOrphanedSkills(selected, skills, both) {
-  const bundledSkills = new Set(skills);
-  const selectedTargets = both ? ["agents", "claude"] : selected;
-
-  for (const key of selectedTargets) {
-    const { root } = TARGETS[key];
-    if (!existsSync(root)) continue;
-
-    const orphanedSkills = readdirSync(root).filter(name => name.startsWith(`${SKILL_PREFIX}-`) && !bundledSkills.has(name));
-    for (const name of orphanedSkills) {
-      rmSync(resolve(root, name), { recursive: true, force: true });
-      // In the two-target layout, .claude/ is a symlinked view of the
-      // canonical .agents/ copy. Remove its matching link along with the
-      // orphaned canonical skill.
-      if (both && key === "agents") {
-        rmSync(resolve(TARGETS.claude.root, name), { recursive: true, force: true });
-      }
-      p.log.info(`Removed orphaned skill: ${name} (no longer in this bundle)`);
-    }
-  }
-}
-
-// A prior install is recoverable from the filesystem, so a re-run doesn't
-// re-ask: a target counts as chosen when any bundled skill is present under
-// it. Symlinks count — they're how the both-targets layout represents
-// .claude/, and lstat avoids following them into the real copy.
-function detectInstalledTargets(skills) {
-  return Object.keys(TARGETS).filter(key =>
-    skills.some(name => lstatSync(resolve(TARGETS[key].root, name), { throwIfNoEntry: false }))
-  );
-}
-
-// Hook templates ship inside the agent-setup skill so they're readable as
-// part of its documentation; the installer copies the scripts into the
-// consumer's .agents/hooks/ and merges the registrations into
-// .claude/settings.json.
-const hooksSourceDir = resolve(skillsRoot, "imf-web-ui-agent-setup", "templates", "hooks");
-const hooksSettingsTemplate = resolve(skillsRoot, "imf-web-ui-agent-setup", "templates", "settings.json");
-// Installer-owned subdirectory: refreshed wholesale on every run, so a repo's
-// own hooks in .agents/hooks/ are never touched.
-const hooksDestDir = resolve(projectRoot, ".agents", "hooks", "imf-web-ui");
-const settingsPath = resolve(projectRoot, ".claude", "settings.json");
-
-function installHookScripts() {
-  const scripts = readdirSync(hooksSourceDir).filter(name => name.endsWith(".sh"));
-  mkdirSync(hooksDestDir, { recursive: true });
-  for (const name of scripts) {
-    const dest = resolve(hooksDestDir, name);
-    cpSync(resolve(hooksSourceDir, name), dest, { force: true });
-    chmodSync(dest, 0o755);
-  }
-  return scripts.length;
-}
-
-// Merge, never clobber: a registration is added only when no existing entry
-// for that event already runs the same command, so re-runs are idempotent
-// and hand-written settings survive.
-function mergeHookRegistrations() {
-  const template = JSON.parse(readFileSync(hooksSettingsTemplate, "utf-8"));
-  let settings = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  settings.hooks ??= {};
-  let added = 0;
-  for (const [event, entries] of Object.entries(template.hooks)) {
-    settings.hooks[event] ??= [];
-    for (const entry of entries) {
-      const commands = entry.hooks.map(hook => hook.command);
-      const present = settings.hooks[event].some(existing =>
-        (existing.hooks ?? []).some(hook => commands.includes(hook.command))
-      );
-      if (!present) {
-        settings.hooks[event].push(entry);
-        added++;
-      }
-    }
-  }
-  mkdirSync(dirname(settingsPath), { recursive: true });
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-  return added;
-}
-
-// The AGENTS.md baseline note lives inside a fenced block owned by this
-// installer. The template between the markers is the source of truth; an
-// existing AGENTS.md gets the block replaced in place (or appended when
-// absent), everything outside the fence is untouched. No AGENTS.md at all
-// is left alone — scaffolding one is the setup skill's job.
-const AGENTS_BLOCK_BEGIN = "<!-- imf-web-ui:begin";
-const AGENTS_BLOCK_END = "<!-- imf-web-ui:end -->";
-const agentsTemplatePath = resolve(skillsRoot, "imf-web-ui-frontend-setup", "templates", "AGENTS.md");
-const agentsPath = resolve(projectRoot, "AGENTS.md");
-
-function extractAgentsBlock(content) {
-  const begin = content.indexOf(AGENTS_BLOCK_BEGIN);
-  const end = content.indexOf(AGENTS_BLOCK_END);
-  if (begin === -1 || end === -1) return null;
-  return content.slice(begin, end + AGENTS_BLOCK_END.length);
-}
-
-function upsertAgentsBlock() {
-  if (!existsSync(agentsPath)) return "absent";
-  const block = extractAgentsBlock(readFileSync(agentsTemplatePath, "utf-8"));
-  if (!block) return "absent";
-  const current = readFileSync(agentsPath, "utf-8");
-  const existing = extractAgentsBlock(current);
-  const next = existing ? current.replace(existing, block) : `${current.trimEnd()}\n\n${block}\n`;
-  if (next === current) return "unchanged";
-  writeFileSync(agentsPath, next);
-  return existing ? "updated" : "added";
-}
-
-// --target claude|agents (repeatable) selects targets without the
-// interactive prompt — for CI and scripted installs.
-function parseTargetFlags(argv) {
-  const targets = [];
-  for (let i = 0; i < argv.length; i++) {
-    if (argv[i] !== "--target") continue;
-    const value = argv[i + 1];
-    if (!value || !(value in TARGETS)) {
-      console.error(`--target expects one of: ${Object.keys(TARGETS).join(", ")}`);
-      process.exit(1);
-    }
-    targets.push(value);
-    i++;
-  }
-  return targets;
-}
-
-async function main() {
-  const skills = discoverSkills();
-  const argv = process.argv.slice(2);
-  const flagTargets = parseTargetFlags(argv);
-  const reconfigure = argv.includes("--reconfigure");
-  // Bare invocation installs skills only. Hooks are opt-in via --hooks — the
-  // imf-web-ui-agent-setup skill drives that after checking what the repo
-  // already registers; the binary stays the dumb mechanical tail.
-  const wantHooks = argv.includes("--hooks");
-  const wantSkills = argv.includes("--skills") || !wantHooks;
-
-  const components = [wantSkills && `${skills.length} skills`, wantHooks && "agent hooks"].filter(Boolean);
-  p.intro(`@imfusion/web-ui install — ${components.join(" + ")}`);
-
-  if (wantSkills && skills.length === 0) {
-    p.log.error(`No skills found at ${skillsRoot}. Reinstall @imfusion/web-ui and try again.`);
-    p.outro("Nothing installed.");
-    process.exitCode = 1;
-    return;
-  }
-
-  if (wantHooks) {
-    const scriptCount = installHookScripts();
-    const added = mergeHookRegistrations();
-    p.log.success(`Agent hooks -> ${displayPath(hooksDestDir)} (${scriptCount} scripts)`);
-    if (added === null) {
-      p.log.warn(`${displayPath(settingsPath)} is not valid JSON — registrations not merged, fix it and re-run.`);
-    } else if (added > 0) {
-      p.log.success(`Registered ${added} hook(s) in ${displayPath(settingsPath)}`);
-    } else {
-      p.log.info(`Hook registrations already present in ${displayPath(settingsPath)}`);
-    }
-    if (!wantSkills) {
-      p.outro("Done — hooks installed.");
-      return;
-    }
-  }
-
-  const installedTargets = detectInstalledTargets(skills);
-
-  const existingVersions = Object.values(TARGETS)
-    .flatMap(({ root }) => skills.map(name => readInstalledVersion(resolve(root, name))))
-    .filter(Boolean);
-  if (existingVersions.length > 0 && existingVersions.every(v => v === currentVersion)) {
-    p.log.info(`Already up to date (v${currentVersion}). Re-running will overwrite with the same content.`);
-  } else if (existingVersions.some(v => v !== currentVersion)) {
-    const from = existingVersions.find(v => v !== currentVersion);
-    p.log.info(`Updating installed skills from v${from} to v${currentVersion}.`);
-  }
-
-  p.log.message(`Skills in this bundle:\n${skills.map(name => `  - ${name}`).join("\n")}`);
-
-  let selected;
-  if (flagTargets.length > 0) {
-    selected = flagTargets;
-    p.log.info(`Targets from --target flags: ${selected.join(", ")}`);
-  } else if (installedTargets.length > 0 && !reconfigure) {
-    selected = installedTargets;
-    p.log.info(
-      `Refreshing the existing install: ${selected.map(key => displayPath(TARGETS[key].root)).join(", ")}` +
-        ` — pass --reconfigure to choose different targets.`
-    );
-  } else {
-    selected = await p.multiselect({
-      message: "Install into which skill directory (or directories)?",
-      options: Object.entries(TARGETS).map(([key, { label, root }]) => ({
-        value: key,
-        label,
-        hint: displayPath(root)
-      })),
-      required: true
-    });
-
-    if (p.isCancel(selected)) {
-      p.cancel("Cancelled — nothing installed.");
-      return;
-    }
-  }
-
-  const both = selected.includes("claude") && selected.includes("agents");
-
-  for (const name of skills) {
-    const sourceDir = resolve(skillsRoot, name);
-    if (both) {
-      // .agents/ is the canonical real copy; .claude/ aliases it via symlink.
-      const realDir = resolve(TARGETS.agents.root, name);
-      writeRealCopy(sourceDir, realDir);
-      writeSymlink(resolve(TARGETS.claude.root, name), realDir);
-    } else {
-      for (const key of selected) {
-        writeRealCopy(sourceDir, resolve(TARGETS[key].root, name));
-      }
-    }
-  }
-
-  removeOrphanedSkills(selected, skills, both);
-
-  if (both) {
-    p.log.success(`Vendor-neutral (.agents/) -> ${displayPath(TARGETS.agents.root)}/${SKILL_PREFIX}*`);
-    p.log.success(`Claude Code -> ${displayPath(TARGETS.claude.root)}/${SKILL_PREFIX}* (symlinks -> .agents/)`);
-  } else {
-    for (const key of selected) {
-      p.log.success(`${TARGETS[key].label} -> ${displayPath(TARGETS[key].root)}/${SKILL_PREFIX}*`);
-    }
-  }
-
-  const agentsResult = upsertAgentsBlock();
-  if (agentsResult === "updated" || agentsResult === "added") {
-    p.log.success(`Refreshed the imf-web-ui block in ${displayPath(agentsPath)}`);
-  }
-
-  p.outro(`Done — ${skills.length} skills installed${wantHooks ? " + agent hooks" : ""}.`);
-}
-
-await main();

package/bin/install.test.ts

@@ -1,166 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { spawnSync } from "node:child_process";
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-  symlinkSync,
-  writeFileSync
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const installer = resolve(fileURLToPath(new URL(".", import.meta.url)), "install.js");
-
-function runInstall(cwd: string, ...args: string[]) {
-  const result = spawnSync("node", [installer, ...args], { cwd, encoding: "utf-8" });
-  expect(result.status).toBe(0);
-  return result;
-}
-
-function readSettings(cwd: string) {
-  return JSON.parse(readFileSync(join(cwd, ".claude", "settings.json"), "utf-8")) as {
-    permissions?: { allow: string[] };
-    hooks: Record<string, { hooks: { command: string }[] }[]>;
-  };
-}
-
-let consumer: string;
-
-beforeEach(() => {
-  consumer = mkdtempSync(join(tmpdir(), "web-ui-install-"));
-});
-
-describe("web-ui-install", () => {
-  it("installs skills into both targets with version markers", () => {
-    runInstall(consumer, "--skills", "--target", "agents", "--target", "claude");
-
-    const installed = readdirSync(join(consumer, ".agents", "skills"));
-    expect(installed).toContain("imf-web-ui");
-    expect(installed).toContain("imf-web-ui-frontend-conventions");
-    expect(installed).toContain("imf-web-ui-frontend-setup");
-
-    for (const name of installed) {
-      expect(existsSync(join(consumer, ".agents", "skills", name, ".imf-web-ui-skill-version.json"))).toBe(true);
-      expect(lstatSync(join(consumer, ".claude", "skills", name)).isSymbolicLink()).toBe(true);
-    }
-  });
-
-  it("removes skills that are no longer included in the bundle", () => {
-    const orphan = "imf-web-ui-retired-skill";
-    const agentsOrphan = join(consumer, ".agents", "skills", orphan);
-    mkdirSync(agentsOrphan, { recursive: true });
-    writeFileSync(join(agentsOrphan, "SKILL.md"), "# Retired skill\n");
-    const claudeOrphan = join(consumer, ".claude", "skills", orphan);
-    mkdirSync(join(consumer, ".claude", "skills"), { recursive: true });
-    symlinkSync(agentsOrphan, claudeOrphan);
-    expect(lstatSync(claudeOrphan).isSymbolicLink()).toBe(true);
-
-    const result = runInstall(consumer, "--skills", "--target", "agents", "--target", "claude");
-
-    expect(existsSync(agentsOrphan)).toBe(false);
-    expect(lstatSync(claudeOrphan, { throwIfNoEntry: false })).toBeUndefined();
-    expect(result.stdout).toContain(`Removed orphaned skill: ${orphan} (no longer in this bundle)`);
-  });
-
-  it("installs hooks into an installer-owned directory and registers them", () => {
-    runInstall(consumer, "--hooks");
-
-    const hookDir = join(consumer, ".agents", "hooks", "imf-web-ui");
-    const scripts = readdirSync(hookDir);
-    expect(scripts).toEqual(expect.arrayContaining(["session-start.sh", "user-prompt-submit.sh", "post-tool-use.sh"]));
-    for (const script of scripts) {
-      expect(statSync(join(hookDir, script)).mode & 0o100).toBeTruthy();
-    }
-
-    const settings = readSettings(consumer);
-    expect(Object.keys(settings.hooks)).toEqual(expect.arrayContaining(["SessionStart", "UserPromptSubmit", "PostToolUse"]));
-    // --hooks alone installs no skills
-    expect(existsSync(join(consumer, ".agents", "skills"))).toBe(false);
-  });
-
-  it("merges registrations without clobbering existing settings, idempotently", () => {
-    mkdirSync(join(consumer, ".claude"), { recursive: true });
-    writeFileSync(
-      join(consumer, ".claude", "settings.json"),
-      JSON.stringify({
-        permissions: { allow: ["Bash(git *)"] },
-        hooks: { PostToolUse: [{ matcher: "Edit", hooks: [{ type: "command", command: "echo existing" }] }] }
-      })
-    );
-
-    runInstall(consumer, "--hooks");
-    runInstall(consumer, "--hooks");
-
-    const settings = readSettings(consumer);
-    expect(settings.permissions?.allow).toEqual(["Bash(git *)"]);
-    const commands = settings.hooks.PostToolUse.flatMap(entry => entry.hooks.map(hook => hook.command));
-    expect(commands).toContain("echo existing");
-    // the shipped registration is added exactly once across both runs
-    expect(commands.filter(command => command.includes("post-tool-use.sh"))).toHaveLength(1);
-  });
-
-  it("upserts the fenced AGENTS.md block and leaves the rest untouched", () => {
-    const agentsPath = join(consumer, "AGENTS.md");
-    writeFileSync(
-      agentsPath,
-      "# AGENTS.md\n\nRepo-specific intro.\n\n<!-- imf-web-ui:begin stale -->\nold content\n<!-- imf-web-ui:end -->\n\nRepo-specific outro.\n"
-    );
-
-    runInstall(consumer, "--skills", "--target", "agents");
-    const updated = readFileSync(agentsPath, "utf-8");
-    expect(updated).toContain("Repo-specific intro.");
-    expect(updated).toContain("Repo-specific outro.");
-    expect(updated).not.toContain("old content");
-    expect(updated).toContain("resynced with `npx web-ui-install`");
-
-    // no fence yet → block is appended; missing AGENTS.md entirely → left alone
-    writeFileSync(agentsPath, "# AGENTS.md\n\nNo fence here.\n");
-    runInstall(consumer, "--skills", "--target", "agents");
-    const appended = readFileSync(agentsPath, "utf-8");
-    expect(appended).toContain("No fence here.");
-    expect(appended).toContain("<!-- imf-web-ui:begin");
-  });
-
-  it("ships hooks that stay advisory: exit 0 with and without a usable payload", () => {
-    runInstall(consumer, "--hooks");
-    const hookDir = join(consumer, ".agents", "hooks", "imf-web-ui");
-
-    const noFile = spawnSync("sh", [join(hookDir, "post-tool-use.sh")], { input: "{}", encoding: "utf-8" });
-    expect(noFile.status).toBe(0);
-
-    const missingFile = spawnSync("sh", [join(hookDir, "post-tool-use.sh")], {
-      input: JSON.stringify({ tool_input: { file_path: join(consumer, "nope.ts") } }),
-      encoding: "utf-8"
-    });
-    expect(missingFile.status).toBe(0);
-
-    const sessionStart = spawnSync("sh", [join(hookDir, "session-start.sh")], { encoding: "utf-8" });
-    expect(sessionStart.status).toBe(0);
-    expect(sessionStart.stdout).toContain("imf-web-ui-frontend-conventions");
-
-    // no node_modules in the consumer → silent success
-    const staleness = spawnSync("sh", [join(hookDir, "baseline-staleness.sh")], { cwd: consumer, encoding: "utf-8" });
-    expect(staleness.status).toBe(0);
-    expect(staleness.stdout).toBe("");
-  });
-
-  it("warns from the staleness script when skill markers lag the package", () => {
-    runInstall(consumer, "--skills", "--hooks", "--target", "agents");
-    const pkgDir = join(consumer, "node_modules", "@imfusion", "web-ui");
-    mkdirSync(pkgDir, { recursive: true });
-    writeFileSync(join(pkgDir, "package.json"), JSON.stringify({ version: "99.0.0" }));
-
-    const result = spawnSync("sh", [join(consumer, ".agents", "hooks", "imf-web-ui", "baseline-staleness.sh")], {
-      cwd: consumer,
-      encoding: "utf-8"
-    });
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain("npx web-ui-install");
-  });
-});

package/dist/build/vite-css-module-names/index.d.ts

@@ -1,20 +0,0 @@
-import { Plugin } from 'vite';
-export interface ReadableCssModuleNamesOptions {
-    /** Namespace for every generated class name. Short, stable, app-scoped (`imf-ui`, `acme`). */
-    prefix: string;
-}
-/**
- * Generates readable CSS Module class names instead of the default hash, so the DOM
- * stays legible in devtools and browser automation. `button.module.css` yields
- * `{prefix}-button-module-root` — `[name]` is the filename, which keeps its `.module`
- * suffix.
- *
- * Register it in every tool that compiles the CSS (the app build AND Storybook). A
- * compiler left out generates different class names for the same source file and its
- * styles silently don't apply.
- *
- * Defaults to opting into Lightning CSS, which drops `css.modules` options it has no
- * equivalent for (`localsConvention`). Set `css.transformer: "postcss"` to stay on
- * the PostCSS pipeline.
- */
-export declare function readableCssModuleNames({ prefix }: ReadableCssModuleNamesOptions): Plugin;

package/dist/build/vite-css-module-names.js

@@ -1,17 +0,0 @@
-//#region src/build/vite-css-module-names/index.ts
-function e(e, t) {
-	let { lightningcss: n, modules: r, transformer: i } = e.css ?? {}, a = n?.cssModules;
-	if (!(typeof a == "boolean" || r === !1) && !a?.pattern && !(typeof r == "object" && r.generateScopedName)) return i === "postcss" ? { css: { modules: { generateScopedName: t } } } : { css: {
-		transformer: "lightningcss",
-		lightningcss: { cssModules: { pattern: t } }
-	} };
-}
-function t({ prefix: t }) {
-	let n = `${t}-[name]-[local]`;
-	return {
-		name: "imf-ui:readable-css-module-names",
-		config: (t) => e(t, n)
-	};
-}
-//#endregion
-export { t as readableCssModuleNames };

package/dist/components/field/field.d.ts

@@ -1,104 +0,0 @@
-import { Field as FieldPrimitive } from '@base-ui/react/field';
-type UpstreamRoot = React.ComponentProps<typeof FieldPrimitive.Root>;
-type UpstreamItem = React.ComponentProps<typeof FieldPrimitive.Item>;
-type UpstreamLabel = React.ComponentProps<typeof FieldPrimitive.Label>;
-type UpstreamDescription = React.ComponentProps<typeof FieldPrimitive.Description>;
-type UpstreamControl = React.ComponentProps<typeof FieldPrimitive.Control>;
-type UpstreamError = React.ComponentProps<typeof FieldPrimitive.Error>;
-type UpstreamValidity = React.ComponentProps<typeof FieldPrimitive.Validity>;
-type RootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    name?: string;
-    actionsRef?: UpstreamRoot["actionsRef"];
-    dirty?: boolean;
-    touched?: boolean;
-    /** @default false */
-    disabled?: boolean;
-    invalid?: boolean;
-    validate?: UpstreamRoot["validate"];
-    /** @default "onSubmit" */
-    validationMode?: UpstreamRoot["validationMode"];
-    /** @default 0 */
-    validationDebounceTime?: number;
-    className?: UpstreamRoot["className"];
-    style?: UpstreamRoot["style"];
-    render?: UpstreamRoot["render"];
-};
-/**
- * Field.Root — groups a label, control, validation state, and supporting copy.
- *
- * @doc https://base-ui.com/react/components/field
- * @llm https://base-ui.com/react/components/field.md
- */
-export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace Root {
-    var displayName: string;
-}
-type ItemProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    /** @default false */
-    disabled?: boolean;
-    className?: UpstreamItem["className"];
-    style?: UpstreamItem["style"];
-    render?: UpstreamItem["render"];
-};
-/** Field.Item — groups one checkable option with its label and description. */
-export declare function Item({ className, ...props }: ItemProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace Item {
-    var displayName: string;
-}
-type LabelProps = Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "className" | "style"> & {
-    /** @default true */
-    nativeLabel?: boolean;
-    className?: UpstreamLabel["className"];
-    style?: UpstreamLabel["style"];
-    render?: UpstreamLabel["render"];
-};
-/** Field.Label — an accessible label automatically associated with the control. */
-export declare function Label({ className, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace Label {
-    var displayName: string;
-}
-type DescriptionProps = Omit<React.HTMLAttributes<HTMLParagraphElement>, "className" | "style"> & {
-    className?: UpstreamDescription["className"];
-    style?: UpstreamDescription["style"];
-    render?: UpstreamDescription["render"];
-};
-/** Field.Description — supporting information for a field. */
-export declare function Description({ className, ...props }: DescriptionProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace Description {
-    var displayName: string;
-}
-type ControlProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "style" | "defaultValue"> & {
-    defaultValue?: UpstreamControl["defaultValue"];
-    onValueChange?: UpstreamControl["onValueChange"];
-    className?: UpstreamControl["className"];
-    style?: UpstreamControl["style"];
-    render?: UpstreamControl["render"];
-};
-/** Field.Control — a native input control with Field labeling and validation. */
-export declare function Control({ className, ...props }: ControlProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace Control {
-    var displayName: string;
-}
-type ErrorProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    match?: UpstreamError["match"];
-    className?: UpstreamError["className"];
-    style?: UpstreamError["style"];
-    render?: UpstreamError["render"];
-};
-/** Field.Error — an inline validation message shown when its match condition fails. */
-export declare function Error({ className, ...props }: ErrorProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace Error {
-    var displayName: string;
-}
-type ValidityProps = {
-    children: UpstreamValidity["children"];
-};
-/**
- * Field.Validity — renderless access to the field validity data for custom messages.
- * Its function child owns the rendered element and therefore its identity and styling.
- */
-export declare function Validity({ children }: ValidityProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace Validity {
-    var displayName: string;
-}
-export {};

package/dist/components/field/field.meta.d.ts

@@ -1,2 +0,0 @@
-import { ComponentMeta } from '../../types/meta';
-export declare const fieldMeta: ComponentMeta;

package/dist/components/field/index.d.ts

@@ -1,2 +0,0 @@
-export * as Field from './field';
-export { fieldMeta } from './field.meta';