@agentrules/core 0.0.11 → 0.2.0

package/dist/index.d.ts

@@ -1,143 +1,124 @@
 import { z } from "zod";
 
-//#region src/preset/schema.d.ts
-declare const platformIdSchema: z.ZodEnum<{
-  opencode: "opencode";
-  codex: "codex";
-  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;
-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;
-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;
+//#region src/resolve/schema.d.ts
+
+declare const ruleVariantSchema: z.ZodUnion<readonly [z.ZodObject<{
   platform: z.ZodEnum<{
     opencode: "opencode";
     codex: "codex";
     claude: "claude";
     cursor: "cursor";
   }>;
-  path: z.ZodOptional<z.ZodString>;
-  ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-declare const bundledFileSchema: z.ZodObject<{
-  path: z.ZodString;
-  size: z.ZodNumber;
-  checksum: z.ZodString;
-  contents: z.ZodString;
-}, z.core.$strip>;
-/**
- * Schema for what clients send to publish a preset.
- * 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;
+  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";
   }>;
-  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;
-  }, z.core.$strip>>;
-  version: z.ZodOptional<z.ZodNumber>;
+  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";
+    }>;
+    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>;
-/**
- * Schema for what registries store and return.
- * Includes full namespaced slug and version assigned by registry.
- */
-declare const presetBundleSchema: z.ZodObject<{
+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;
-  platform: z.ZodEnum<{
-    opencode: "opencode";
-    codex: "codex";
-    claude: "claude";
-    cursor: "cursor";
-  }>;
-  features: z.ZodOptional<z.ZodArray<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;
+  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>>;
-  slug: z.ZodString;
-  version: z.ZodString;
 }, z.core.$strip>;
-declare const presetSchema: 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>>;
+declare const resolveResponseSchema: z.ZodObject<{
   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>>;
-
-//#endregion
+  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.
@@ -145,39 +126,33 @@ declare const presetIndexSchema: z.ZodRecord<z.ZodString, 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.
@@ -188,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";
@@ -200,232 +175,601 @@ 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 (AGENTS.md)";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: "AGENTS.md";
-        readonly globalPath: "~/.config/opencode/AGENTS.md";
+        readonly description: "Project instructions";
+        readonly project: "AGENTS.md";
+        readonly global: "{platformDir}/AGENTS.md";
       };
       readonly agent: {
-        readonly description: "Specialized AI agent definition";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: ".opencode/agent/{name}.md";
-        readonly globalPath: "~/.config/opencode/agent/{name}.md";
+        readonly description: "Specialized AI agent";
+        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 definition";
-        readonly format: "typescript";
-        readonly extension: "ts";
-        readonly projectPath: ".opencode/tool/{name}.ts";
-        readonly globalPath: "~/.config/opencode/tool/{name}.ts";
+        readonly description: "Custom tool";
+        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 (CLAUDE.md)";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: "CLAUDE.md";
-        readonly globalPath: "~/.claude/CLAUDE.md";
+        readonly description: "Project instructions";
+        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 definition";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: ".claude/skills/{name}/SKILL.md";
-        readonly globalPath: "~/.claude/skills/{name}/SKILL.md";
+        readonly description: "Custom skill";
+        readonly project: "{platformDir}/skills/{name}/SKILL.md";
+        readonly global: "{platformDir}/skills/{name}/SKILL.md";
       };
     };
   };
   readonly cursor: {
     readonly label: "Cursor";
-    readonly projectDir: ".cursor";
-    readonly globalDir: null;
+    readonly platformDir: ".cursor";
+    readonly globalDir: "~/.cursor";
     readonly types: {
+      readonly instruction: {
+        readonly description: "Project instructions";
+        readonly project: "AGENTS.md";
+        readonly global: null;
+      };
       readonly rule: {
-        readonly description: "Project rule (MDC format)";
-        readonly format: "mdc";
-        readonly extension: "mdc";
-        readonly projectPath: ".cursor/rules/{name}.mdc";
-        readonly globalPath: null;
+        readonly description: "Custom rule";
+        readonly project: "{platformDir}/rules/{name}.mdc";
+        readonly global: null;
+      };
+      readonly command: {
+        readonly description: "Custom slash command";
+        readonly project: "{platformDir}/commands/{name}.md";
+        readonly global: "{platformDir}/commands/{name}.md";
       };
     };
   };
   readonly codex: {
     readonly label: "Codex";
-    readonly projectDir: "";
+    readonly platformDir: ".codex";
     readonly globalDir: "~/.codex";
     readonly types: {
       readonly instruction: {
-        readonly description: "Project instructions (AGENTS.md)";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: "AGENTS.md";
-        readonly globalPath: "~/.codex/AGENTS.md";
+        readonly description: "Project instructions";
+        readonly project: "AGENTS.md";
+        readonly global: "{platformDir}/AGENTS.md";
       };
       readonly command: {
-        readonly description: "Custom prompt (global only)";
-        readonly format: "markdown";
-        readonly extension: "md";
-        readonly projectPath: null;
-        readonly globalPath: "~/.codex/prompts/{name}.md";
+        readonly description: "Custom prompt";
+        readonly project: null;
+        readonly global: "{platformDir}/prompts/{name}.md";
       };
     };
   };
 };
