@agentrules/core 0.0.10 → 0.1.0

package/dist/index.d.ts

@@ -1,5 +1,43 @@
 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;
+
+//#endregion
 //#region src/preset/schema.d.ts
 declare const platformIdSchema: z.ZodEnum<{
   opencode: "opencode";
@@ -7,14 +45,22 @@ declare const platformIdSchema: z.ZodEnum<{
   claude: "claude";
   cursor: "cursor";
 }>;
-declare const titleSchema: z.ZodString;
-declare const descriptionSchema: z.ZodString;
-declare const tagSchema: z.ZodString;
-declare const tagsSchema: z.ZodArray<z.ZodString>;
-declare const slugSchema: z.ZodString;
+/**
+ * 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;
@@ -24,142 +70,318 @@ declare const presetConfigSchema: z.ZodObject<{
   tags: z.ZodArray<z.ZodString>;
   features: z.ZodOptional<z.ZodArray<z.ZodString>>;
   license: z.ZodString;
-  platform: z.ZodEnum<{
+  ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  agentrulesDir: z.ZodOptional<z.ZodString>;
+  platforms: z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
     opencode: "opencode";
     codex: "codex";
     claude: "claude";
     cursor: "cursor";
-  }>;
-  path: z.ZodOptional<z.ZodString>;
-  ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }>, 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;
-  contents: z.ZodString;
+  content: z.ZodString;
 }, z.core.$strip>;
 /**
- * Schema for what clients send to publish a preset.
- * Version is optional major version. Registry assigns full MAJOR.MINOR.
+ * Schema for per-platform variant in publish input.
  */
-declare const presetPublishInputSchema: z.ZodObject<{
-  slug: z.ZodString;
+declare const publishVariantInputSchema: z.ZodObject<{
   platform: z.ZodEnum<{
     opencode: "opencode";
     codex: "codex";
     claude: "claude";
     cursor: "cursor";
   }>;
-  title: z.ZodString;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  license: z.ZodString;
-  licenseContent: z.ZodOptional<z.ZodString>;
-  readmeContent: z.ZodOptional<z.ZodString>;
-  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  installMessage: z.ZodOptional<z.ZodString>;
   files: z.ZodArray<z.ZodObject<{
     path: z.ZodString;
     size: z.ZodNumber;
     checksum: z.ZodString;
-    contents: z.ZodString;
+    content: z.ZodString;
   }, z.core.$strip>>;
-  version: z.ZodOptional<z.ZodNumber>;
+  readmeContent: z.ZodOptional<z.ZodString>;
+  licenseContent: z.ZodOptional<z.ZodString>;
+  installMessage: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
- * Schema for what registries store and return.
- * Includes version (required) - full MAJOR.MINOR format assigned by registry.
+ * 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 presetBundleSchema: z.ZodObject<{
+declare const presetPublishInputSchema: z.ZodObject<{
+  name: z.ZodString;
   title: z.ZodString;
   description: z.ZodString;
   tags: z.ZodArray<z.ZodString>;
   license: z.ZodString;
-  platform: z.ZodEnum<{
-    opencode: "opencode";
-    codex: "codex";
-    claude: "claude";
-    cursor: "cursor";
-  }>;
   features: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  slug: z.ZodString;
-  licenseContent: z.ZodOptional<z.ZodString>;
-  readmeContent: z.ZodOptional<z.ZodString>;
-  installMessage: z.ZodOptional<z.ZodString>;
-  files: z.ZodArray<z.ZodObject<{
-    path: z.ZodString;
-    size: z.ZodNumber;
-    checksum: z.ZodString;
-    contents: z.ZodString;
+  variants: z.ZodArray<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.ZodString;
+  version: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-declare const presetSchema: z.ZodObject<{
+/**
+ * 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<{
+    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>>;
   license: z.ZodString;
-  platform: z.ZodEnum<{
-    opencode: "opencode";
-    codex: "codex";
-    claude: "claude";
-    cursor: "cursor";
-  }>;
-  version: z.ZodString;
   features: z.ZodOptional<z.ZodArray<z.ZodString>>;
   slug: z.ZodString;
-  name: z.ZodString;
-  bundleUrl: z.ZodString;
-  fileCount: z.ZodNumber;
-  totalSize: z.ZodNumber;
-}, z.core.$strip>;
-declare const presetIndexSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-  title: z.ZodString;
-  description: z.ZodString;
-  tags: z.ZodArray<z.ZodString>;
-  license: z.ZodString;
-  platform: z.ZodEnum<{
-    opencode: "opencode";
-    codex: "codex";
-    claude: "claude";
-    cursor: "cursor";
-  }>;
   version: z.ZodString;
-  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  slug: z.ZodString;
-  name: z.ZodString;
-  bundleUrl: z.ZodString;
-  fileCount: z.ZodNumber;
-  totalSize: z.ZodNumber;
-}, z.core.$strip>>;
+}, z.core.$strip>;
 
 //#endregion
 //#region src/platform/types.d.ts
 /**
- * Single source of truth for platform IDs.
- * Add new platforms here - types and config will follow.
+ * Platform and rule type definitions.
  */
 declare const PLATFORM_ID_TUPLE: readonly ["opencode", "codex", "claude", "cursor"];
-/** Union type of supported platform IDs, derived from PLATFORM_ID_TUPLE */
+/** Union type of supported platform IDs */
 type PlatformId = (typeof PLATFORM_ID_TUPLE)[number];
-/** Configuration for a platform's directory paths */
-type PlatformConfig = {
-  /** Directory name for project installs (e.g., ".opencode") */
+/** File format for a rule type */
+type RuleFileFormat = "markdown" | "typescript" | "mdc";
+/** Configuration for a single rule type */
+type RuleTypeConfig = {
+  /** 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.
+   * null if project install not supported.
+   */
+  projectPath: string | null;
+  /**
+   * Install path pattern for global/user install.
+   * Use ~ for home directory.
+   * null if global install not supported.
+   */
+  globalPath: string | null;
+};
+/** Platform configuration with all its rule types */
+type PlatformRuleConfig = {
+  /** Human-readable platform name */
+  label: string;
+  /** Platform's project directory (e.g., ".opencode") */
   projectDir: string;
-  /** Path for global installs (e.g., "~/.config/opencode") */
-  globalDir: string;
+  /** Platform's global config directory (null if not supported) */
+  globalDir: string | null;
+  /** Rule types supported by this platform */
+  types: Record<string, RuleTypeConfig>;
 };
+/**
+ * Discriminated union of valid platform + type combinations.
+ * Must be kept in sync with PLATFORMS in config.ts.
+ */
+type PlatformRuleType = {
+  platform: "opencode";
+  type: "instruction" | "agent" | "command" | "tool";
+} | {
+  platform: "claude";
+  type: "instruction" | "command" | "skill";
+} | {
+  platform: "cursor";
+  type: "rule";
+} | {
+  platform: "codex";
+  type: "instruction" | "command";
+};
+/** Extract rule type for a specific platform */
+type RuleTypeForPlatform<P extends PlatformId> = Extract<PlatformRuleType, {
+  platform: P;
+}>["type"];
+/** Union of all valid rule types across all platforms */
+type RuleType = PlatformRuleType["type"];
 
 //#endregion
 //#region src/platform/config.d.ts
-/** List of supported platform IDs as a readonly tuple */
-declare const PLATFORM_IDS: readonly ["opencode", "codex", "claude", "cursor"];
+declare const PLATFORM_IDS: [PlatformId, ...PlatformId[]];
 /**
- * Platform-specific configuration.
- * Single source of truth for all platform paths.
+ * Platform configuration including supported rule types and install paths.
  */
-declare const PLATFORMS: Record<PlatformId, PlatformConfig>;
+declare const PLATFORMS: {
+  readonly opencode: {
+    readonly label: "OpenCode";
+    readonly projectDir: ".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 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 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 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 claude: {
+    readonly label: "Claude Code";
+    readonly projectDir: ".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 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 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 cursor: {
+    readonly label: "Cursor";
+    readonly projectDir: ".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 rule: {
+        readonly description: "Custom rule";
+        readonly format: "mdc";
+        readonly extension: "mdc";
+        readonly projectPath: ".cursor/rules/{name}.mdc";
+        readonly globalPath: 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 codex: {
+    readonly label: "Codex";
+    readonly projectDir: ".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 command: {
+        readonly description: "Custom prompt";
+        readonly format: "markdown";
+        readonly extension: "md";
+        readonly projectPath: null;
+        readonly globalPath: "~/.codex/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[];
+/** Check if a type is valid for a given platform */
+declare function isValidRuleType(platform: PlatformId, type: string): boolean;
+/** 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;
+/** Get platform configuration */
+declare function getPlatformConfig(platform: PlatformId): PlatformRuleConfig;
 
 //#endregion
 //#region src/platform/utils.d.ts
@@ -177,7 +399,40 @@ declare function getPlatformFromDir(dirName: string): PlatformId | undefined;
 
 //#endregion
 //#region src/preset/types.d.ts
-type PresetConfig = {
+/**
+ * Platform entry in raw config - either a platform ID string or an object with optional path.
+ *
+ * Examples:
+ * - "opencode" (shorthand, uses default directory)
+ * - { platform: "opencode", path: "rules" } (custom path)
+ */
+type RawPlatformEntry = PlatformId | {
+  platform: PlatformId;
+  path?: string;
+};
+/**
+ * Normalized platform entry - always the object form.
+ */
+type PlatformConfig = {
+  platform: PlatformId;
+  path?: string;
+};
+/**
+ * Normalize a raw platform entry to the object form.
+ */
+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;
   name: string;
   title: string;
@@ -186,124 +441,499 @@ type PresetConfig = {
   tags?: string[];
   features?: string[];
   license: string;
-  platform: PlatformId;
-  /** Path to config files. Defaults to platform's projectDir (e.g., ".claude") */
-  path?: 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[];
+};
+/**
+ * Normalized preset configuration - used internally after loading.
+ * Always has platforms as PlatformConfig[] (object form).
+ */
+type PresetConfig = Omit<RawPresetConfig, "platforms"> & {
+  platforms: PlatformConfig[];
 };
 type BundledFile = {
   path: string;
   /** File size in bytes */
   size: number;
   checksum: string;
-  contents: string;
+  content: string;
+};
+/**
+ * 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;
 };
 /**
- * What clients send to publish a preset.
+ * 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"
  */
 type PresetPublishInput = {
-  slug: string;
-  platform: PlatformId;
+  name: string;
   title: string;
   description: string;
   tags: string[];
   license: string;
-  licenseContent?: string;
-  readmeContent?: string;
   features?: string[];
-  installMessage?: string;
-  files: BundledFile[];
+  /** Platform variants - each contains files for that platform */
+  variants: PublishVariantInput[];
   /** Major version. Defaults to 1 if not specified. */
   version?: number;
 };
 /**
- * What registries store and return.
- * Includes version (required) - full MAJOR.MINOR format assigned by registry.
+ * 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.
  */
-type PresetBundle = Omit<PresetPublishInput, "version"> & {
-  /** Full version in MAJOR.MINOR format (e.g., "1.3", "2.1") */
-  version: string;
-};
-type Preset = {
+type PresetBundle = {
   name: string;
-  slug: string;
   platform: PlatformId;
   title: string;
-  version: string;
   description: string;
   tags: string[];
   license: string;
   features?: string[];
-  bundleUrl: string;
-  fileCount: number;
-  totalSize: number;
+  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 PresetIndex = Record<string, Preset>;
 type PresetFileInput = {
   path: string;
-  contents: ArrayBuffer | ArrayBufferView | string;
+  content: ArrayBuffer | ArrayBufferView | string;
+};
+/**
+ * Files for a single platform variant
+ */
+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;
 };
+/**
+ * Preset input - what the CLI builds after loading files.
+ * Always uses platformFiles array (works for single or multi-platform).
+ */
 type PresetInput = {
-  slug: string;
+  name: string;
   config: PresetConfig;
-  files: PresetFileInput[];
-  /** Install message from INSTALL.txt file */
+  /** 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/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<{
+    opencode: "opencode";
+    codex: "codex";
+    claude: "claude";
+    cursor: "cursor";
+  }>;
+  content: z.ZodString;
+  fileCount: z.ZodNumber;
+  totalSize: z.ZodNumber;
+}, z.core.$strip>]>;
+declare const ruleVariantSchema: 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";
+    }>;
+    content: z.ZodString;
+    fileCount: z.ZodNumber;
+    totalSize: z.ZodNumber;
+  }, z.core.$strip>]>>;
+}, z.core.$strip>;
+declare const ruleVersionSchema: 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>>;
+}, 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;
+      content: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, 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;
+  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>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+
+//#endregion
+//#region src/resolve/types.d.ts
+/** Base fields for all variants */
+type BaseVariant = {
+  platform: PlatformId;
+};
+/** Preset variant with bundle URL (for larger presets) */
+type PresetVariantBundle = BaseVariant & {
+  bundleUrl: string;
+  fileCount: number;
+  totalSize: number;
+};
+/** Preset variant with inline content (for smaller presets) */
+type PresetVariantInline = BaseVariant & {
+  content: string;
+  fileCount: number;
+  totalSize: number;
+};
+/** 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;
+  content: string;
+};
+type PresetVersion = {
+  version: string;
+  isLatest: boolean;
+  publishedAt?: string;
+  variants: PresetVariant[];
+};
+type RuleVersion = {
+  version: string;
+  isLatest: boolean;
+  publishedAt?: string;
+  variants: RuleVariant[];
+};
+type ResolvedPreset = {
+  kind: "preset";
+  slug: string;
+  name: string;
+  title: string;
+  description: string;
+  tags: string[];
+  license: string;
+  features: string[];
+  versions: PresetVersion[];
+};
+type ResolvedRule = {
+  kind: "rule";
+  slug: string;
+  name: string;
+  title: string;
+  description: string;
+  tags: string[];
+  versions: RuleVersion[];
+};
+/** 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 guard for preset variant with inline content
+ */
+declare function hasInlineContent(variant: PresetVariant): variant is PresetVariant & {
+  content: 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
+ */
+declare function ruleHasPlatform(item: ResolvedRule, platform: PlatformId): boolean;
+
 //#endregion
 //#region src/builder/registry.d.ts
 /**
  * Directory name for bundle files in static registry output.
  * Used by `agentrules registry build` to structure output.
  */
-declare const STATIC_BUNDLE_DIR = "r";
+declare const STATIC_BUNDLE_DIR = "registry";
 /**
- * Options for building a PresetPublishInput (for CLI publish command).
+ * Options for building a PresetPublishInput.
  */
 type BuildPresetPublishInputOptions = {
+  /** Preset input (single or multi-platform) */
   preset: PresetInput;
   /** Major version. Defaults to 1 if not specified. */
   version?: number;
 };
 /**
  * Builds a PresetPublishInput from preset input.
- * Used by CLI to prepare data for publishing to a registry.
+ *
+ * PresetInput always has platformFiles array (unified format).
  */
 declare function buildPresetPublishInput(options: BuildPresetPublishInputOptions): Promise<PresetPublishInput>;
 /**
  * Options for building a static registry.
  */
 type BuildPresetRegistryOptions = {
+  /** Presets to include (single or multi-platform) */
   presets: PresetInput[];
   /**
    * Optional base path or URL prefix for bundle locations.
-   * Format: {bundleBase}/{STATIC_BUNDLE_DIR}/{slug}/{platform}
+   * Format: {bundleBase}/{STATIC_BUNDLE_DIR}/{slug}/{platform}/{version}
    * Default: no prefix (bundleUrl starts with STATIC_BUNDLE_DIR)
    */
   bundleBase?: string;
 };
 type BuildPresetRegistryResult = {
-  entries: Preset[];
-  index: PresetIndex;
+  /** Resolved presets in the unified format (one per slug with all versions/variants) */
+  items: ResolvedPreset[];
+  /** Bundles for each platform variant (used to write individual bundle files) */
   bundles: PresetBundle[];
 };
 /**
- * Builds a static registry with entries, index, and bundles.
- * Used for building static registry files (e.g., community-presets).
- * Each preset uses its version from config (default: major 1, minor 0).
+ * 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 platform variant becomes one bundle
  */
 declare function buildPresetRegistry(options: BuildPresetRegistryOptions): Promise<BuildPresetRegistryResult>;
 
 //#endregion
 //#region src/builder/utils.d.ts
 declare function cleanInstallMessage(value: unknown): string | undefined;
-declare function encodeItemName(slug: string, platform: PlatformId): string;
-declare function validatePresetConfig(config: unknown, slug: string): PresetConfig;
+/**
+ * Validate raw preset config from JSON.
+ * Returns the raw config shape (before normalization).
+ */
+declare function validatePresetConfig(config: unknown, slug: string): RawPresetConfig;
 
 //#endregion
 //#region src/client/bundle.d.ts
@@ -315,26 +945,19 @@ declare function toUtf8String(payload: ArrayBuffer | ArrayBufferView): string;
 //#endregion
 //#region src/client/registry.d.ts
 /**
- * Resolved preset with absolute bundle URL
+ * Fetches a bundle from an absolute URL.
  */
-type ResolvedPreset = {
-  preset: Preset;
-  bundleUrl: string;
-};
+declare function fetchBundle(bundleUrl: string): Promise<PresetBundle>;
 /**
- * Resolves a preset from the registry via API endpoint.
- * Returns the entry metadata and the absolute bundle URL.
+ * Resolves a slug to get all versions and platform variants.
  *
  * @param baseUrl - Registry base URL
- * @param slug - Preset slug
- * @param platform - Target platform
- * @param version - Version to resolve (defaults to "latest")
- */
-declare function resolvePreset(baseUrl: string, slug: string, platform: PlatformId, version?: string): Promise<ResolvedPreset>;
-/**
- * Fetches a bundle from an absolute URL or resolves it relative to the registry.
+ * @param slug - Content slug (may contain slashes, e.g., "username/my-preset")
+ * @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
  */
-declare function fetchBundle(bundleUrl: string): Promise<PresetBundle>;
+declare function resolveSlug(baseUrl: string, slug: string, version?: string): Promise<ResolveResponse | null>;
 
 //#endregion
 //#region src/constants.d.ts
@@ -351,16 +974,18 @@ declare const PRESET_SCHEMA_URL = "https://agentrules.directory/schema/agentrule
 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
+ * - The client is responsible for validating values before making requests
  */
 declare const API_ENDPOINTS: {
-  /** Preset endpoints */
+  /** Preset endpoints (for publishing) */
   readonly presets: {
     /** Base path for preset operations */
     readonly base: "api/presets";
-    /** Get preset by slug, platform, and version (defaults to "latest") */
-    readonly get: (slug: string, platform: string, version?: string) => string;
-    /** Unpublish preset version */
-    readonly unpublish: (slug: string, platform: string, version: string) => string;
+    /** Unpublish preset version (unpublishes all platform variants for that version) */
+    readonly unpublish: (slug: string, version: string) => string;
   };
   /** Auth endpoints */
   readonly auth: {
@@ -371,10 +996,121 @@ 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
+/**
+ * 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
+ */
+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;
+/**
+ * Discriminated union schema for platform + type combinations.
+ * Each platform has its own set of valid types.
+ */
+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>;
+
 //#endregion
 //#region src/utils/diff.d.ts
+/** Re-export platform-rule types for convenience */
 type DiffPreviewOptions = {
   context?: number;
   maxLines?: number;
@@ -397,4 +1133,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, PRESET_CONFIG_FILENAME, PRESET_SCHEMA_URL, PlatformConfig, PlatformId, Preset, PresetBundle, PresetConfig, PresetFileInput, PresetIndex, PresetInput, PresetPublishInput, ResolvedPreset, STATIC_BUNDLE_DIR, buildPresetPublishInput, buildPresetRegistry, bundledFileSchema, cleanInstallMessage, createDiffPreview, decodeBundledFile, decodeUtf8, descriptionSchema, encodeItemName, encodeUtf8, fetchBundle, getPlatformFromDir, isLikelyText, isPlatformDir, isSupportedPlatform, licenseSchema, normalizeBundlePath, normalizePlatformInput, platformIdSchema, presetBundleSchema, presetConfigSchema, presetIndexSchema, presetPublishInputSchema, presetSchema, resolvePreset, slugSchema, tagSchema, tagsSchema, titleSchema, toPosixPath, toUint8Array, toUtf8String, validatePresetConfig, verifyBundledFileChecksum };
+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 };