@tulip-systems/core 0.9.0 → 0.10.1

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

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

@@ -1,39 +1,99 @@
 //#region src/modules/commands/lib/registery.ts
-function toKeys(input) {
+function resolveKeys(input) {
 	if (Array.isArray(input)) return [...input];
 	return Object.entries(input).filter(([, enabled]) => enabled === true).map(([key]) => key);
 }
-/**
-* Internal function to create a command registry from a given command map.
-*/
+function dedupe(tags) {
+	return [...new Set(tags)];
+}
+function hasEveryTag(command, tags) {
+	return tags.every((tag) => command.tags.includes(tag));
+}
+function hasSomeTag(command, tags) {
+	return tags.some((tag) => command.tags.includes(tag));
+}
+function hasExactTags(command, tags) {
+	const ctags = dedupe(command.tags);
+	const ftags = dedupe(tags);
+	return ctags.length === ftags.length && ftags.every((t) => ctags.includes(t));
+}
+function injectIds(commands) {
+	return Object.fromEntries(Object.entries(commands).map(([id, c]) => [id, {
+		...c,
+		id
+	}]));
+}
+function pickCommands(commands, input) {
+	const keys = resolveKeys(input);
+	return Object.fromEntries(keys.filter((k) => k in commands).map((k) => [k, commands[k]]));
+}
+function omitCommands(commands, input) {
+	const keys = new Set(resolveKeys(input));
+	return Object.fromEntries(Object.entries(commands).filter(([k]) => !keys.has(k)));
+}
+function createTagFilterRegistry(commands) {
+	function apply(predicate) {
+		return (...tags) => {
+			return createTagFilterRegistry(commands.filter((c) => predicate(c, tags)));
+		};
+	}
+	return {
+		every: apply(hasEveryTag),
+		some: apply(hasSomeTag),
+		exact: apply(hasExactTags),
+		without: apply((c, ts) => !hasSomeTag(c, ts)),
+		toArray() {
+			return commands;
+		}
+	};
+}
+function createKeyFilterRegistry(commands) {
+	return {
+		pick(input) {
+			return createKeyFilterRegistry(pickCommands(commands, input));
+		},
+		omit(input) {
+			return createKeyFilterRegistry(omitCommands(commands, input));
+		},
+		toArray() {
+			return Object.values(commands);
+		}
+	};
+}
 function createRegistry(commands) {
+	const withIds = injectIds(commands);
 	return {
-		commands,
+		commands: withIds,
+		keys: createKeyFilterRegistry(withIds),
+		tags: createTagFilterRegistry(Object.values(withIds)),
 		extend(extension) {
 			return createRegistry({
-				...commands,
+				...withIds,
 				...extension
 			});
 		},
 		pick(input) {
-			const keys = toKeys(input);
-			return createRegistry(Object.fromEntries(keys.flatMap((key) => key in commands ? [[key, commands[key]]] : [])));
+			return createRegistry(pickCommands(withIds, input));
 		},
 		omit(input) {
-			const keys = toKeys(input);
-			const blacklist = new Set(keys);
-			return createRegistry(Object.fromEntries(Object.entries(commands).filter(([key]) => !blacklist.has(key))));
+			return createRegistry(omitCommands(withIds, input));
 		},
 		toArray() {
-			return Object.values(commands);
+			return Object.values(withIds);
 		}
 	};
 }
 /**
-* 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();
 */
 function defineCommands(commands) {
 	return createRegistry(commands);

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

@@ -0,0 +1,11 @@
+//#region src/modules/commands/lib/utils.d.ts
+/**
+ * Normalizes command data into an array.
+ *
+ * Use this as a command transform when the same command should support both
+ * single-item and bulk contexts. After `.transform(ensureArray)`, command
+ * callbacks can safely use array helpers like `.map` and `.every`.
+ */
+declare function ensureArray<T>(data: T | T[]): T[];
+//#endregion
+export { ensureArray };

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

@@ -0,0 +1,14 @@
+//#region src/modules/commands/lib/utils.ts
+/**
+* Normalizes command data into an array.
+*
+* Use this as a command transform when the same command should support both
+* single-item and bulk contexts. After `.transform(ensureArray)`, command
+* callbacks can safely use array helpers like `.map` and `.every`.
+*/
+function ensureArray(data) {
+	return Array.isArray(data) ? data : [data];
+}
+
+//#endregion
+export { ensureArray };

package/dist/modules/data-tables/components/footer.mjs

@@ -1,6 +1,7 @@
 "use client";
 
 import { InfinteTableBottombar, InfinteTableFooter } from "../strategies/infinite/components.mjs";
+import { LocalTableFooter } from "../strategies/local/components.mjs";
 import { PaginationTableFooter } from "../strategies/pagination/components.mjs";
 import { jsx } from "react/jsx-runtime";
 
@@ -12,6 +13,7 @@ function TableFooter({ table }) {
 	const meta = table.options.meta;
 	if (meta.strategy.name === "pagination") return null;
 	if (meta.strategy.name === "infinite") return /* @__PURE__ */ jsx(InfinteTableFooter, { table });
+	if (meta.strategy.name === "local") return null;
 	throw new Error(`Unknown strategy: ${meta.strategy.name}`);
 }
 /**
@@ -21,6 +23,7 @@ function TableBottombar({ table }) {
 	const meta = table.options.meta;
 	if (meta.strategy.name === "pagination") return /* @__PURE__ */ jsx(PaginationTableFooter, { table });
 	if (meta.strategy.name === "infinite") return /* @__PURE__ */ jsx(InfinteTableBottombar, { table });
+	if (meta.strategy.name === "local") return /* @__PURE__ */ jsx(LocalTableFooter, { table });
 	throw new Error(`Unknown strategy: ${meta.strategy.name}`);
 }
 

package/dist/modules/data-tables/hooks/use-context.client.d.mts

@@ -1,4 +1,4 @@
-import { CommandDef } from "../../commands/lib/builder.mjs";
+import { CommandFor } from "../../commands/lib/builder.mjs";
 import { TableFiltersResult } from "../lib/filters/config.mjs";
 import { Selection, TableColumnDef, TableMetaInput, TableStrategy } from "../lib/types.mjs";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
@@ -21,7 +21,7 @@ type TableConfigContextValue<TData, TFilters extends TableFiltersResult = TableF
   strategy: TableStrategy;
   selection?: Selection;
   columnVisibility?: VisibilityState;
-  commands?: CommandDef[];
+  commands?: CommandFor<TData[], TMeta>[];
   meta?: TMeta;
   where?: TFilters;
 };