-/** Valid rule types for each platform. Must be kept in sync with PLATFORMS. */
+/** 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 isValidType(platform: PlatformId, type: string): boolean;
+type InstallScope = "project" | "global";
+/** Get the configuration for a specific platform + type combination */
+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): PlatformConfig;
+/**
+ * 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", "command", "skill"];
-  readonly cursor: readonly ["rule"];
+  readonly claude: readonly ["instruction", "rule", "command", "skill"];
+  readonly cursor: readonly ["instruction", "rule", "command"];
   readonly codex: readonly ["instruction", "command"];
 };
-/** 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
 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;
+/**
+ * Infer the platform from a file path by searching for platformDir segments.
+ *
+ * Example: "/repo/.claude/commands/foo.md" -> "claude"
+ */
+declare function inferPlatformFromPath(value: string): PlatformId | undefined;
+/**
+ * Return all platforms whose instruction file matches this basename.
+ *
+ * Example: "CLAUDE.md" -> ["claude"], "AGENTS.md" -> ["opencode", "cursor", "codex"]
+ */
+declare function inferInstructionPlatformsFromFileName(fileName: string): PlatformId[];
+/**
+ * Infer a rule type from a file path for a known platform.
+ * Uses PLATFORMS templates as source-of-truth.
+ */
+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;
+  description: string;
+  tags: string[];
+  license: string;
+  features: string[];
+  versions: RuleVersion[];
+};
+/** Response from items endpoint */
+type ResolveResponse = ResolvedRule;
+
+//#endregion
+//#region src/resolve/utils.d.ts
+/**
+ * Type guard for rule variant with bundleUrl
+ */
+declare function hasBundle(variant: RuleVariant): variant is RuleVariant & {
+  bundleUrl: string;
+};
+/**
+ * Type guard for rule variant with inline content
+ */
+declare function hasInlineContent(variant: RuleVariant): variant is RuleVariant & {
+  content: string;
+};
+/**
+ * Get the latest version from a resolved rule
+ */
+declare function getLatestVersion(item: ResolvedRule): RuleVersion | undefined;
+/**
+ * Get a specific version from a resolved rule
+ */
+declare function getVersion(item: ResolvedRule, version: string): RuleVersion | undefined;
+/**
+ * Get a specific platform variant from a rule version
+ */
+declare function getVariant(version: RuleVersion, platform: PlatformId): RuleVariant | undefined;
+/**
+ * Get all available platforms for a rule version
+ */
+declare function getPlatforms(version: RuleVersion): PlatformId[];
+/**
+ * Check if a platform is available in any version of a rule
+ */
+declare function hasPlatform(item: ResolvedRule, platform: PlatformId): boolean;
 
 //#endregion
