@tulip-systems/core 0.9.0 → 0.10.0

package/dist/commands.d.mts

@@ -1,3 +1,4 @@
-import { CommandCondition, CommandDef, CommandRender, CommandStatus, CommandUI, commandBuilder, createCommandBuilder } from "./src/modules/commands/lib/builder.mjs";
+import { AnyCommandDef, CommandCondition, CommandDef, CommandFor, CommandRender, CommandStatus, CommandTag, CommandUI, ExtractCommandData, commandBuilder, createCommandBuilder } from "./src/modules/commands/lib/builder.mjs";
 import { CommandMap, defineCommands } from "./src/modules/commands/lib/registery.mjs";
-export { CommandCondition, CommandDef, CommandMap, CommandRender, CommandStatus, CommandUI, commandBuilder, createCommandBuilder, defineCommands };
+import { ensureArray } from "./src/modules/commands/lib/utils.mjs";
+export { AnyCommandDef, CommandCondition, CommandDef, CommandFor, CommandMap, CommandRender, CommandStatus, CommandTag, CommandUI, ExtractCommandData, commandBuilder, createCommandBuilder, defineCommands, ensureArray };

package/dist/commands.mjs

@@ -1,4 +1,5 @@
 import { commandBuilder, createCommandBuilder } from "./src/modules/commands/lib/builder.mjs";
 import { defineCommands } from "./src/modules/commands/lib/registery.mjs";
+import { ensureArray } from "./src/modules/commands/lib/utils.mjs";
 
-export { commandBuilder, createCommandBuilder, defineCommands };
+export { commandBuilder, createCommandBuilder, defineCommands, ensureArray };

package/dist/components/ui/badge.d.mts