package/dist/modules/data-tables/lib/types.d.mts

@@ -1,5 +1,5 @@
 import { Permission } from "../../auth/lib/permissions.mjs";
-import { CommandDef } from "../../commands/lib/builder.mjs";
+import { CommandFor } from "../../commands/lib/builder.mjs";
 import { UseQueryStatesKeysMap } from "nuqs";
 import { ColumnDef, PaginationState, RowSelectionState, SortingState, TableMeta, Updater } from "@tanstack/react-table";
 
@@ -11,7 +11,7 @@ type TableMetaInput<TData> = TableMeta<TData>;
 type TableMeta$1<TData, TMeta = TableMetaInput<TData>> = {
   strategy: TableStrategy;
   selectedData: TData[];
-  commands?: CommandDef[];
+  commands?: CommandFor<TData[], TMeta>[];
 };
 /**
  * Table column definition
@@ -24,7 +24,7 @@ type TableColumnDef<TData> = ColumnDef<TData> & {
  * Data table strategy
  */
 type TableStrategy = {
-  name: "pagination" | "infinite";
+  name: "pagination" | "infinite" | "local";
   rowCount?: number;
   paginationState?: PaginationState;
   manualPagination?: boolean;

package/dist/modules/data-tables/strategies/local/components.mjs

@@ -0,0 +1,25 @@
+"use client";
+
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/modules/data-tables/strategies/local/components.tsx
+function LocalTableFooter({ table }) {
+	const selected = Object.keys(table.getState().rowSelection).length;
+	const total = table.getRowCount();
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex flex-col gap-y-2 px-2 md:flex-row md:items-center md:justify-between",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "text-muted-foreground text-sm",
+			children: [
+				selected ?? table.getFilteredSelectedRowModel().rows.length,
+				" of",
+				" ",
+				total ?? table.getRowModel().rows.length,
+				" row(s) selected."
+			]
+		})
+	});
+}
+
+//#endregion
+export { LocalTableFooter };