-//#region src/preset/types.d.ts
-type PresetConfig = {
+//#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";
+  rule: "rule";
+  command: "command";
+  skill: "skill";
+  agent: "agent";
+  tool: "tool";
+}>;
+/**
+ * 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";
+    rule: "rule";
+    command: "command";
+    skill: "skill";
+    agent: "agent";
+    tool: "tool";
+  }>>;
+  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;
+}, 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";
+  }>;
+  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 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";
+    rule: "rule";
+    command: "command";
+    skill: "skill";
+    agent: "agent";
+    tool: "tool";
+  }>>;
+  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";
+      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 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;
+  type: z.ZodOptional<z.ZodEnum<{
+    instruction: "instruction";
+    rule: "rule";
+    command: "command";
+    skill: "skill";
+    agent: "agent";
+    tool: "tool";
+  }>>;
+  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>>;
+  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/rule/types.d.ts
+/** Normalized platform entry - always object form */
+type PlatformEntry = {
+  platform: PlatformId;
+  path?: string;
+};
+/** 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;
-  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[];
+  /**
+   * 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[];
+};
+/**
+ * Normalized rule configuration - used internally after loading.
+ */
+type RuleConfig = Omit<RawRuleConfig, "platforms"> & {
+  platforms: PlatformEntry[];
 };
 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 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-preset"), and the registry defines the format of the slug.