@@ -5,7 +5,7 @@ import * as class_variance_authority_types0 from "class-variance-authority/types
 
 //#region src/components/ui/badge.d.ts
 declare const badgeVariants: (props?: ({
-  variant?: "link" | "default" | "outline" | "destructive" | "secondary" | "ghost" | null | undefined;
+  variant?: "link" | "default" | "destructive" | "secondary" | "outline" | "ghost" | null | undefined;
 } & class_variance_authority_types0.ClassProp) | undefined) => string;
 declare function Badge({
   className,

package/dist/components/ui/button-group.d.mts

@@ -5,7 +5,7 @@ import * as class_variance_authority_types0 from "class-variance-authority/types
 
 //#region src/components/ui/button-group.d.ts
 declare const buttonGroupVariants: (props?: ({
-  orientation?: "vertical" | "horizontal" | null | undefined;
+  orientation?: "horizontal" | "vertical" | null | undefined;
 } & class_variance_authority_types0.ClassProp) | undefined) => string;
 declare function ButtonGroup({
   className,

package/dist/components/ui/button.d.mts

@@ -5,8 +5,8 @@ import * as class_variance_authority_types0 from "class-variance-authority/types
 
 //#region src/components/ui/button.d.ts
 declare const buttonVariants: (props?: ({
-  variant?: "link" | "default" | "outline" | "destructive" | "secondary" | "ghost" | null | undefined;
-  size?: "default" | "xs" | "sm" | "icon-xs" | "icon-sm" | "lg" | "icon" | "icon-lg" | null | undefined;
+  variant?: "link" | "default" | "destructive" | "secondary" | "outline" | "ghost" | null | undefined;
+  size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
 } & class_variance_authority_types0.ClassProp) | undefined) => string;
 declare function Button({
   className,

package/dist/components/ui/field.client.d.mts

@@ -20,7 +20,7 @@ declare function FieldGroup({
   ...props
 }: React.ComponentProps<"div">): react_jsx_runtime0.JSX.Element;
 declare const fieldVariants: (props?: ({
-  orientation?: "vertical" | "horizontal" | "responsive" | null | undefined;
+  orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
 } & class_variance_authority_types0.ClassProp) | undefined) => string;
 declare function Field({
   className,

package/dist/data-tables/client.d.mts

@@ -10,6 +10,7 @@ import { TableSearchInput } from "../src/modules/data-tables/components/search-i
 import { TableConfigContextValue, TableConfigProvider, createTableConfig, useTableConfigContext } from "../src/modules/data-tables/hooks/use-context.client.mjs";
 import { useTable } from "../src/modules/data-tables/hooks/use-table.client.mjs";
 import { InfiniteStrategyMeta, UseInfiniteStrategyInput, useInfiniteStrategy } from "../src/modules/data-tables/strategies/infinite/strategy.mjs";
+import { LocalStrategy, UseLocalStrategyInput, useLocalStrategy } from "../src/modules/data-tables/strategies/local/strategy.mjs";
 import { PaginationStrategy, UsePaginationStrategyInput, usePaginationStrategy } from "../src/modules/data-tables/strategies/pagination/strategy.mjs";
 import { DataTable } from "../src/modules/data-tables/tables/data-table/components/table.mjs";
 import { TableInlineCell } from "../src/modules/data-tables/tables/inline-table/components/cells/common.mjs";
@@ -18,4 +19,4 @@ import { InlineDataTableReadOnly } from "../src/modules/data-tables/tables/inlin
 import { INLINE_INPUT_ATTR, InlineDataTableHotkeysConfig, useInlineDataTableHotkeys } from "../src/modules/data-tables/tables/inline-table/hooks/use-hotkeys.client.mjs";
 import { InlineTableContextValue, InlineTableProvider, useInlineTableContext } from "../src/modules/data-tables/tables/inline-table/hooks/context.client.mjs";
 import { InlineTable } from "../src/modules/data-tables/tables/inline-table/components/table.mjs";
-export { DataTable, INLINE_INPUT_ATTR, InfiniteStrategyMeta, InlineDataTableHotkeysConfig, InlineDataTableReadOnly, InlineTable, InlineTableContextValue, InlineTableProvider, PaginationStrategy, TableConfigContextValue, TableConfigProvider, TableDateCell, TableDragHandle, TableDragHandleProps, TableFilterCombobox, TableFilterComboboxOption, TableFilterComboboxProps, TableFilterDateRange, TableFilterDateRangePreset, TableFilterDateRangeProps, TableFilterDateRangeValue, TableFilterSearch, TableFilterSearchProps, TableFilterSlider, TableFilterSliderProps, TableFilterToggle, TableFilterToggleProps, TableInlineCell, TableNumberCell, TableSearchInput, TableStatusCell, TableTextCell, UseInfiniteStrategyInput, UsePaginationStrategyInput, createTableConfig, createTableDragHandleCell, createTableIndexCell, createTableSelectCell, useInfiniteStrategy, useInlineDataTableHotkeys, useInlineTableContext, usePaginationStrategy, useTable, useTableConfigContext };
+export { DataTable, INLINE_INPUT_ATTR, InfiniteStrategyMeta, InlineDataTableHotkeysConfig, InlineDataTableReadOnly, InlineTable, InlineTableContextValue, InlineTableProvider, LocalStrategy, PaginationStrategy, TableConfigContextValue, TableConfigProvider, TableDateCell, TableDragHandle, TableDragHandleProps, TableFilterCombobox, TableFilterComboboxOption, TableFilterComboboxProps, TableFilterDateRange, TableFilterDateRangePreset, TableFilterDateRangeProps, TableFilterDateRangeValue, TableFilterSearch, TableFilterSearchProps, TableFilterSlider, TableFilterSliderProps, TableFilterToggle, TableFilterToggleProps, TableInlineCell, TableNumberCell, TableSearchInput, TableStatusCell, TableTextCell, UseInfiniteStrategyInput, UseLocalStrategyInput, UsePaginationStrategyInput, createTableConfig, createTableDragHandleCell, createTableIndexCell, createTableSelectCell, useInfiniteStrategy, useInlineDataTableHotkeys, useInlineTableContext, useLocalStrategy, usePaginationStrategy, useTable, useTableConfigContext };

package/dist/data-tables/client.mjs

@@ -10,6 +10,7 @@ import { TableConfigProvider, createTableConfig, useTableConfigContext } from ".
 import { TableSearchInput } from "../src/modules/data-tables/components/search-input.client.mjs";
 import { useTable } from "../src/modules/data-tables/hooks/use-table.client.mjs";
 import { useInfiniteStrategy } from "../src/modules/data-tables/strategies/infinite/strategy.mjs";
+import { useLocalStrategy } from "../src/modules/data-tables/strategies/local/strategy.mjs";
 import { usePaginationStrategy } from "../src/modules/data-tables/strategies/pagination/strategy.mjs";
 import { DataTable } from "../src/modules/data-tables/tables/data-table/components/table.mjs";
 import { TableInlineCell } from "../src/modules/data-tables/tables/inline-table/components/cells/common.mjs";
@@ -19,4 +20,4 @@ import { InlineTableProvider, useInlineTableContext } from "../src/modules/data-
 import { INLINE_INPUT_ATTR, useInlineDataTableHotkeys } from "../src/modules/data-tables/tables/inline-table/hooks/use-hotkeys.client.mjs";
 import { InlineTable } from "../src/modules/data-tables/tables/inline-table/components/table.mjs";
 
-export { DataTable, INLINE_INPUT_ATTR, InlineDataTableReadOnly, InlineTable, InlineTableProvider, TableConfigProvider, TableDateCell, TableDragHandle, TableFilterCombobox, TableFilterDateRange, TableFilterSearch, TableFilterSlider, TableFilterToggle, TableInlineCell, TableNumberCell, TableSearchInput, TableStatusCell, TableTextCell, createTableConfig, createTableDragHandleCell, createTableIndexCell, createTableSelectCell, useInfiniteStrategy, useInlineDataTableHotkeys, useInlineTableContext, usePaginationStrategy, useTable, useTableConfigContext };
+export { DataTable, INLINE_INPUT_ATTR, InlineDataTableReadOnly, InlineTable, InlineTableProvider, TableConfigProvider, TableDateCell, TableDragHandle, TableFilterCombobox, TableFilterDateRange, TableFilterSearch, TableFilterSlider, TableFilterToggle, TableInlineCell, TableNumberCell, TableSearchInput, TableStatusCell, TableTextCell, createTableConfig, createTableDragHandleCell, createTableIndexCell, createTableSelectCell, useInfiniteStrategy, useInlineDataTableHotkeys, useInlineTableContext, useLocalStrategy, usePaginationStrategy, useTable, useTableConfigContext };

package/dist/modules/commands/components/menus/context-menu.client.d.mts

@@ -1,14 +1,13 @@
 import { ContextMenu, ContextMenuContent, ContextMenuTrigger } from "../../../../components/ui/context-menu.client.mjs";
-import { CommandDef } from "../../lib/builder.mjs";
+import { AnyCommandDef, ExtractCommandData } from "../../lib/builder.mjs";
 import { CommandContextLifecycle } from "../../hooks/use-command.client.mjs";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { ComponentProps, ReactNode } from "react";
-import z from "zod";
 
 //#region src/modules/commands/components/menus/context-menu.client.d.ts
-type ContextCommandMenuContentProps<TSchema extends z.ZodTypeAny, TMeta> = ComponentProps<typeof ContextMenuContent> & CommandContextLifecycle & {
-  data: unknown;
-  commands: Array<CommandDef<z.ZodTypeAny, TMeta>>;
+type ContextCommandMenuContentProps<TCommand extends AnyCommandDef, TMeta = object> = ComponentProps<typeof ContextMenuContent> & CommandContextLifecycle & {
+  data: NoInfer<ExtractCommandData<TCommand>>;
+  commands: TCommand[];
   meta?: TMeta;
   fallback?: ReactNode;
   emptyLabel?: string;
@@ -24,7 +23,7 @@ declare const ContextCommandMenuTrigger: typeof ContextMenuTrigger;
 /**
  * ContextCommandMenuContent
  */
-declare function ContextCommandMenuContent<TSchema extends z.ZodTypeAny, TMeta>({
+declare function ContextCommandMenuContent<TCommand extends AnyCommandDef, TMeta = object>({
   data,
   commands,
   meta,
@@ -35,6 +34,6 @@ declare function ContextCommandMenuContent<TSchema extends z.ZodTypeAny, TMeta>(
   className,
   emptyLabel,
   ...props
-}: ContextCommandMenuContentProps<TSchema, TMeta>): react_jsx_runtime0.JSX.Element;
+}: ContextCommandMenuContentProps<TCommand, TMeta>): react_jsx_runtime0.JSX.Element;
 //#endregion
 export { ContextCommandMenu, ContextCommandMenuContent, ContextCommandMenuContentProps, ContextCommandMenuTrigger };

package/dist/modules/commands/components/menus/dropdown-menu.client.d.mts

@@ -1,17 +1,16 @@
-import { CommandDef } from "../../lib/builder.mjs";
+import { AnyCommandDef, ExtractCommandData } from "../../lib/builder.mjs";
 import { CommandContextLifecycle } from "../../hooks/use-command.client.mjs";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { ComponentProps, HTMLAttributes, ReactNode } from "react";
-import z from "zod";
 
 //#region src/modules/commands/components/menus/dropdown-menu.client.d.ts
-type DropdownCommandMenuProps<TSchema extends z.ZodTypeAny, TMeta> = HTMLAttributes<HTMLElement> & CommandContextLifecycle & {
-  data: unknown;
-  commands: Array<CommandDef<z.ZodTypeAny, TMeta>>;
+type DropdownCommandMenuProps<TCommand extends AnyCommandDef, TMeta = object> = HTMLAttributes<HTMLElement> & CommandContextLifecycle & {
+  data: NoInfer<ExtractCommandData<TCommand>>;
+  commands: TCommand[];
   meta?: TMeta;
   fallback?: ReactNode;
 };
-declare function DropdownCommandMenu<TSchema extends z.ZodTypeAny, TMeta>({
+declare function DropdownCommandMenu<TCommand extends AnyCommandDef, TMeta = object>({
   data,
   commands,
   meta,
@@ -21,7 +20,7 @@ declare function DropdownCommandMenu<TSchema extends z.ZodTypeAny, TMeta>({
   onSettled,
   className,
   ...props
-}: DropdownCommandMenuProps<TSchema, TMeta>): react_jsx_runtime0.JSX.Element | null;
+}: DropdownCommandMenuProps<TCommand, TMeta>): react_jsx_runtime0.JSX.Element | null;
 declare function DropdownCommandMenuLoading({
   className,
   ...props

package/dist/modules/commands/components/menus/floating-menu.client.d.mts

@@ -1,19 +1,18 @@
-import { CommandDef } from "../../lib/builder.mjs";
+import { AnyCommandDef, ExtractCommandData } from "../../lib/builder.mjs";
 import { CommandContextLifecycle } from "../../hooks/use-command.client.mjs";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { HTMLAttributes, ReactNode } from "react";
-import z from "zod";
 
 //#region src/modules/commands/components/menus/floating-menu.client.d.ts
-type FloatingCommandMenuProps<TSchema extends z.ZodTypeAny, TMeta> = HTMLAttributes<HTMLElement> & CommandContextLifecycle & {
-  data: unknown;
-  commands: Array<CommandDef<z.ZodTypeAny, TMeta>>;
+type FloatingCommandMenuProps<TCommand extends AnyCommandDef, TMeta = object> = HTMLAttributes<HTMLElement> & CommandContextLifecycle & {
+  data: NoInfer<ExtractCommandData<TCommand>>;
+  commands: TCommand[];
   meta?: TMeta;
   fallback?: ReactNode;
   state: "open" | "closed";
   emptyLabel?: string;
 };
-declare function FloatingCommandMenu<TSchema extends z.ZodTypeAny, TMeta>({
+declare function FloatingCommandMenu<TCommand extends AnyCommandDef, TMeta = object>({
   data,
   commands,
   meta,
@@ -25,6 +24,6 @@ declare function FloatingCommandMenu<TSchema extends z.ZodTypeAny, TMeta>({
   className,
   emptyLabel,
   ...props
-}: FloatingCommandMenuProps<TSchema, TMeta>): react_jsx_runtime0.JSX.Element;
+}: FloatingCommandMenuProps<TCommand, TMeta>): react_jsx_runtime0.JSX.Element;
 //#endregion
 export { FloatingCommandMenu, FloatingCommandMenuProps };

package/dist/modules/commands/components/menus/inline-menu.client.d.mts

@@ -1,17 +1,16 @@
-import { CommandDef } from "../../lib/builder.mjs";
+import { AnyCommandDef, ExtractCommandData } from "../../lib/builder.mjs";
 import { CommandContextLifecycle } from "../../hooks/use-command.client.mjs";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { ComponentProps, HTMLAttributes, ReactNode } from "react";
-import z from "zod";
 
 //#region src/modules/commands/components/menus/inline-menu.client.d.ts
-type InlineCommandMenuProps<TSchema extends z.ZodTypeAny, TMeta> = HTMLAttributes<HTMLElement> & CommandContextLifecycle & {
-  data: unknown;
-  commands: Array<CommandDef<z.ZodTypeAny, TMeta>>;
+type InlineCommandMenuProps<TCommand extends AnyCommandDef, TMeta = object> = HTMLAttributes<HTMLElement> & CommandContextLifecycle & {
+  data: NoInfer<ExtractCommandData<TCommand>>;
+  commands: TCommand[];
   meta?: TMeta;
   fallback?: ReactNode;
 };
-declare function InlineCommandMenu<TSchema extends z.ZodTypeAny, TMeta>({
+declare function InlineCommandMenu<TCommand extends AnyCommandDef, TMeta = object>({
   data,
   meta,
   commands,
@@ -21,7 +20,7 @@ declare function InlineCommandMenu<TSchema extends z.ZodTypeAny, TMeta>({
   onSettled,
   className,
   ...props
-}: InlineCommandMenuProps<TSchema, TMeta>): react_jsx_runtime0.JSX.Element | null;
+}: InlineCommandMenuProps<TCommand, TMeta>): react_jsx_runtime0.JSX.Element | null;
 declare function InlineCommandMenuLoading({
   className,
   ...props

package/dist/modules/commands/components/menus/responsive-menu.client.d.mts

@@ -1,17 +1,16 @@
-import { CommandDef } from "../../lib/builder.mjs";
+import { AnyCommandDef, ExtractCommandData } from "../../lib/builder.mjs";
 import { CommandContextLifecycle } from "../../hooks/use-command.client.mjs";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";
-import z from "zod";
 
 //#region src/modules/commands/components/menus/responsive-menu.client.d.ts
-type ResponsiveCommandMenuProps<TSchema extends z.ZodTypeAny, TMeta> = CommandContextLifecycle & {
-  data: unknown;
-  commands: Array<CommandDef<z.ZodTypeAny, TMeta>>;
+type ResponsiveCommandMenuProps<TCommand extends AnyCommandDef, TMeta = object> = CommandContextLifecycle & {
+  data: NoInfer<ExtractCommandData<TCommand>>;
+  commands: TCommand[];
   meta?: TMeta;
   fallback?: ReactNode;
 };
-declare function ResponsiveCommandMenu<TSchema extends z.ZodTypeAny, TMeta>(props: ResponsiveCommandMenuProps<TSchema, TMeta>): react_jsx_runtime0.JSX.Element;
+declare function ResponsiveCommandMenu<TCommand extends AnyCommandDef, TMeta = object>(props: ResponsiveCommandMenuProps<TCommand, TMeta>): react_jsx_runtime0.JSX.Element;
 declare function ResponsiveCommandMenuLoading(): react_jsx_runtime0.JSX.Element;
 //#endregion
 export { ResponsiveCommandMenu, ResponsiveCommandMenuLoading, ResponsiveCommandMenuProps };

package/dist/modules/commands/components/render-command.mjs

@@ -8,13 +8,11 @@ import { Fragment, jsx } from "react/jsx-runtime";
 /**
 * Command renderer.
 *
-* It validates input data through the command schema, applies optional visibility/disabled rules,
-* exposes command status via context, and then renders the command content.
+* It applies cheap visibility/disabled rules, exposes command status via context,
+* and then renders the command content. Validation belongs at execution boundaries.
 */
 function RenderCommand(props) {
-	const parsedData = props.command.schema.safeParse(props.data);
-	if (!parsedData.success) return /* @__PURE__ */ jsx(Fragment, { children: props.fallback });
-	const data = parsedData.data;
+	const data = props.command.transform ? props.command.transform(props.data) : props.data;
 	const meta = props.meta ?? {};
 	const visibleResult = props.command.visibleWhen?.({
 		data,

package/dist/modules/commands/lib/builder.d.mts

@@ -1,39 +1,135 @@
 import { Permission } from "../../auth/lib/permissions.mjs";
-import { z as z$1 } from "zod";
 
 //#region src/modules/commands/lib/builder.d.ts
+/**
+ * The different UI contexts in which a command can be rendered.
+ */
 type CommandUI = "dropdown" | "context" | "table" | "inline" | "custom";
+/**
+ * The status of a command, which can be used to style the command's UI appropriately.
+ */
 type CommandStatus = "idle" | "pending" | "success" | "error";
-type CommandCondition<TSchema extends z$1.ZodTypeAny, TMeta> = (params: {
-  data: z$1.output<TSchema>;
+/**
+ * A string tag that can be added to a command for organizational and filtering purposes.
+ */
+type CommandTag = string;
+/**
+ * Represents a command definition with its associated types and properties.
+ */
+type AnyCommandDef = CommandDef<any, any, any, any>;
+/**
+ * Condition function that determines whether a command is visible or disabled based on the provided data and meta.
+ */
+type CommandCondition<TData, TMeta> = (params: {
+  data: TData;
   meta: TMeta;
 }) => boolean | boolean[];
-type CommandRender<TSchema extends z$1.ZodTypeAny, TMeta> = (params: {
-  data: z$1.output<TSchema>;
+/**
+ * Render function that defines how a command should be rendered based on the provided data, meta, and UI context.
+ */
+type CommandRender<TData, TMeta> = (params: {
+  data: TData;
   meta: TMeta;
   ui: CommandUI;
 }) => React.ReactNode;
 /**
  * Final command definition (without name).
  * Name is derived from the object key in `defineCommands`.
+ *
+ * @typeParam TData  - The type `visibleWhen`, `disabledWhen`, and `render` receive.
+ *                    When `.transform()` is used this is the post-transform type.
+ * @typeParam TMeta  - Shared contextual metadata passed alongside data.
+ * @typeParam TTags  - Literal tuple of tag strings preserved from the builder's
+ *                    `.tags()` call. Enables compile-time tag filtering in the
+ *                    registry. Defaults to `string[]` when not provided.
+ * @typeParam TInput - The type that menus must pass as `data`. Equals `TData`
+ *                    when no `.transform()` is used. When `.transform(fn)` is
+ *                    called, `TInput` captures the pre-transform type so menus
+ *                    remain correctly typed while `render` sees the transformed type.
+ *                    Structurally expressed as the parameter of `transform`.
  */
-type CommandDef<TSchema extends z$1.ZodTypeAny = z$1.ZodTypeAny, TMeta = object> = {
+type CommandDef<TData = unknown, TMeta = object, TTags extends readonly string[] = string[], TInput = TData> = {
+  id?: string;
+  tags: TTags;
+  transform?: (data: TInput) => TData;
   permission?: Permission;
-  schema: TSchema;
-  visibleWhen?: CommandCondition<TSchema, TMeta>;
-  disabledWhen?: CommandCondition<TSchema, TMeta>;
-  render: CommandRender<TSchema, TMeta>;
+  visibleWhen?: CommandCondition<TData, TMeta>;
+  disabledWhen?: CommandCondition<TData, TMeta>;
+  render: CommandRender<TData, TMeta>;
 };
-type ReadyCommandBuilder<TSchema extends z$1.ZodTypeAny, TMeta> = {
-  permission(permission: Permission): ReadyCommandBuilder<TSchema, TMeta>;
-  visibleWhen(condition: CommandCondition<TSchema, TMeta>): ReadyCommandBuilder<TSchema, TMeta>;
-  disabledWhen(condition: CommandCondition<TSchema, TMeta>): ReadyCommandBuilder<TSchema, TMeta>;
-  render(render: CommandRender<TSchema, TMeta>): CommandDef<TSchema, TMeta>;
+/**
+ * Command typed by accepted input data.
+ *
+ * Useful for APIs that only care about what can be passed in (e.g. table
+ * providers that always pass selected rows), not the command's normalized
+ * render-time shape.
+ */
+type CommandFor<TInput, TMeta = object> = CommandDef<any, TMeta, any, TInput>;
+/**
+ * Extracts the **input** data type of a command — what menus must pass as `data`.
+ *
+ * - When `.transform()` is used, this is the pre-transform type (e.g. `Template | Template[]`).
+ * - Otherwise it equals the render-time type.
+ *
+ * The type is read from the `transform` field's parameter when present, and
+ * falls back to the `render` parameter when there is no transformer.
+ */
+type ExtractCommandData<TCommand extends AnyCommandDef> = [NonNullable<TCommand["transform"]>] extends [never] ? TCommand extends {
+  render: (params: {
+    data: infer TData;
+    meta: any;
+    ui: any;
+  }) => any;
+} ? TData : never : NonNullable<TCommand["transform"]> extends ((data: infer TInput) => any) ? TInput : never;
+/**
+ * Builder state after `.$type<TData>()` has been called (or at initial state
+ * with `TData = unknown`).
+ *
+ * @typeParam TData  - Current render-time data type (post-transform if used).
+ * @typeParam TTags  - Literal tag tuple, carried through every method so that
+ *                    the final `CommandDef` retains the literal type.
+ * @typeParam TInput - Input data type for menus. Starts equal to `TData`.
+ *                    Freezes to the value of `TData` at the moment `.transform()`
+ *                    is called, while `TData` changes to the transformer's output.
+ */
+type ReadyCommandBuilder<TData, TMeta, TTags extends readonly string[] = string[], TInput = TData> = {
+  /** Override the data (and optionally meta) type. Resets `TInput` to the new `TData`. */$type<TNewData, TNewMeta = TMeta>(): ReadyCommandBuilder<TNewData, TNewMeta, TTags, TNewData>;
+  /**
+   * Set the command's tags as a literal tuple. The `const` modifier infers
+   * string arguments as literals, enabling compile-time tag narrowing in the registry.
+   */
+  tags<const TNewTags extends string[]>(...tags: TNewTags): ReadyCommandBuilder<TData, TMeta, TNewTags, TInput>;
+  permission(permission: Permission): ReadyCommandBuilder<TData, TMeta, TTags, TInput>;
+  /**
+   * Declares a lightweight transformer that runs once per render — before `visibleWhen`,
+   * `disabledWhen`, and `render` — collapsing the input type into a single usable shape.
+   *
+   * Freezes `TInput` to the current `TData` (the pre-transform type) and advances
+   * `TData` to `TNewData` (the transformer's return type). This ensures:
+   * - Menus are typed against the union input (e.g. `Template | Template[]`)
+   * - `visibleWhen` and `render` work with the clean transformed type (e.g. `Template[]`)
+   *
+   * @example
+   * commandBuilder
+   *   .$type<Template | Template[]>()
+   *   .transform((data) => (Array.isArray(data) ? data : [data]))
+   *   .visibleWhen(({ data }) => data.length > 0)  // data: Template[]
+   *   .render(({ data }) => <ArchiveCommand ids={data.map(i => i.id)} />)
+   */
+  transform<TNewData>(fn: (data: TData) => TNewData): ReadyCommandBuilder<TNewData, TMeta, TTags, TData>;
+  visibleWhen(condition: CommandCondition<TData, TMeta>): ReadyCommandBuilder<TData, TMeta, TTags, TInput>;
+  disabledWhen(condition: CommandCondition<TData, TMeta>): ReadyCommandBuilder<TData, TMeta, TTags, TInput>; /** Terminal — produces the final `CommandDef`. */
+  render(render: CommandRender<TData, TMeta>): CommandDef<TData, TMeta, TTags, TInput>;
 };
-type InitialCommandBuilder<TMeta> = {
-  input<TNextSchema extends z$1.ZodTypeAny>(schema: TNextSchema): ReadyCommandBuilder<TNextSchema, TMeta>;
+/**
+ * The initial builder returned by `commandBuilder` / `createCommandBuilder()`.
+ * Before `.$type<>()` is called, `TData` is `unknown`.
+ */
+type InitialCommandBuilder<TMeta> = ReadyCommandBuilder<unknown, TMeta, string[], unknown> & {
+  $type<TNewData, TNewMeta = TMeta>(): ReadyCommandBuilder<TNewData, TNewMeta, string[], TNewData>;
+  tags<const TNewTags extends string[]>(...tags: TNewTags): ReadyCommandBuilder<unknown, TMeta, TNewTags, unknown>;
 };
 declare function createCommandBuilder<TMeta = object>(): InitialCommandBuilder<TMeta>;
 declare const commandBuilder: InitialCommandBuilder<object>;
 //#endregion
-export { CommandCondition, CommandDef, CommandRender, CommandStatus, CommandUI, commandBuilder, createCommandBuilder };
+export { AnyCommandDef, CommandCondition, CommandDef, CommandFor, CommandRender, CommandStatus, CommandTag, CommandUI, ExtractCommandData, commandBuilder, createCommandBuilder };

package/dist/modules/commands/lib/builder.mjs

@@ -1,20 +1,54 @@
 //#region src/modules/commands/lib/builder.ts
 function createInitialBuilder(state) {
-	return { input(schema) {
-		return createReadyBuilder({
-			permission: state.permission,
-			schema
-		});
-	} };
+	return {
+		...createReadyBuilder({
+			tags: state.tags ?? [],
+			permission: state.permission
+		}),
+		tags(...tags) {
+			return createReadyBuilder({
+				tags,
+				permission: state.permission
+			});
+		},
+		$type() {
+			return createReadyBuilder({
+				tags: state.tags ?? [],
+				permission: state.permission
+			});
+		}
+	};
 }
 function createReadyBuilder(state) {
 	return {
+		$type() {
+			return createReadyBuilder({
+				tags: state.tags,
+				permission: state.permission
+			});
+		},
+		tags(...tags) {
+			return createReadyBuilder({
+				tags,
+				permission: state.permission,
+				transform: state.transform,
+				visibleWhen: state.visibleWhen,
+				disabledWhen: state.disabledWhen
+			});
+		},
 		permission(permission) {
 			return createReadyBuilder({
 				...state,
 				permission
 			});
 		},
+		transform(fn) {
+			return createReadyBuilder({
+				tags: state.tags,
+				permission: state.permission,
+				transform: fn
+			});
+		},
 		visibleWhen(condition) {
 			return createReadyBuilder({
 				...state,
@@ -29,8 +63,9 @@ function createReadyBuilder(state) {
 		},
 		render(render) {
 			return {
+				tags: state.tags,
+				transform: state.transform,
 				permission: state.permission,
-				schema: state.schema,
 				visibleWhen: state.visibleWhen,
 				disabledWhen: state.disabledWhen,
 				render

package/dist/modules/commands/lib/registery.d.mts

@@ -1,11 +1,28 @@
-import { CommandDef } from "./builder.mjs";
-import z from "zod";
+import { AnyCommandDef } from "./builder.mjs";
 
 //#region src/modules/commands/lib/registery.d.ts
 /**
  * Command map type defining the shape of command definitions.
  */
-type CommandMap = Record<string, CommandDef<z.ZodTypeAny, any>>;
+type CommandMap = Record<string, AnyCommandDef>;
+/** Union of all values in a command map. */
+type ValueOf<TCommands extends CommandMap> = TCommands[keyof TCommands];
+/** Keep commands that have **every** of `TFilterTags`. */
+type FilterAllTags<TCommand extends AnyCommandDef, TFilterTags extends readonly string[]> = TCommand extends {
+  tags: infer CmdTags extends readonly string[];
+} ? TFilterTags[number] extends CmdTags[number] ? TCommand : never : TCommand;
+/** Keep commands that have **some** of `TFilterTags`. */
+type FilterAnyTags<TCommand extends AnyCommandDef, TFilterTags extends readonly string[]> = TCommand extends {
+  tags: infer CmdTags extends readonly string[];
+} ? string[] extends CmdTags ? TCommand : Extract<CmdTags[number], TFilterTags[number]> extends never ? never : TCommand : TCommand;
+/** Keep commands whose tag set equals `TFilterTags` (order-insensitive). */
+type FilterExactTags<TCommand extends AnyCommandDef, TFilterTags extends readonly string[]> = TCommand extends {
+  tags: infer CmdTags extends readonly string[];
+} ? string[] extends CmdTags ? TCommand : [CmdTags[number]] extends [TFilterTags[number]] ? [TFilterTags[number]] extends [CmdTags[number]] ? TCommand : never : never : TCommand;
+/** Keep commands that have **without** of `TFilterTags`. */
+type FilterWithoutTags<TCommand extends AnyCommandDef, TFilterTags extends readonly string[]> = TCommand extends {
+  tags: infer CmdTags extends readonly string[];
+} ? string[] extends CmdTags ? TCommand : Extract<CmdTags[number], TFilterTags[number]> extends never ? TCommand : never : TCommand;
 type CommandKey<TCommands extends CommandMap> = Extract<keyof TCommands, string>;
 type CommandFlags<TCommands extends CommandMap> = Partial<Record<CommandKey<TCommands>, boolean>>;
 type CommandInput<TCommands extends CommandMap> = readonly CommandKey<TCommands>[] | CommandFlags<TCommands>;
@@ -13,22 +30,38 @@ type TruthyKeys<T> = { [K in keyof T]-?: T[K] extends true ? K : never }[keyof T
 type PickedCommands<TCommands extends CommandMap, TInput extends CommandInput<TCommands>> = TInput extends readonly CommandKey<TCommands>[] ? Pick<TCommands, TInput[number]> : TInput extends CommandFlags<TCommands> ? Pick<TCommands, Extract<TruthyKeys<TInput>, keyof TCommands>> : never;
 type OmittedCommands<TCommands extends CommandMap, TInput extends CommandInput<TCommands>> = TInput extends readonly CommandKey<TCommands>[] ? Omit<TCommands, TInput[number]> : TInput extends CommandFlags<TCommands> ? Omit<TCommands, Extract<TruthyKeys<TInput>, keyof TCommands>> : never;
 type ExtendedCommands<TBase extends CommandMap, TExtension extends CommandMap> = Omit<TBase, keyof TExtension> & TExtension;
-/**
- * Command registry type with utility methods for picking, omitting, and converting to array.
- * This allows for flexible manipulation of command sets while maintaining type safety.
- */
+type CommandTagFilterRegistry<TCommand extends AnyCommandDef> = {
+  every<const TTags extends string[]>(...tags: TTags): CommandTagFilterRegistry<FilterAllTags<TCommand, TTags>>;
+  some<const TTags extends string[]>(...tags: TTags): CommandTagFilterRegistry<FilterAnyTags<TCommand, TTags>>;
+  exact<const TTags extends string[]>(...tags: TTags): CommandTagFilterRegistry<FilterExactTags<TCommand, TTags>>;
+  without<const TTags extends string[]>(...tags: TTags): CommandTagFilterRegistry<FilterWithoutTags<TCommand, TTags>>;
+  toArray(): TCommand[];
+};
+type CommandKeyFilterRegistry<TCommands extends CommandMap> = {
+  pick<const TInput extends CommandInput<TCommands>>(input: TInput): CommandKeyFilterRegistry<PickedCommands<TCommands, TInput>>;
+  omit<const TInput extends CommandInput<TCommands>>(input: TInput): CommandKeyFilterRegistry<OmittedCommands<TCommands, TInput>>;
+  toArray(): ValueOf<TCommands>[];
+};
 type CommandRegistry<TCommands extends CommandMap> = {
   commands: TCommands;
-  extend<const TExtension extends CommandMap>(extension: TExtension): CommandRegistry<ExtendedCommands<TCommands, TExtension>>;
-  pick<const TInput extends CommandInput<TCommands>>(input: TInput): CommandRegistry<PickedCommands<TCommands, TInput>>;
+  keys: CommandKeyFilterRegistry<TCommands>;
+  tags: CommandTagFilterRegistry<ValueOf<TCommands>>;
+  extend<const TExtension extends CommandMap>(extension: TExtension): CommandRegistry<ExtendedCommands<TCommands, TExtension>>; /** @deprecated Use `commands.keys.pick(...)` instead. */
+  pick<const TInput extends CommandInput<TCommands>>(input: TInput): CommandRegistry<PickedCommands<TCommands, TInput>>; /** @deprecated Use `commands.keys.omit(...)` instead. */
   omit<const TInput extends CommandInput<TCommands>>(input: TInput): CommandRegistry<OmittedCommands<TCommands, TInput>>;
-  toArray(): Array<CommandDef<z.ZodTypeAny, any>>;
+  toArray(): ValueOf<TCommands>[];
 };
 /**
- * Public function to define commands. It takes a command map and returns a command registry with utility methods.
- * This is the main entry point for users to create their command sets.
- * @param commands - A map of command definitions keyed by command name.
- * @returns A command registry with the defined commands and utility methods.
+ * Define commands from a map of name → `CommandDef`.
+ *
+ * Returns a `CommandRegistry` with key-based and tag-based filtering, plus
+ * `extend` for composition. Filter chains are immutable — each call produces
+ * a new registry.
+ *
+ * @example
+ * const registry = defineCommands({ edit, delete, archive });
+ * registry.tags.every("danger", "table").toArray();
+ * registry.keys.omit({ delete: true }).toArray();
  */
 declare function defineCommands<TCommands extends CommandMap>(commands: TCommands): CommandRegistry<TCommands>;
 //#endregion