@agentrules/core 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -1,185 +1,124 @@
 import { z } from "zod";
 
-//#region src/schemas/common.d.ts
-/**
-* Schema for a single tag.
-* - Max 35 characters
-* - Lowercase alphanumeric with hyphens
-* - Platform names blocked (redundant with platform field)
-*/
-
-/**
- * Schema for a single tag.
- * - Max 35 characters
- * - Lowercase alphanumeric with hyphens
- * - Platform names blocked (redundant with platform field)
- */
-declare const tagSchema: z.ZodString;
-/**
- * Schema for tags array.
- * - 1-10 tags required
- */
-declare const tagsSchema: z.ZodArray<z.ZodString>;
-/**
- * Schema for preset/rule name.
- * - Max 64 characters
- * - Lowercase alphanumeric with hyphens
- */
-declare const nameSchema: z.ZodString;
-/**
- * Schema for display title.
- * - Max 80 characters
- */
-declare const titleSchema: z.ZodString;
-/**
- * Schema for description.
- * - Max 500 characters
- */
-declare const descriptionSchema: z.ZodString;
+//#region src/resolve/schema.d.ts
 
-//#endregion
-//#region src/preset/schema.d.ts
-declare const platformIdSchema: z.ZodEnum<{
-  opencode: "opencode";
-  codex: "codex";
-  claude: "claude";
-  cursor: "cursor";
-}>;
-/**
- * Schema for required description (presets require a description).
- * Extends base descriptionSchema with min(1) constraint.
- */
-declare const requiredDescriptionSchema: z.ZodString;
-declare const COMMON_LICENSES: readonly ["MIT", "Apache-2.0", "GPL-3.0-only", "BSD-3-Clause", "ISC", "Unlicense"];
-type CommonLicense = (typeof COMMON_LICENSES)[number];
-declare const licenseSchema: z.ZodString;
-/**
- * Preset config schema.
- *
- * Uses a unified `platforms` array that accepts either:
- * - Platform ID strings: `["opencode", "claude"]`
- * - Objects with optional path: `[{ platform: "opencode", path: "rules" }]`
- * - Mixed: `["opencode", { platform: "claude", path: "my-claude" }]`
- */
-declare const presetConfigSchema: z.ZodObject<{
-  $schema: z.ZodOptional<z.ZodString>;
-  name: z.ZodString;
-  title: z.ZodString;
-  version: z.ZodOptional<z.ZodNumber>;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  license: z.ZodString;
-  ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  agentrulesDir: z.ZodOptional<z.ZodString>;
-  platforms: z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+declare const ruleVariantSchema: z.ZodUnion<readonly [z.ZodObject<{
+  platform: z.ZodEnum<{
     opencode: "opencode";
     codex: "codex";
     claude: "claude";
     cursor: "cursor";
-  }>, z.ZodObject<{
-    platform: z.ZodEnum<{
-      opencode: "opencode";
-      codex: "codex";
-      claude: "claude";
-      cursor: "cursor";
-    }>;
-    path: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-}, z.core.$strict>;
-declare const bundledFileSchema: z.ZodObject<{
-  path: z.ZodString;
-  size: z.ZodNumber;
-  checksum: z.ZodString;
-  content: z.ZodString;
-}, z.core.$strip>;
-/**
- * Schema for per-platform variant in publish input.
- */
-declare const publishVariantInputSchema: z.ZodObject<{
+  }>;
+  bundleUrl: z.ZodString;
+  fileCount: z.ZodNumber;
+  totalSize: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
   platform: z.ZodEnum<{
     opencode: "opencode";
     codex: "codex";
     claude: "claude";
     cursor: "cursor";
   }>;
-  files: z.ZodArray<z.ZodObject<{
-    path: z.ZodString;
-    size: z.ZodNumber;
-    checksum: z.ZodString;
-    content: z.ZodString;
-  }, z.core.$strip>>;
-  readmeContent: z.ZodOptional<z.ZodString>;
-  licenseContent: z.ZodOptional<z.ZodString>;
-  installMessage: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Schema for what clients send to publish a preset (multi-platform).
- *
- * One publish call creates ONE version with ALL platform variants.
- * Version is optional major version. Registry assigns full MAJOR.MINOR.
- *
- * Note: Clients send `name` (e.g., "my-preset"), and the registry defines the format of the slug.
- * For example, a namespaced slug could be returned as "username/my-preset"
- */
-declare const presetPublishInputSchema: z.ZodObject<{
-  name: z.ZodString;
-  title: z.ZodString;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  license: z.ZodString;
-  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  variants: z.ZodArray<z.ZodObject<{
+  content: z.ZodString;
+  fileCount: z.ZodNumber;
+  totalSize: z.ZodNumber;
+}, z.core.$strip>]>;
+declare const ruleVersionSchema: z.ZodObject<{
+  version: z.ZodString;
+  isLatest: z.ZodBoolean;
+  publishedAt: z.ZodOptional<z.ZodString>;
+  variants: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
     platform: z.ZodEnum<{
       opencode: "opencode";
       codex: "codex";
       claude: "claude";
       cursor: "cursor";
     }>;
-    files: z.ZodArray<z.ZodObject<{
-      path: z.ZodString;
-      size: z.ZodNumber;
-      checksum: z.ZodString;
-      content: z.ZodString;
-    }, z.core.$strip>>;
-    readmeContent: z.ZodOptional<z.ZodString>;
-    licenseContent: z.ZodOptional<z.ZodString>;
-    installMessage: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>>;
-  version: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-/**
- * Schema for what registries store and return.
- * Includes full namespaced slug and version assigned by registry.
- */
-declare const presetBundleSchema: z.ZodObject<{
-  title: z.ZodString;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  variants: z.ZodArray<z.ZodObject<{
+    bundleUrl: z.ZodString;
+    fileCount: z.ZodNumber;
+    totalSize: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
     platform: z.ZodEnum<{
       opencode: "opencode";
       codex: "codex";
       claude: "claude";
       cursor: "cursor";
     }>;
-    files: z.ZodArray<z.ZodObject<{
-      path: z.ZodString;
-      size: z.ZodNumber;
-      checksum: z.ZodString;
+    content: z.ZodString;
+    fileCount: z.ZodNumber;
+    totalSize: z.ZodNumber;
+  }, z.core.$strip>]>>;
+}, z.core.$strip>;
+declare const resolvedRuleSchema: z.ZodObject<{
+  slug: z.ZodString;
+  name: z.ZodString;
+  title: z.ZodString;
+  description: z.ZodString;
+  tags: z.ZodArray<z.ZodString>;
+  license: z.ZodString;
+  features: z.ZodArray<z.ZodString>;
+  versions: z.ZodArray<z.ZodObject<{
+    version: z.ZodString;
+    isLatest: z.ZodBoolean;
+    publishedAt: z.ZodOptional<z.ZodString>;
+    variants: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      platform: z.ZodEnum<{
+        opencode: "opencode";
+        codex: "codex";
+        claude: "claude";
+        cursor: "cursor";
+      }>;
+      bundleUrl: z.ZodString;
+      fileCount: z.ZodNumber;
+      totalSize: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      platform: z.ZodEnum<{
+        opencode: "opencode";
+        codex: "codex";
+        claude: "claude";
+        cursor: "cursor";
+      }>;
       content: z.ZodString;
-    }, z.core.$strip>>;
-    readmeContent: z.ZodOptional<z.ZodString>;
-    licenseContent: z.ZodOptional<z.ZodString>;
-    installMessage: z.ZodOptional<z.ZodString>;
+      fileCount: z.ZodNumber;
+      totalSize: z.ZodNumber;
+    }, z.core.$strip>]>>;
   }, z.core.$strip>>;
-  license: z.ZodString;
-  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  slug: z.ZodString;
-  version: z.ZodString;
 }, z.core.$strip>;
-
-//#endregion
+declare const resolveResponseSchema: z.ZodObject<{
+  slug: z.ZodString;
+  name: z.ZodString;
+  title: z.ZodString;
+  description: z.ZodString;
+  tags: z.ZodArray<z.ZodString>;
+  license: z.ZodString;
+  features: z.ZodArray<z.ZodString>;
+  versions: z.ZodArray<z.ZodObject<{
+    version: z.ZodString;
+    isLatest: z.ZodBoolean;
+    publishedAt: z.ZodOptional<z.ZodString>;
+    variants: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      platform: z.ZodEnum<{
+        opencode: "opencode";
+        codex: "codex";
+        claude: "claude";
+        cursor: "cursor";
+      }>;
+      bundleUrl: z.ZodString;
+      fileCount: z.ZodNumber;
+      totalSize: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      platform: z.ZodEnum<{
+        opencode: "opencode";
+        codex: "codex";
+        claude: "claude";
+        cursor: "cursor";
+      }>;
+      content: z.ZodString;
+      fileCount: z.ZodNumber;
+      totalSize: z.ZodNumber;
+    }, z.core.$strip>]>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>; //#endregion
 //#region src/platform/types.d.ts
 /**
  * Platform and rule type definitions.
@@ -187,39 +126,33 @@ declare const presetBundleSchema: z.ZodObject<{
 declare const PLATFORM_ID_TUPLE: readonly ["opencode", "codex", "claude", "cursor"];
 /** Union type of supported platform IDs */
 type PlatformId = (typeof PLATFORM_ID_TUPLE)[number];
-/** File format for a rule type */
-type RuleFileFormat = "markdown" | "typescript" | "mdc";
-/** Configuration for a single rule type */
-type RuleTypeConfig = {
+/** Configuration for a single type */
+type TypeConfig = {
   /** Human-readable description */
   description: string;
-  /** File format */
-  format: RuleFileFormat;
-  /** File extension (without dot) */
-  extension: string;
   /**
-   * Install path pattern relative to project root.
-   * Use {name} as placeholder for the rule slug/filename.
+   * Install path template for project install.
+   * Supports: {platformDir}, {name}
    * null if project install not supported.
    */
-  projectPath: string | null;
+  project: string | null;
   /**
-   * Install path pattern for global/user install.
-   * Use ~ for home directory.
+   * Install path template for global install.
+   * Supports: {platformDir}, {name}
    * null if global install not supported.
    */
-  globalPath: string | null;
+  global: string | null;
 };
 /** Platform configuration with all its rule types */
-type PlatformRuleConfig = {
+type PlatformConfig = {
   /** Human-readable platform name */
   label: string;
-  /** Platform's project directory (e.g., ".opencode") */
-  projectDir: string;
-  /** Platform's global config directory (null if not supported) */
-  globalDir: string | null;
-  /** Rule types supported by this platform */
-  types: Record<string, RuleTypeConfig>;
+  /** Platform's project directory (e.g., ".claude") */
+  platformDir: string;
+  /** Platform's global config directory (e.g., "~/.claude") */
+  globalDir: string;
+  /** Types supported by this platform */
+  types: Record<string, TypeConfig>;
 };
 /**
  * Discriminated union of valid platform + type combinations.
@@ -230,10 +163,10 @@ type PlatformRuleType = {
   type: "instruction" | "agent" | "command" | "tool";
 } | {
   platform: "claude";
-  type: "instruction" | "command" | "skill";
+  type: "instruction" | "command" | "skill" | "rule";
 } | {
   platform: "cursor";
-  type: "rule";
+  type: "instruction" | "command" | "rule";
 } | {
   platform: "codex";
   type: "instruction" | "command";
@@ -242,388 +175,394 @@ type PlatformRuleType = {
 type RuleTypeForPlatform<P extends PlatformId> = Extract<PlatformRuleType, {
   platform: P;
 }>["type"];
-/** Union of all valid rule types across all platforms */
+/**
+ * All valid rule types.
+ * When type is omitted, freeform file structure is used.
+ */
 type RuleType = PlatformRuleType["type"];
+/** Tuple of all rule types for schema validation */
+declare const RULE_TYPE_TUPLE: readonly ["instruction", "rule", "command", "skill", "agent", "tool"];
 
 //#endregion
 //#region src/platform/config.d.ts
 declare const PLATFORM_IDS: [PlatformId, ...PlatformId[]];
 /**
- * Platform configuration including supported rule types and install paths.
+ * Platform configuration including supported types and install paths.
  */
 declare const PLATFORMS: {
   readonly opencode: {
     readonly label: "OpenCode";
-    readonly projectDir: ".opencode";
+    readonly platformDir: ".opencode";
     readonly globalDir: "~/.config/opencode";
     readonly types: {
       readonly instruction: {
         readonly description: "Project instructions";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: "AGENTS.md";
-        readonly globalPath: "~/.config/opencode/AGENTS.md";
+        readonly project: "AGENTS.md";
+        readonly global: "{platformDir}/AGENTS.md";
       };
       readonly agent: {
         readonly description: "Specialized AI agent";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: ".opencode/agent/{name}.md";
-        readonly globalPath: "~/.config/opencode/agent/{name}.md";
+        readonly project: "{platformDir}/agent/{name}.md";
+        readonly global: "{platformDir}/agent/{name}.md";
       };
       readonly command: {
         readonly description: "Custom slash command";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: ".opencode/command/{name}.md";
-        readonly globalPath: "~/.config/opencode/command/{name}.md";
+        readonly project: "{platformDir}/command/{name}.md";
+        readonly global: "{platformDir}/command/{name}.md";
       };
       readonly tool: {
         readonly description: "Custom tool";
-        readonly format: "typescript";
-        readonly extension: "ts";
-        readonly projectPath: ".opencode/tool/{name}.ts";
-        readonly globalPath: "~/.config/opencode/tool/{name}.ts";
+        readonly project: "{platformDir}/tool/{name}.ts";
+        readonly global: "{platformDir}/tool/{name}.ts";
       };
     };
   };
   readonly claude: {
     readonly label: "Claude Code";
-    readonly projectDir: ".claude";
+    readonly platformDir: ".claude";
     readonly globalDir: "~/.claude";
     readonly types: {
       readonly instruction: {
         readonly description: "Project instructions";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: "CLAUDE.md";
-        readonly globalPath: "~/.claude/CLAUDE.md";
+        readonly project: "CLAUDE.md";
+        readonly global: "{platformDir}/CLAUDE.md";
+      };
+      readonly rule: {
+        readonly description: "Project rule";
+        readonly project: "{platformDir}/rules/{name}.md";
+        readonly global: "{platformDir}/rules/{name}.md";
       };
       readonly command: {
         readonly description: "Custom slash command";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: ".claude/commands/{name}.md";
-        readonly globalPath: "~/.claude/commands/{name}.md";
+        readonly project: "{platformDir}/commands/{name}.md";
+        readonly global: "{platformDir}/commands/{name}.md";
       };
       readonly skill: {
         readonly description: "Custom skill";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: ".claude/skills/{name}/SKILL.md";
-        readonly globalPath: "~/.claude/skills/{name}/SKILL.md";
+        readonly project: "{platformDir}/skills/{name}/SKILL.md";
+        readonly global: "{platformDir}/skills/{name}/SKILL.md";
       };
     };
   };
   readonly cursor: {
     readonly label: "Cursor";
-    readonly projectDir: ".cursor";
+    readonly platformDir: ".cursor";
     readonly globalDir: "~/.cursor";
     readonly types: {
       readonly instruction: {
         readonly description: "Project instructions";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: "AGENTS.md";
-        readonly globalPath: null;
+        readonly project: "AGENTS.md";
+        readonly global: null;
       };
       readonly rule: {
         readonly description: "Custom rule";
-        readonly format: "mdc";
-        readonly extension: "mdc";
-        readonly projectPath: ".cursor/rules/{name}.mdc";
-        readonly globalPath: null;
+        readonly project: "{platformDir}/rules/{name}.mdc";
+        readonly global: null;
       };
       readonly command: {
         readonly description: "Custom slash command";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: ".cursor/commands/{name}.md";
-        readonly globalPath: "~/.cursor/commands/{name}.md";
+        readonly project: "{platformDir}/commands/{name}.md";
+        readonly global: "{platformDir}/commands/{name}.md";
       };
     };
   };
   readonly codex: {
     readonly label: "Codex";
-    readonly projectDir: ".codex";
+    readonly platformDir: ".codex";
     readonly globalDir: "~/.codex";
     readonly types: {
       readonly instruction: {
         readonly description: "Project instructions";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: "AGENTS.md";
-        readonly globalPath: "~/.codex/AGENTS.md";
+        readonly project: "AGENTS.md";
+        readonly global: "{platformDir}/AGENTS.md";
       };
       readonly command: {
         readonly description: "Custom prompt";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: null;
-        readonly globalPath: "~/.codex/prompts/{name}.md";
+        readonly project: null;
+        readonly global: "{platformDir}/prompts/{name}.md";
       };
     };
   };
 };
-/** Valid rule types for each platform. Must be kept in sync with PLATFORMS. */
-declare const PLATFORM_RULE_TYPES: {
-  readonly opencode: readonly ["instruction", "command", "agent", "tool"];
-  readonly claude: readonly ["instruction", "command", "skill"];
-  readonly codex: readonly ["instruction", "command"];
-  readonly cursor: readonly ["instruction", "command", "rule"];
-};
-/** Get valid rule types for a specific platform */
-declare function getValidRuleTypes(platform: PlatformId): readonly string[];
+/** Get valid types for a specific platform */
+declare function getValidTypes(platform: PlatformId): string[];
 /** Check if a type is valid for a given platform */
-declare function isValidRuleType(platform: PlatformId, type: string): boolean;
+declare function isValidType(platform: PlatformId, type: string): boolean;
+type InstallScope = "project" | "global";
 /** Get the configuration for a specific platform + type combination */
-declare function getRuleTypeConfig(platform: PlatformId, type: string): RuleTypeConfig | undefined;
-/** Get the install path for a rule, replacing {name} placeholder */
-declare function getInstallPath(platform: PlatformId, type: string, name: string, location?: "project" | "global"): string | null;
+declare function getTypeConfig(platform: PlatformId, type: string): TypeConfig | undefined;
+type SupportsInstallPathInput = {
+  platform: PlatformId;
+  type: string;
+  scope?: InstallScope;
+};
+declare function supportsInstallPath({
+  platform,
+  type,
+  scope
+}: SupportsInstallPathInput): boolean;
+/** Get the install path for a type, resolving all placeholders */
+type GetInstallPathInput = {
+  platform: PlatformId;
+  type: string;
+  name?: string;
+  scope?: InstallScope;
+};
+declare function getInstallPath({
+  platform,
+  type,
+  name,
+  scope
+}: GetInstallPathInput): string | null;
 /** Get platform configuration */
-declare function getPlatformConfig(platform: PlatformId): PlatformRuleConfig;
+declare function getPlatformConfig(platform: PlatformId): PlatformConfig;
+/**
+ * Get the relative install path for a type (without the root directory prefix).
+ * Returns the path relative to the platform's root directory.
+ *
+ * Example: For codex instruction with scope="global", returns "AGENTS.md"
+ * (not "~/.codex/AGENTS.md")
+ */
+declare function getRelativeInstallPath({
+  platform,
+  type,
+  name,
+  scope
+}: GetInstallPathInput): string | null;
+/**
+ * Platform-specific type tuples for zod schema validation.
+ * Must be kept in sync with PLATFORMS types above.
+ */
+declare const PLATFORM_RULE_TYPES: {
+  readonly opencode: readonly ["instruction", "agent", "command", "tool"];
+  readonly claude: readonly ["instruction", "rule", "command", "skill"];
+  readonly cursor: readonly ["instruction", "rule", "command"];
+  readonly codex: readonly ["instruction", "command"];
+};
 
 //#endregion
 //#region src/platform/utils.d.ts
 declare function isSupportedPlatform(value: string): value is PlatformId;
 declare function normalizePlatformInput(value: string): PlatformId;
 /**
- * Check if a directory name matches a platform's projectDir.
- * Used to detect if a preset config is inside a platform directory (in-project mode).
+ * Check if a directory name matches a platform's platformDir.
+ * Used to detect if a rule config is inside a platform directory (in-project mode).
  */
 declare function isPlatformDir(dirName: string): boolean;
 /**
- * Get the platform ID from a directory name, if it matches a platform's projectDir.
+ * Get the platform ID from a directory name, if it matches a platform's platformDir.
  */
 declare function getPlatformFromDir(dirName: string): PlatformId | undefined;
-
-//#endregion
-//#region src/preset/types.d.ts
 /**
- * Platform entry in raw config - either a platform ID string or an object with optional path.
+ * Infer the platform from a file path by searching for platformDir segments.
  *
- * Examples:
- * - "opencode" (shorthand, uses default directory)
- * - { platform: "opencode", path: "rules" } (custom path)
+ * Example: "/repo/.claude/commands/foo.md" -> "claude"
  */
-type RawPlatformEntry = PlatformId | {
-  platform: PlatformId;
-  path?: string;
-};
+declare function inferPlatformFromPath(value: string): PlatformId | undefined;
 /**
- * Normalized platform entry - always the object form.
+ * Return all platforms whose instruction file matches this basename.
+ *
+ * Example: "CLAUDE.md" -> ["claude"], "AGENTS.md" -> ["opencode", "cursor", "codex"]
  */
-type PlatformConfig = {
-  platform: PlatformId;
-  path?: string;
-};
+declare function inferInstructionPlatformsFromFileName(fileName: string): PlatformId[];
 /**
- * Normalize a raw platform entry to the object form.
+ * Infer a rule type from a file path for a known platform.
+ * Uses PLATFORMS templates as source-of-truth.
  */
-declare function normalizePlatformEntry(entry: RawPlatformEntry): PlatformConfig;
-/**
- * Raw preset configuration - what users write in agentrules.json.
- *
- * Uses a unified `platforms` array that accepts either:
- * - Platform ID strings: `["opencode", "claude"]`
- * - Objects with optional path: `[{ platform: "opencode", path: "rules" }]`
- * - Mixed: `["opencode", { platform: "claude", path: "my-claude" }]`
- *
- * **Order matters**: The first platform in the array is used as the default
- * when viewing the preset on the registry without specifying a platform.
- */
-type RawPresetConfig = {
-  $schema?: string;
+declare function inferTypeFromPath(platform: PlatformId, filePath: string): string | undefined;
+
+//#endregion
+//#region src/resolve/types.d.ts
+/** Base fields for all variants */
+type BaseVariant = {
+  platform: PlatformId;
+};
+/** Rule variant with bundle URL (for larger rules) */
+type RuleVariantBundle = BaseVariant & {
+  bundleUrl: string;
+  fileCount: number;
+  totalSize: number;
+};
+/** Rule variant with inline content (for smaller rules) */
+type RuleVariantInline = BaseVariant & {
+  content: string;
+  fileCount: number;
+  totalSize: number;
+};
+/** Rule variant - registry decides bundleUrl vs inline content */
+type RuleVariant = RuleVariantBundle | RuleVariantInline;
+type RuleVersion = {
+  version: string;
+  isLatest: boolean;
+  publishedAt?: string;
+  variants: RuleVariant[];
+};
+type ResolvedRule = {
+  slug: string;
   name: string;
+  /** Rule type - optional, defaults to freeform file structure */
+  type?: RuleType;
   title: string;
-  version?: number;
   description: string;
-  tags?: string[];
-  features?: string[];
+  tags: string[];
   license: string;
-  /** Additional patterns to exclude from bundle (glob patterns) */
-  ignore?: string[];
-  /**
-   * Directory containing metadata files (README.md, LICENSE.md, INSTALL.txt).
-   * Defaults to ".agentrules". Use "." to read metadata from the project root.
-   */
-  agentrulesDir?: string;
-  /**
-   * Target platforms with optional custom paths.
-   * Order matters: the first platform is used as the default when viewing
-   * the preset on the registry.
-   */
-  platforms: RawPlatformEntry[];
+  features: string[];
+  versions: RuleVersion[];
 };
+/** Response from items endpoint */
+type ResolveResponse = ResolvedRule;
+
+//#endregion
+//#region src/resolve/utils.d.ts
 /**
- * Normalized preset configuration - used internally after loading.
- * Always has platforms as PlatformConfig[] (object form).
+ * Type guard for rule variant with bundleUrl
  */
-type PresetConfig = Omit<RawPresetConfig, "platforms"> & {
-  platforms: PlatformConfig[];
+declare function hasBundle(variant: RuleVariant): variant is RuleVariant & {
+  bundleUrl: string;
 };
-type BundledFile = {
-  path: string;
-  /** File size in bytes */
-  size: number;
-  checksum: string;
+/**
+ * Type guard for rule variant with inline content
+ */
+declare function hasInlineContent(variant: RuleVariant): variant is RuleVariant & {
   content: string;
 };
 /**
- * Per-platform variant input for publishing.
- * Contains files and optional metadata for a single platform.
+ * Get the latest version from a resolved rule
  */
-type PublishVariantInput = {
-  platform: PlatformId;
-  files: BundledFile[];
-  /** Optional per-platform README */
-  readmeContent?: string;
-  /** Optional per-platform LICENSE */
-  licenseContent?: string;
-  /** Optional per-platform install message */
-  installMessage?: string;
-};
+declare function getLatestVersion(item: ResolvedRule): RuleVersion | undefined;
 /**
- * What clients send to publish a preset (multi-platform).
- *
- * One publish call creates ONE version with ALL platform variants.
- * Version is optional major version. Registry assigns full MAJOR.MINOR.
- *
- * Note: Clients send `name` (e.g., "my-preset"), and the registry defines the format of the slug.
- * For example, a namespaced slug could be returned as "username/my-preset"
+ * Get a specific version from a resolved rule
  */
-type PresetPublishInput = {
-  name: string;
-  title: string;
-  description: string;
-  tags: string[];
-  license: string;
-  features?: string[];
-  /** Platform variants - each contains files for that platform */
-  variants: PublishVariantInput[];
-  /** Major version. Defaults to 1 if not specified. */
-  version?: number;
-};
+declare function getVersion(item: ResolvedRule, version: string): RuleVersion | undefined;
 /**
- * What registries store and return for a single platform bundle.
- * This is stored in R2 and fetched via bundleUrl.
- *
- * Note: This is per-platform, while PresetPublishInput is multi-platform.
+ * Get a specific platform variant from a rule version
  */
-type PresetBundle = {
-  name: string;
-  platform: PlatformId;
-  title: string;
-  description: string;
-  tags: string[];
-  license: string;
-  features?: string[];
-  files: BundledFile[];
-  readmeContent?: string;
-  licenseContent?: string;
-  installMessage?: string;
-  /** Full namespaced slug (e.g., "username/my-preset") */
-  slug: string;
-  /** Full version in MAJOR.MINOR format (e.g., "1.3", "2.1") */
-  version: string;
-};
-type PresetFileInput = {
-  path: string;
-  content: ArrayBuffer | ArrayBufferView | string;
-};
+declare function getVariant(version: RuleVersion, platform: PlatformId): RuleVariant | undefined;
 /**
- * Files for a single platform variant
+ * Get all available platforms for a rule version
  */
-type PlatformFiles = {
-  platform: PlatformId;
-  files: PresetFileInput[];
-  /** Optional per-platform install message */
-  installMessage?: string;
-  /** Optional per-platform README */
-  readmeContent?: string;
-  /** Optional per-platform LICENSE */
-  licenseContent?: string;
-};
+declare function getPlatforms(version: RuleVersion): PlatformId[];
 /**
- * Preset input - what the CLI builds after loading files.
- * Always uses platformFiles array (works for single or multi-platform).
+ * Check if a platform is available in any version of a rule
  */
-type PresetInput = {
-  name: string;
-  config: PresetConfig;
-  /** Files for each platform */
-  platformFiles: PlatformFiles[];
-  /** Shared install message (fallback for platforms without their own) */
-  installMessage?: string;
-  /** Shared README (fallback for platforms without their own) */
-  readmeContent?: string;
-  /** Shared LICENSE (fallback for platforms without their own) */
-  licenseContent?: string;
-};
+declare function hasPlatform(item: ResolvedRule, platform: PlatformId): boolean;
 
 //#endregion
-//#region src/resolve/schema.d.ts
-declare const presetVariantSchema: z.ZodUnion<readonly [z.ZodObject<{
-  platform: z.ZodEnum<{
-    opencode: "opencode";
-    codex: "codex";
-    claude: "claude";
-    cursor: "cursor";
-  }>;
-  bundleUrl: z.ZodString;
-  fileCount: z.ZodNumber;
-  totalSize: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-  platform: z.ZodEnum<{
+//#region src/rule/schema.d.ts
+declare const platformIdSchema: z.ZodEnum<{
+  opencode: "opencode";
+  codex: "codex";
+  claude: "claude";
+  cursor: "cursor";
+}>;
+declare const COMMON_LICENSES: readonly ["MIT", "Apache-2.0", "GPL-3.0-only", "BSD-3-Clause", "ISC", "Unlicense"];
+type CommonLicense = (typeof COMMON_LICENSES)[number];
+declare const licenseSchema: z.ZodString;
+/**
+ * Schema for rule type.
+ * Valid types: instruction, rule, command, skill, agent, tool, multi.
+ * Optional - defaults to "multi" (freeform file structure).
+ * Platform-specific validation happens at publish time.
+ */
+declare const ruleTypeSchema: z.ZodEnum<{
+  instruction: "instruction";
+  agent: "agent";
+  command: "command";
+  tool: "tool";
+  rule: "rule";
+  skill: "skill";
+}>;
+/**
+ * Rule config schema.
+ *
+ * Uses a unified `platforms` array that accepts either:
+ * - Platform ID strings: `["opencode", "claude"]`
+ * - Objects with optional path: `[{ platform: "opencode", path: "rules" }]`
+ * - Mixed: `["opencode", { platform: "claude", path: "my-claude" }]`
+ */
+declare const ruleConfigSchema: z.ZodObject<{
+  $schema: z.ZodOptional<z.ZodString>;
+  name: z.ZodString;
+  type: z.ZodOptional<z.ZodEnum<{
+    instruction: "instruction";
+    agent: "agent";
+    command: "command";
+    tool: "tool";
+    rule: "rule";
+    skill: "skill";
+  }>>;
+  title: z.ZodString;
+  version: z.ZodOptional<z.ZodNumber>;
+  description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+  tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  license: z.ZodString;
+  ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  platforms: z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
     opencode: "opencode";
     codex: "codex";
     claude: "claude";
     cursor: "cursor";
-  }>;
+  }>, z.ZodObject<{
+    platform: z.ZodEnum<{
+      opencode: "opencode";
+      codex: "codex";
+      claude: "claude";
+      cursor: "cursor";
+    }>;
+    path: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+}, z.core.$strict>;
+declare const bundledFileSchema: z.ZodObject<{
+  path: z.ZodString;
+  size: z.ZodNumber;
+  checksum: z.ZodString;
   content: z.ZodString;
-  fileCount: z.ZodNumber;
-  totalSize: z.ZodNumber;
-}, z.core.$strip>]>;
-declare const ruleVariantSchema: z.ZodObject<{
+}, z.core.$strip>;
+/**
+ * Schema for per-platform variant in publish input.
+ */
+declare const publishVariantInputSchema: z.ZodObject<{
   platform: z.ZodEnum<{
     opencode: "opencode";
     codex: "codex";
     claude: "claude";
     cursor: "cursor";
   }>;
-  type: z.ZodString;
-  content: z.ZodString;
-}, z.core.$strip>;
-declare const presetVersionSchema: z.ZodObject<{
-  version: z.ZodString;
-  isLatest: z.ZodBoolean;
-  publishedAt: z.ZodOptional<z.ZodString>;
-  variants: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-    platform: z.ZodEnum<{
-      opencode: "opencode";
-      codex: "codex";
-      claude: "claude";
-      cursor: "cursor";
-    }>;
-    bundleUrl: z.ZodString;
-    fileCount: z.ZodNumber;
-    totalSize: z.ZodNumber;
-  }, z.core.$strip>, z.ZodObject<{
-    platform: z.ZodEnum<{
-      opencode: "opencode";
-      codex: "codex";
-      claude: "claude";
-      cursor: "cursor";
-    }>;
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    size: z.ZodNumber;
+    checksum: z.ZodString;
     content: z.ZodString;
-    fileCount: z.ZodNumber;
-    totalSize: z.ZodNumber;
-  }, z.core.$strip>]>>;
+  }, z.core.$strip>>;
+  readmeContent: z.ZodOptional<z.ZodString>;
+  licenseContent: z.ZodOptional<z.ZodString>;
+  installMessage: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const ruleVersionSchema: z.ZodObject<{
-  version: z.ZodString;
-  isLatest: z.ZodBoolean;
-  publishedAt: z.ZodOptional<z.ZodString>;
+/**
+ * Schema for what clients send to publish a rule.
+ *
+ * One publish call creates ONE version with ALL platform variants.
+ * Version is optional major version. Registry assigns full MAJOR.MINOR.
+ *
+ * Note: Clients send `name` (e.g., "my-rule"), and the registry defines the format of the slug.
+ * For example, a namespaced slug could be returned as "username/my-rule"
+ */
+declare const rulePublishInputSchema: z.ZodObject<{
+  name: z.ZodString;
+  type: z.ZodOptional<z.ZodEnum<{
+    instruction: "instruction";
+    agent: "agent";
+    command: "command";
+    tool: "tool";
+    rule: "rule";
+    skill: "skill";
+  }>>;
+  title: z.ZodString;
+  description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+  tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  license: z.ZodString;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
   variants: z.ZodArray<z.ZodObject<{
     platform: z.ZodEnum<{
       opencode: "opencode";
@@ -631,250 +570,218 @@ declare const ruleVersionSchema: z.ZodObject<{
       claude: "claude";
       cursor: "cursor";
     }>;
-    type: z.ZodString;
-    content: z.ZodString;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const resolvedPresetSchema: z.ZodObject<{
-  kind: z.ZodLiteral<"preset">;
-  slug: z.ZodString;
-  name: z.ZodString;
-  title: z.ZodString;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  license: z.ZodString;
-  features: z.ZodArray<z.ZodString>;
-  versions: z.ZodArray<z.ZodObject<{
-    version: z.ZodString;
-    isLatest: z.ZodBoolean;
-    publishedAt: z.ZodOptional<z.ZodString>;
-    variants: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-      platform: z.ZodEnum<{
-        opencode: "opencode";
-        codex: "codex";
-        claude: "claude";
-        cursor: "cursor";
-      }>;
-      bundleUrl: z.ZodString;
-      fileCount: z.ZodNumber;
-      totalSize: z.ZodNumber;
-    }, z.core.$strip>, z.ZodObject<{
-      platform: z.ZodEnum<{
-        opencode: "opencode";
-        codex: "codex";
-        claude: "claude";
-        cursor: "cursor";
-      }>;
-      content: z.ZodString;
-      fileCount: z.ZodNumber;
-      totalSize: z.ZodNumber;
-    }, z.core.$strip>]>>;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const resolvedRuleSchema: z.ZodObject<{
-  kind: z.ZodLiteral<"rule">;
-  slug: z.ZodString;
-  name: z.ZodString;
-  title: z.ZodString;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  versions: z.ZodArray<z.ZodObject<{
-    version: z.ZodString;
-    isLatest: z.ZodBoolean;
-    publishedAt: z.ZodOptional<z.ZodString>;
-    variants: z.ZodArray<z.ZodObject<{
-      platform: z.ZodEnum<{
-        opencode: "opencode";
-        codex: "codex";
-        claude: "claude";
-        cursor: "cursor";
-      }>;
-      type: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      size: z.ZodNumber;
+      checksum: z.ZodString;
       content: z.ZodString;
     }, z.core.$strip>>;
+    readmeContent: z.ZodOptional<z.ZodString>;
+    licenseContent: z.ZodOptional<z.ZodString>;
+    installMessage: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>;
+  version: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-declare const resolveResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  kind: z.ZodLiteral<"preset">;
-  slug: z.ZodString;
-  name: z.ZodString;
-  title: z.ZodString;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  license: z.ZodString;
-  features: z.ZodArray<z.ZodString>;
-  versions: z.ZodArray<z.ZodObject<{
-    version: z.ZodString;
-    isLatest: z.ZodBoolean;
-    publishedAt: z.ZodOptional<z.ZodString>;
-    variants: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-      platform: z.ZodEnum<{
-        opencode: "opencode";
-        codex: "codex";
-        claude: "claude";
-        cursor: "cursor";
-      }>;
-      bundleUrl: z.ZodString;
-      fileCount: z.ZodNumber;
-      totalSize: z.ZodNumber;
-    }, z.core.$strip>, z.ZodObject<{
-      platform: z.ZodEnum<{
-        opencode: "opencode";
-        codex: "codex";
-        claude: "claude";
-        cursor: "cursor";
-      }>;
-      content: z.ZodString;
-      fileCount: z.ZodNumber;
-      totalSize: z.ZodNumber;
-    }, z.core.$strip>]>>;
-  }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-  kind: z.ZodLiteral<"rule">;
-  slug: z.ZodString;
+/**
+ * Schema for what registries store and return for a single platform bundle.
+ * This is per-platform (flat structure), stored in R2 and fetched via bundleUrl.
+ */
+declare const ruleBundleSchema: z.ZodObject<{
   name: z.ZodString;
-  title: z.ZodString;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  versions: z.ZodArray<z.ZodObject<{
-    version: z.ZodString;
-    isLatest: z.ZodBoolean;
-    publishedAt: z.ZodOptional<z.ZodString>;
-    variants: z.ZodArray<z.ZodObject<{
-      platform: z.ZodEnum<{
-        opencode: "opencode";
-        codex: "codex";
-        claude: "claude";
-        cursor: "cursor";
-      }>;
-      type: z.ZodString;
-      content: z.ZodString;
-    }, z.core.$strip>>;
+  type: z.ZodOptional<z.ZodEnum<{
+    instruction: "instruction";
+    agent: "agent";
+    command: "command";
+    tool: "tool";
+    rule: "rule";
+    skill: "skill";
+  }>>;
+  platform: z.ZodEnum<{
+    opencode: "opencode";
+    codex: "codex";
+    claude: "claude";
+    cursor: "cursor";
+  }>;
+  title: z.ZodString;
+  description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+  tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  license: z.ZodString;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    size: z.ZodNumber;
+    checksum: z.ZodString;
+    content: z.ZodString;
   }, z.core.$strip>>;
-}, z.core.$strip>], "kind">;
+  readmeContent: z.ZodOptional<z.ZodString>;
+  licenseContent: z.ZodOptional<z.ZodString>;
+  installMessage: z.ZodOptional<z.ZodString>;
+  slug: z.ZodString;
+  version: z.ZodString;
+}, z.core.$strip>;
 
 //#endregion
-//#region src/resolve/types.d.ts
-/** Base fields for all variants */
-type BaseVariant = {
+//#region src/rule/types.d.ts
+/** Normalized platform entry - always object form */
+type PlatformEntry = {
   platform: PlatformId;
+  path?: string;
 };
-/** Preset variant with bundle URL (for larger presets) */
-type PresetVariantBundle = BaseVariant & {
-  bundleUrl: string;
-  fileCount: number;
-  totalSize: number;
+/** Raw platform entry - string shorthand or object with optional path */
+type RawPlatformEntry = PlatformId | PlatformEntry;
+/** Normalize a raw platform entry to the object form */
+declare function normalizePlatformEntry(entry: RawPlatformEntry): PlatformEntry;
+/**
+ * Raw rule configuration - what users write in agentrules.json.
+ *
+ * Uses a unified `platforms` array that accepts either:
+ * - Platform ID strings: `["opencode", "claude"]`
+ * - Objects with optional path: `[{ platform: "opencode", path: "rules" }]`
+ * - Mixed: `["opencode", { platform: "claude", path: "my-claude" }]`
+ *
+ * **Order matters**: The first platform in the array is used as the default
+ * when viewing the rule on the registry without specifying a platform.
+ */
+type RawRuleConfig = {
+  $schema?: string;
+  name: string;
+  /**
+   * Rule type - determines install path and constrains valid platforms.
+   * Optional - defaults to "multi" (freeform file structure).
+   */
+  type?: RuleType;
+  title: string;
+  version?: number;
+  description: string;
+  tags?: string[];
+  features?: string[];
+  license: string;
+  /** Additional patterns to exclude from bundle (glob patterns) */
+  ignore?: string[];
+  /**
+   * Target platforms with optional custom paths.
+   * Order matters: the first platform is used as the default when viewing
+   * the rule on the registry.
+   */
+  platforms: RawPlatformEntry[];
 };
-/** Preset variant with inline content (for smaller presets) */
-type PresetVariantInline = BaseVariant & {
-  content: string;
-  fileCount: number;
-  totalSize: number;
+/**
+ * Normalized rule configuration - used internally after loading.
+ */
+type RuleConfig = Omit<RawRuleConfig, "platforms"> & {
+  platforms: PlatformEntry[];
 };
-/** Preset variant - registry decides bundleUrl vs inline content */
-type PresetVariant = PresetVariantBundle | PresetVariantInline;
-/** Rule variant - always inline (rules are small text files) */
-type RuleVariant = BaseVariant & {
-  type: string;
+type BundledFile = {
+  path: string;
+  /** File size in bytes */
+  size: number;
+  checksum: string;
   content: string;
 };
-type PresetVersion = {
-  version: string;
-  isLatest: boolean;
-  publishedAt?: string;
-  variants: PresetVariant[];
-};
-type RuleVersion = {
-  version: string;
-  isLatest: boolean;
-  publishedAt?: string;
-  variants: RuleVariant[];
+/**
+ * Per-platform variant input for publishing.
+ * Contains files and optional metadata for a single platform.
+ */
+type PublishVariantInput = {
+  platform: PlatformId;
+  files: BundledFile[];
+  /** Optional per-platform README */
+  readmeContent?: string;
+  /** Optional per-platform LICENSE */
+  licenseContent?: string;
+  /** Optional per-platform install message */
+  installMessage?: string;
 };
-type ResolvedPreset = {
-  kind: "preset";
-  slug: string;
+/**
+ * What clients send to publish a rule (multi-platform).
+ *
+ * One publish call creates ONE version with ALL platform variants.
+ * Version is optional major version. Registry assigns full MAJOR.MINOR.
+ *
+ * Note: Clients send `name` (e.g., "my-rule"), and the registry defines the format of the slug.
+ * For example, a namespaced slug could be returned as "username/my-rule"
+ */
+type RulePublishInput = {
   name: string;
+  /** Rule type - optional, defaults to freeform file structure */
+  type?: RuleType;
   title: string;
   description: string;
   tags: string[];
   license: string;
-  features: string[];
-  versions: PresetVersion[];
+  features?: string[];
+  /** Platform variants - each contains files for that platform */
+  variants: PublishVariantInput[];
+  /** Major version. Defaults to 1 if not specified. */
+  version?: number;
 };
-type ResolvedRule = {
-  kind: "rule";
-  slug: string;
+/**
+ * What registries store and return for a single platform bundle.
+ * This is stored in R2 and fetched via bundleUrl.
+ *
+ * Note: This is per-platform, while RulePublishInput is multi-platform.
+ */
+type RuleBundle = {
   name: string;
+  /** Rule type - optional, defaults to freeform file structure */
+  type?: RuleType;
+  platform: PlatformId;
   title: string;
   description: string;
   tags: string[];
-  versions: RuleVersion[];
+  license: string;
+  features?: string[];
+  files: BundledFile[];
+  readmeContent?: string;
+  licenseContent?: string;
+  installMessage?: string;
+  /** Full namespaced slug (e.g., "username/my-rule") */
+  slug: string;
+  /** Full version in MAJOR.MINOR format (e.g., "1.3", "2.1") */
+  version: string;
 };
-/** Discriminated union for items endpoint response */
-type ResolveResponse = ResolvedPreset | ResolvedRule;
-
-//#endregion
-//#region src/resolve/utils.d.ts
-/**
- * Type guard for preset
- */
-declare function isPreset(item: ResolveResponse): item is ResolvedPreset;
-/**
- * Type guard for rule
- */
-declare function isRule(item: ResolveResponse): item is ResolvedRule;
-/**
- * Type guard for preset variant with bundleUrl
- */
-declare function hasBundle(variant: PresetVariant): variant is PresetVariant & {
-  bundleUrl: string;
+type RuleFileInput = {
+  path: string;
+  content: ArrayBuffer | ArrayBufferView | string;
 };
 /**
- * Type guard for preset variant with inline content
+ * Files for a single platform variant
  */
-declare function hasInlineContent(variant: PresetVariant): variant is PresetVariant & {
-  content: string;
+type PlatformFiles = {
+  platform: PlatformId;
+  files: RuleFileInput[];
+  /** Optional per-platform install message */
+  installMessage?: string;
+  /** Optional per-platform README */
+  readmeContent?: string;
+  /** Optional per-platform LICENSE */
+  licenseContent?: string;
 };
 /**
- * Get the latest version from a resolved preset
- */
-declare function getLatestPresetVersion(item: ResolvedPreset): PresetVersion | undefined;
-/**
- * Get the latest version from a resolved rule
- */
-declare function getLatestRuleVersion(item: ResolvedRule): RuleVersion | undefined;
-/**
- * Get a specific version from a resolved preset
- */
-declare function getPresetVersion(item: ResolvedPreset, version: string): PresetVersion | undefined;
-/**
- * Get a specific version from a resolved rule
- */
-declare function getRuleVersion(item: ResolvedRule, version: string): RuleVersion | undefined;
-/**
- * Get a specific platform variant from a preset version
- */
-declare function getPresetVariant(version: PresetVersion, platform: PlatformId): PresetVariant | undefined;
-/**
- * Get a specific platform variant from a rule version
- */
-declare function getRuleVariant(version: RuleVersion, platform: PlatformId): RuleVariant | undefined;
-/**
- * Get all available platforms for a preset version
- */
-declare function getPresetPlatforms(version: PresetVersion): PlatformId[];
-/**
- * Get all available platforms for a rule version
- */
-declare function getRulePlatforms(version: RuleVersion): PlatformId[];
-/**
- * Check if a platform is available in any version of a preset
- */
-declare function presetHasPlatform(item: ResolvedPreset, platform: PlatformId): boolean;
-/**
- * Check if a platform is available in any version of a rule
+ * Rule input - what the CLI builds after loading files.
+ * Always uses platformFiles array (works for single or multi-platform).
  */
-declare function ruleHasPlatform(item: ResolvedRule, platform: PlatformId): boolean;
+type RuleInput = {
+  name: string;
+  config: RuleConfig;
+  /** Files for each platform */
+  platformFiles: PlatformFiles[];
+  /** Shared install message (fallback for platforms without their own) */
+  installMessage?: string;
+  /** Shared README (fallback for platforms without their own) */
+  readmeContent?: string;
+  /** Shared LICENSE (fallback for platforms without their own) */
+  licenseContent?: string;
+};
+
+//#endregion
+//#region src/rule/validate.d.ts
+type RuleValidationResult = {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+};
+declare function validateRule(config: RuleConfig): RuleValidationResult;
 
 //#endregion
 //#region src/builder/registry.d.ts
@@ -884,26 +791,26 @@ declare function ruleHasPlatform(item: ResolvedRule, platform: PlatformId): bool
  */
 declare const STATIC_BUNDLE_DIR = "registry";
 /**
- * Options for building a PresetPublishInput.
+ * Options for building a publish input.
  */
-type BuildPresetPublishInputOptions = {
-  /** Preset input (single or multi-platform) */
-  preset: PresetInput;
+type BuildPublishInputOptions = {
+  /** Rule input (single or multi-platform) */
+  rule: RuleInput;
   /** Major version. Defaults to 1 if not specified. */
   version?: number;
 };
 /**
- * Builds a PresetPublishInput from preset input.
+ * Builds a RulePublishInput from rule input.
  *
- * PresetInput always has platformFiles array (unified format).
+ * RuleInput always has platformFiles array (unified format).
  */
-declare function buildPresetPublishInput(options: BuildPresetPublishInputOptions): Promise<PresetPublishInput>;
+declare function buildPublishInput(options: BuildPublishInputOptions): Promise<RulePublishInput>;
 /**
  * Options for building a static registry.
  */
-type BuildPresetRegistryOptions = {
-  /** Presets to include (single or multi-platform) */
-  presets: PresetInput[];
+type BuildRegistryOptions = {
+  /** Rules to include (single or multi-platform) */
+  rules: RuleInput[];
   /**
    * Optional base path or URL prefix for bundle locations.
    * Format: {bundleBase}/{STATIC_BUNDLE_DIR}/{slug}/{platform}/{version}
@@ -911,29 +818,29 @@ type BuildPresetRegistryOptions = {
    */
   bundleBase?: string;
 };
-type BuildPresetRegistryResult = {
-  /** Resolved presets in the unified format (one per slug with all versions/variants) */
-  items: ResolvedPreset[];
+type BuildRegistryResult = {
+  /** Resolved rules in the unified format (one per slug with all versions/variants) */
+  rules: ResolvedRule[];
   /** Bundles for each platform variant (used to write individual bundle files) */
-  bundles: PresetBundle[];
+  bundles: RuleBundle[];
 };
 /**
  * Builds a static registry with items and bundles.
  *
  * Uses the same model as dynamic publishing:
- * - Each PresetInput (single or multi-platform) becomes one item
+ * - Each RuleInput (single or multi-platform) becomes one item
  * - Each platform variant becomes one bundle
  */
-declare function buildPresetRegistry(options: BuildPresetRegistryOptions): Promise<BuildPresetRegistryResult>;
+declare function buildRegistry(options: BuildRegistryOptions): Promise<BuildRegistryResult>;
 
 //#endregion
 //#region src/builder/utils.d.ts
 declare function cleanInstallMessage(value: unknown): string | undefined;
 /**
- * Validate raw preset config from JSON.
+ * Validate raw rule config from JSON.
  * Returns the raw config shape (before normalization).
  */
-declare function validatePresetConfig(config: unknown, slug: string): RawPresetConfig;
+declare function validateConfig(config: unknown, slug: string): RawRuleConfig;
 
 //#endregion
 //#region src/client/bundle.d.ts
@@ -947,12 +854,12 @@ declare function toUtf8String(payload: ArrayBuffer | ArrayBufferView): string;
 /**
  * Fetches a bundle from an absolute URL.
  */
-declare function fetchBundle(bundleUrl: string): Promise<PresetBundle>;
+declare function fetchBundle(bundleUrl: string): Promise<RuleBundle>;
 /**
  * Resolves a slug to get all versions and platform variants.
  *
  * @param baseUrl - Registry base URL
- * @param slug - Content slug (may contain slashes, e.g., "username/my-preset")
+ * @param slug - Content slug (may contain slashes, e.g., "username/my-rule")
  * @param version - Optional version filter (server may ignore for static registries)
  * @returns Resolved data, or null if not found
  * @throws Error on network/server errors
@@ -962,29 +869,29 @@ declare function resolveSlug(baseUrl: string, slug: string, version?: string): P
 //#endregion
 //#region src/constants.d.ts
 /**
- * Shared constants for agentrules presets and registry.
+ * Shared constants for agentrules.
  */
-/** Filename for preset configuration */
-declare const PRESET_CONFIG_FILENAME = "agentrules.json";
-/** Directory name for preset metadata (README, LICENSE, etc.) */
-declare const AGENT_RULES_DIR = ".agentrules";
-/** JSON Schema URL for preset configuration */
-declare const PRESET_SCHEMA_URL = "https://agentrules.directory/schema/agentrules.json";
-/** Default version identifier for latest preset version */
+/** Filename for rule configuration */
+declare const RULE_CONFIG_FILENAME = "agentrules.json";
+/** JSON Schema URL for rule configuration */
+declare const RULE_SCHEMA_URL = "https://agentrules.directory/schema/agentrules.json";
+/** Default version identifier for latest rule version */
 declare const LATEST_VERSION = "latest";
 /**
  * API endpoint paths (relative to registry base URL).
  *
  * Note on slug handling:
- * - Slugs may contain slashes (e.g., "username/my-preset") which flow through as path segments
+ * - Slugs may contain slashes (e.g., "username/my-rule") which flow through as path segments
  * - The client is responsible for validating values before making requests
  */
 declare const API_ENDPOINTS: {
-  /** Preset endpoints (for publishing) */
-  readonly presets: {
-    /** Base path for preset operations */
-    readonly base: "api/presets";
-    /** Unpublish preset version (unpublishes all platform variants for that version) */
+  /** Rule endpoints (for publishing) */
+  readonly rules: {
+    /** Base path for rule operations (POST to publish) */
+    readonly base: "api/rules";
+    /** Get rule by slug (GET) */
+    readonly get: (slug: string) => string;
+    /** Unpublish rule version (DELETE) */
     readonly unpublish: (slug: string, version: string) => string;
   };
   /** Auth endpoints */
@@ -996,121 +903,41 @@ declare const API_ENDPOINTS: {
     /** Device token exchange */
     readonly deviceToken: "api/auth/device/token";
   };
-  /** Rule endpoints (for publishing) */
-  readonly rules: {
-    /** Base path for rule operations (POST to create) */
-    readonly base: "api/rules";
-    /** Rule by slug (PUT to update, DELETE to remove) */
-    readonly bySlug: (slug: string) => string;
-  };
-  /** Items endpoint - unified content retrieval */
-  readonly items: {
-    /**
-     * Get all versions and variants for a slug.
-     * Version filtering via query param is optional (server may ignore for static registries).
-     * @param slug - Content slug (may contain slashes, e.g., "username/my-preset")
-     */
-    readonly get: (slug: string) => string;
-  };
 };
 
 //#endregion
-//#region src/rule/schema.d.ts
+//#region src/schemas/common.d.ts
 /**
- * Rule-specific schema aliases.
- * All use shared schemas for consistency with presets:
- * - name: max 64 chars, lowercase kebab-case
- * - title: max 80 chars
- * - description: max 500 chars (optional for rules)
- * - tags: max 35 chars each, 1-10 required, platform names blocked
+ * Schema for a single tag.
+ * - Max 35 characters
+ * - Lowercase alphanumeric with hyphens
+ * - Platform names blocked (redundant with platform field)
  */
-declare const ruleNameSchema: z.ZodString;
-declare const ruleTitleSchema: z.ZodString;
-declare const ruleDescriptionSchema: z.ZodString;
-declare const ruleTagSchema: z.ZodString;
-declare const ruleTagsSchema: z.ZodArray<z.ZodString>;
-declare const rulePlatformSchema: z.ZodEnum<{
-  opencode: "opencode";
-  codex: "codex";
-  claude: "claude";
-  cursor: "cursor";
-}>;
-declare const ruleTypeSchema: z.ZodString;
-declare const ruleContentSchema: z.ZodString;
+declare const tagSchema: z.ZodString;
 /**
- * Discriminated union schema for platform + type combinations.
- * Each platform has its own set of valid types.
+ * Schema for tags array.
+ * - 0-10 tags allowed
  */
-declare const rulePlatformTypeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  platform: z.ZodLiteral<"opencode">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    agent: "agent";
-    command: "command";
-    tool: "tool";
-  }>;
-}, z.core.$strip>, z.ZodObject<{
-  platform: z.ZodLiteral<"claude">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    command: "command";
-    skill: "skill";
-  }>;
-}, z.core.$strip>, z.ZodObject<{
-  platform: z.ZodLiteral<"cursor">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    command: "command";
-    rule: "rule";
-  }>;
-}, z.core.$strip>, z.ZodObject<{
-  platform: z.ZodLiteral<"codex">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    command: "command";
-  }>;
-}, z.core.$strip>], "platform">;
-/** Schema for rule creation with discriminated union for platform+type */
-declare const ruleCreateInputSchema: z.ZodIntersection<z.ZodObject<{
-  name: z.ZodString;
-  title: z.ZodString;
-  description: z.ZodOptional<z.ZodString>;
-  content: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-  platform: z.ZodLiteral<"opencode">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    agent: "agent";
-    command: "command";
-    tool: "tool";
-  }>;
-}, z.core.$strip>, z.ZodObject<{
-  platform: z.ZodLiteral<"claude">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    command: "command";
-    skill: "skill";
-  }>;
-}, z.core.$strip>, z.ZodObject<{
-  platform: z.ZodLiteral<"cursor">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    command: "command";
-    rule: "rule";
-  }>;
-}, z.core.$strip>, z.ZodObject<{
-  platform: z.ZodLiteral<"codex">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    command: "command";
-  }>;
-}, z.core.$strip>], "platform">>;
-type RuleCreateInput = z.infer<typeof ruleCreateInputSchema>;
+declare const tagsSchema: z.ZodArray<z.ZodString>;
+/**
+ * Schema for rule name.
+ * - Max 64 characters
+ * - Lowercase alphanumeric with hyphens
+ */
+declare const nameSchema: z.ZodString;
+/**
+ * Schema for display title.
+ * - Max 80 characters
+ */
+declare const titleSchema: z.ZodString;
+/**
+ * Schema for description.
+ * - Max 500 characters
+ */
+declare const descriptionSchema: z.ZodString;
 
 //#endregion
 //#region src/utils/diff.d.ts
-/** Re-export platform-rule types for convenience */
 type DiffPreviewOptions = {
   context?: number;
   maxLines?: number;
@@ -1133,4 +960,4 @@ declare function toUint8Array(payload: ArrayBuffer | ArrayBufferView): Uint8Arra
 declare function normalizeBundlePath(value: string): string;
 
 //#endregion
-export { AGENT_RULES_DIR, API_ENDPOINTS, BuildPresetPublishInputOptions, BuildPresetRegistryOptions, BuildPresetRegistryResult, BundledFile, COMMON_LICENSES, CommonLicense, DiffPreviewOptions, LATEST_VERSION, PLATFORMS, PLATFORM_IDS, PLATFORM_ID_TUPLE, PLATFORM_RULE_TYPES, PRESET_CONFIG_FILENAME, PRESET_SCHEMA_URL, PlatformConfig, PlatformFiles, PlatformId, PlatformRuleConfig, PlatformRuleType, PresetBundle, PresetConfig, PresetFileInput, PresetInput, PresetPublishInput, PresetVariant, PresetVersion, PublishVariantInput, RawPlatformEntry, RawPresetConfig, ResolveResponse, ResolvedPreset, ResolvedRule, RuleCreateInput, RuleFileFormat, RuleType, RuleTypeConfig, RuleTypeForPlatform, RuleVariant, RuleVersion, STATIC_BUNDLE_DIR, buildPresetPublishInput, buildPresetRegistry, bundledFileSchema, cleanInstallMessage, createDiffPreview, decodeBundledFile, decodeUtf8, descriptionSchema, encodeUtf8, fetchBundle, getInstallPath, getLatestPresetVersion, getLatestRuleVersion, getPlatformConfig, getPlatformFromDir, getPresetPlatforms, getPresetVariant, getPresetVersion, getRulePlatforms, getRuleTypeConfig, getRuleVariant, getRuleVersion, getValidRuleTypes, hasBundle, hasInlineContent, isLikelyText, isPlatformDir, isPreset, isRule, isSupportedPlatform, isValidRuleType, licenseSchema, nameSchema, normalizeBundlePath, normalizePlatformEntry, normalizePlatformInput, platformIdSchema, presetBundleSchema, presetConfigSchema, presetHasPlatform, presetPublishInputSchema, presetVariantSchema, presetVersionSchema, publishVariantInputSchema, requiredDescriptionSchema, resolveResponseSchema, resolveSlug, resolvedPresetSchema, resolvedRuleSchema, ruleContentSchema, ruleCreateInputSchema, ruleDescriptionSchema, ruleHasPlatform, ruleNameSchema, rulePlatformSchema, rulePlatformTypeSchema, ruleTagSchema, ruleTagsSchema, ruleTitleSchema, ruleTypeSchema, ruleVariantSchema, ruleVersionSchema, tagSchema, tagsSchema, titleSchema, toPosixPath, toUint8Array, toUtf8String, validatePresetConfig, verifyBundledFileChecksum };
+export { API_ENDPOINTS, BuildPublishInputOptions, BuildRegistryOptions, BuildRegistryResult, BundledFile, COMMON_LICENSES, CommonLicense, DiffPreviewOptions, GetInstallPathInput, InstallScope, LATEST_VERSION, PLATFORMS, PLATFORM_IDS, PLATFORM_ID_TUPLE, PLATFORM_RULE_TYPES, PlatformConfig, PlatformEntry, PlatformFiles, PlatformId, PlatformRuleType, PublishVariantInput, RULE_CONFIG_FILENAME, RULE_SCHEMA_URL, RULE_TYPE_TUPLE, RawPlatformEntry, RawRuleConfig, ResolveResponse, ResolvedRule, RuleBundle, RuleConfig, RuleFileInput, RuleInput, RulePublishInput, RuleType, RuleTypeForPlatform, RuleValidationResult, RuleVariant, RuleVersion, STATIC_BUNDLE_DIR, SupportsInstallPathInput, TypeConfig, buildPublishInput, buildRegistry, bundledFileSchema, cleanInstallMessage, createDiffPreview, decodeBundledFile, decodeUtf8, descriptionSchema, encodeUtf8, fetchBundle, getInstallPath, getLatestVersion, getPlatformConfig, getPlatformFromDir, getPlatforms, getRelativeInstallPath, getTypeConfig, getValidTypes, getVariant, getVersion, hasBundle, hasInlineContent, hasPlatform, inferInstructionPlatformsFromFileName, inferPlatformFromPath, inferTypeFromPath, isLikelyText, isPlatformDir, isSupportedPlatform, isValidType, licenseSchema, nameSchema, normalizeBundlePath, normalizePlatformEntry, normalizePlatformInput, platformIdSchema, publishVariantInputSchema, resolveResponseSchema, resolveSlug, resolvedRuleSchema, ruleBundleSchema, ruleConfigSchema, rulePublishInputSchema, ruleTypeSchema, ruleVariantSchema, ruleVersionSchema, supportsInstallPath, tagSchema, tagsSchema, titleSchema, toPosixPath, toUint8Array, toUtf8String, validateConfig, validateRule, verifyBundledFileChecksum };