- * For example, a namespaced slug could be returned as "username/my-preset"
+ * 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 PresetPublishInput = {
+type RulePublishInput = {
   name: string;
-  platform: PlatformId;
+  /** Rule type - optional, defaults to freeform file structure */
+  type?: RuleType;
   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 full namespaced slug and version 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 RulePublishInput is multi-platform.
  */
-type PresetBundle = Omit<PresetPublishInput, "name" | "version"> & {
-  /** 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 Preset = {
+type RuleBundle = {
   name: string;
-  slug: string;
+  /** Rule type - optional, defaults to freeform file structure */
+  type?: RuleType;
   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-rule") */
+  slug: string;
+  /** Full version in MAJOR.MINOR format (e.g., "1.3", "2.1") */
+  version: string;
 };
-type PresetIndex = Record<string, Preset>;
-type PresetFileInput = {
+type RuleFileInput = {
   path: string;
-  contents: ArrayBuffer | ArrayBufferView | string;
+  content: ArrayBuffer | ArrayBufferView | string;
 };
-type PresetInput = {
+/**
+ * Files for a single platform variant
+ */
+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;
+};
+/**
+ * Rule input - what the CLI builds after loading files.
+ * Always uses platformFiles array (works for single or multi-platform).
+ */
+type RuleInput = {
   name: string;
-  config: PresetConfig;
-  files: PresetFileInput[];
-  /** Install message from INSTALL.txt file */
+  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
 /**
@@ -434,47 +778,56 @@ type PresetInput = {
  */
 declare const STATIC_BUNDLE_DIR = "registry";
 /**
- * Options for building a PresetPublishInput (for CLI publish command).
+ * Options for building a publish input.
  */
-type BuildPresetPublishInputOptions = {
-  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.
- * Used by CLI to prepare data for publishing to a registry.
+ * Builds a RulePublishInput from rule input.
+ *
+ * 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: 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}
+   * 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;
-  bundles: PresetBundle[];
+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: RuleBundle[];
 };
 /**
- * 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 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;
-declare function encodeItemName(slug: string, platform: PlatformId): string;
-declare function validatePresetConfig(config: unknown, slug: string): PresetConfig;
+/**
+ * Validate raw rule config from JSON.
+ * Returns the raw config shape (before normalization).
+ */
+declare function validateConfig(config: unknown, slug: string): RawRuleConfig;
 
 //#endregion
 //#region src/client/bundle.d.ts
@@ -486,60 +839,47 @@ 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<RuleBundle>;
 /**
- * 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-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
  */
-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
 /**
- * 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: Path parameters (slug, platform, version) are NOT URI-encoded.
- * - Slugs may contain slashes (e.g., "username/my-preset") which should flow
- *   through as path segments for static registry compatibility
- * - Platform and version are constrained values (enums, validated formats)
- *   that only contain URL-safe characters
- *
- * The client is responsible for validating these values before making requests.
+ * Note on slug handling:
+ * - 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 */
-  readonly presets: {
-    /** Base path for preset operations */
-    readonly base: "api/preset";
-    /** 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;
+  /** 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 */
   readonly auth: {
@@ -550,112 +890,41 @@ declare const API_ENDPOINTS: {
     /** Device token exchange */
     readonly deviceToken: "api/auth/device/token";
   };
-  /** Rule endpoints */
-  readonly rule: {
-    /** Base path for rule operations */
-    readonly base: "api/rule";
-    /** Get or update rule by slug */
-    readonly get: (slug: string) => string;
-  };
 };
 
 //#endregion
-//#region src/rule/schema.d.ts
+//#region src/schemas/common.d.ts
 /**
- * Schema for the rule name.
- * This is what users provide when creating a rule.
+ * 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 rulePlatformSchema: z.ZodEnum<{
-  opencode: "opencode";
-  codex: "codex";
-  claude: "claude";
-  cursor: "cursor";
-}>;
-declare const ruleTypeSchema: z.ZodString;
-declare const ruleContentSchema: z.ZodString;
-declare const ruleTagSchema: z.ZodString;
-declare const ruleTagsSchema: z.ZodArray<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<{
-    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<{
-    rule: "rule";
-  }>;
-}, z.core.$strip>, z.ZodObject<{
-  platform: z.ZodLiteral<"codex">;
-  type: z.ZodEnum<{
-    instruction: "instruction";
-    command: "command";
-  }>;
-}, z.core.$strip>], "platform">>;
-declare const ruleUpdateInputSchema: z.ZodObject<{
-  name: z.ZodString;
-  title: z.ZodOptional<z.ZodString>;
-  description: z.ZodOptional<z.ZodString>;
-  content: z.ZodOptional<z.ZodString>;
-  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-type RuleCreateInput = z.infer<typeof ruleCreateInputSchema>;
-type RuleUpdateInput = z.infer<typeof ruleUpdateInputSchema>;
+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;
@@ -678,4 +947,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, PlatformId, PlatformRuleConfig, PlatformRuleType, Preset, PresetBundle, PresetConfig, PresetFileInput, PresetIndex, PresetInput, PresetPublishInput, ResolvedPreset, RuleCreateInput, RuleFileFormat, RuleType, RuleTypeConfig, RuleTypeForPlatform, RuleUpdateInput, STATIC_BUNDLE_DIR, buildPresetPublishInput, buildPresetRegistry, bundledFileSchema, cleanInstallMessage, createDiffPreview, decodeBundledFile, decodeUtf8, descriptionSchema, encodeItemName, encodeUtf8, fetchBundle, getInstallPath, getPlatformConfig, getPlatformFromDir, getRuleTypeConfig, getValidRuleTypes, isLikelyText, isPlatformDir, isSupportedPlatform, isValidRuleType, licenseSchema, normalizeBundlePath, normalizePlatformInput, platformIdSchema, presetBundleSchema, presetConfigSchema, presetIndexSchema, presetPublishInputSchema, presetSchema, resolvePreset, ruleContentSchema, ruleCreateInputSchema, ruleDescriptionSchema, ruleNameSchema, rulePlatformSchema, rulePlatformTypeSchema, ruleTagSchema, ruleTagsSchema, ruleTitleSchema, ruleTypeSchema, ruleUpdateInputSchema, slugSchema, 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, 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 };