@agentrules/core 0.0.11 → 0.2.0

package/dist/index.js

@@ -1,49 +1,6 @@
 import { ZodError, z } from "zod";
 import { createTwoFilesPatch } from "diff";
 
-//#region src/constants.ts
-/**
-* Shared constants for agentrules presets and registry.
-*/
-/** Filename for preset configuration */
-const PRESET_CONFIG_FILENAME = "agentrules.json";
-/** Directory name for preset metadata (README, LICENSE, etc.) */
-const AGENT_RULES_DIR = ".agentrules";
-/** JSON Schema URL for preset configuration */
-const PRESET_SCHEMA_URL = "https://agentrules.directory/schema/agentrules.json";
-/** API root path segment */
-const API_PATH = "api";
-/** Default version identifier for latest preset version */
-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.
-*/
-const API_ENDPOINTS = {
-	presets: {
-		base: `${API_PATH}/preset`,
-		get: (slug, platform, version = LATEST_VERSION) => `${API_PATH}/preset/${slug}/${platform}/${version}`,
-		unpublish: (slug, platform, version) => `${API_PATH}/preset/${slug}/${platform}/${version}`
-	},
-	auth: {
-		session: `${API_PATH}/auth/get-session`,
-		deviceCode: `${API_PATH}/auth/device/code`,
-		deviceToken: `${API_PATH}/auth/device/token`
-	},
-	rule: {
-		base: `${API_PATH}/rule`,
-		get: (slug) => `${API_PATH}/rule/${slug}`
-	}
-};
-
-//#endregion
 //#region src/platform/types.ts
 /**
 * Platform and rule type definitions.
@@ -54,112 +11,154 @@ const PLATFORM_ID_TUPLE = [
 	"claude",
 	"cursor"
 ];
+/** Tuple of all rule types for schema validation */
+const RULE_TYPE_TUPLE = [
+	"instruction",
+	"rule",
+	"command",
+	"skill",
+	"agent",
+	"tool"
+];
 
 //#endregion
 //#region src/platform/config.ts
 const PLATFORM_IDS = PLATFORM_ID_TUPLE;
 /**
-* Platform configuration including supported rule types and install paths.
+* Platform configuration including supported types and install paths.
 */
 const PLATFORMS = {
 	opencode: {
 		label: "OpenCode",
-		projectDir: ".opencode",
+		platformDir: ".opencode",
 		globalDir: "~/.config/opencode",
 		types: {
 			instruction: {
-				description: "Project instructions (AGENTS.md)",
-				format: "markdown",
-				extension: "md",
-				projectPath: "AGENTS.md",
-				globalPath: "~/.config/opencode/AGENTS.md"
+				description: "Project instructions",
+				project: "AGENTS.md",
+				global: "{platformDir}/AGENTS.md"
 			},
 			agent: {
-				description: "Specialized AI agent definition",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".opencode/agent/{name}.md",
-				globalPath: "~/.config/opencode/agent/{name}.md"
+				description: "Specialized AI agent",
+				project: "{platformDir}/agent/{name}.md",
+				global: "{platformDir}/agent/{name}.md"
 			},
 			command: {
 				description: "Custom slash command",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".opencode/command/{name}.md",
-				globalPath: "~/.config/opencode/command/{name}.md"
+				project: "{platformDir}/command/{name}.md",
+				global: "{platformDir}/command/{name}.md"
 			},
 			tool: {
-				description: "Custom tool definition",
-				format: "typescript",
-				extension: "ts",
-				projectPath: ".opencode/tool/{name}.ts",
-				globalPath: "~/.config/opencode/tool/{name}.ts"
+				description: "Custom tool",
+				project: "{platformDir}/tool/{name}.ts",
+				global: "{platformDir}/tool/{name}.ts"
 			}
 		}
 	},
 	claude: {
 		label: "Claude Code",
-		projectDir: ".claude",
+		platformDir: ".claude",
 		globalDir: "~/.claude",
 		types: {
 			instruction: {
-				description: "Project instructions (CLAUDE.md)",
-				format: "markdown",
-				extension: "md",
-				projectPath: "CLAUDE.md",
-				globalPath: "~/.claude/CLAUDE.md"
+				description: "Project instructions",
+				project: "CLAUDE.md",
+				global: "{platformDir}/CLAUDE.md"
+			},
+			rule: {
+				description: "Project rule",
+				project: "{platformDir}/rules/{name}.md",
+				global: "{platformDir}/rules/{name}.md"
 			},
 			command: {
 				description: "Custom slash command",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".claude/commands/{name}.md",
-				globalPath: "~/.claude/commands/{name}.md"
+				project: "{platformDir}/commands/{name}.md",
+				global: "{platformDir}/commands/{name}.md"
 			},
 			skill: {
-				description: "Custom skill definition",
-				format: "markdown",
-				extension: "md",
-				projectPath: ".claude/skills/{name}/SKILL.md",
-				globalPath: "~/.claude/skills/{name}/SKILL.md"
+				description: "Custom skill",
+				project: "{platformDir}/skills/{name}/SKILL.md",
+				global: "{platformDir}/skills/{name}/SKILL.md"
 			}
 		}
 	},
 	cursor: {
 		label: "Cursor",
-		projectDir: ".cursor",
-		globalDir: null,
-		types: { rule: {
-			description: "Project rule (MDC format)",
-			format: "mdc",
-			extension: "mdc",
-			projectPath: ".cursor/rules/{name}.mdc",
-			globalPath: null
-		} }
+		platformDir: ".cursor",
+		globalDir: "~/.cursor",
+		types: {
+			instruction: {
+				description: "Project instructions",
+				project: "AGENTS.md",
+				global: null
+			},
+			rule: {
+				description: "Custom rule",
+				project: "{platformDir}/rules/{name}.mdc",
+				global: null
+			},
+			command: {
+				description: "Custom slash command",
+				project: "{platformDir}/commands/{name}.md",
+				global: "{platformDir}/commands/{name}.md"
+			}
+		}
 	},
 	codex: {
 		label: "Codex",
-		projectDir: "",
+		platformDir: ".codex",
 		globalDir: "~/.codex",
 		types: {
 			instruction: {
-				description: "Project instructions (AGENTS.md)",
-				format: "markdown",
-				extension: "md",
-				projectPath: "AGENTS.md",
-				globalPath: "~/.codex/AGENTS.md"
+				description: "Project instructions",
+				project: "AGENTS.md",
+				global: "{platformDir}/AGENTS.md"
 			},
 			command: {
-				description: "Custom prompt (global only)",
-				format: "markdown",
-				extension: "md",
-				projectPath: null,
-				globalPath: "~/.codex/prompts/{name}.md"
+				description: "Custom prompt",
+				project: null,
+				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 */
+function getValidTypes(platform) {
+	return Object.keys(PLATFORMS[platform].types);
+}
+/** Check if a type is valid for a given platform */
+function isValidType(platform, type) {
+	return type in PLATFORMS[platform].types;
+}
+/** Get the configuration for a specific platform + type combination */
+function getTypeConfig(platform, type) {
+	const platformConfig = PLATFORMS[platform];
+	return platformConfig.types[type];
+}
+function supportsInstallPath({ platform, type, scope = "project" }) {
+	const typeConfig = getTypeConfig(platform, type);
+	if (!typeConfig) return false;
+	const template = scope === "project" ? typeConfig.project : typeConfig.global;
+	return template !== null;
+}
+function getInstallPath({ platform, type, name, scope = "project" }) {
+	const platformConfig = PLATFORMS[platform];
+	const typeConfig = getTypeConfig(platform, type);
+	if (!typeConfig) return null;
+	const template = scope === "project" ? typeConfig.project : typeConfig.global;
+	if (!template) return null;
+	const rootDir = scope === "project" ? platformConfig.platformDir : platformConfig.globalDir;
+	if (template.includes("{name}") && !name) throw new Error(`Missing name for install path: platform="${platform}" type="${type}" scope="${scope}"`);
+	return template.replace("{platformDir}", rootDir).replace("{name}", name ?? "");
+}
+/** Get platform configuration */
+function getPlatformConfig(platform) {
+	return PLATFORMS[platform];
+}
+/**
+* Platform-specific type tuples for zod schema validation.
+* Must be kept in sync with PLATFORMS types above.
+*/
 const PLATFORM_RULE_TYPES = {
 	opencode: [
 		"instruction",
@@ -169,37 +168,17 @@ const PLATFORM_RULE_TYPES = {
 	],
 	claude: [
 		"instruction",
+		"rule",
 		"command",
 		"skill"
 	],
-	cursor: ["rule"],
+	cursor: [
+		"instruction",
+		"rule",
+		"command"
+	],
 	codex: ["instruction", "command"]
 };
-/** Get valid rule types for a specific platform */
-function getValidRuleTypes(platform) {
-	return PLATFORM_RULE_TYPES[platform];
-}
-/** Check if a type is valid for a given platform */
-function isValidRuleType(platform, type) {
-	return PLATFORM_RULE_TYPES[platform].includes(type);
-}
-/** Get the configuration for a specific platform + type combination */
-function getRuleTypeConfig(platform, type) {
-	const platformConfig = PLATFORMS[platform];
-	return platformConfig.types[type];
-}
-/** Get the install path for a rule, replacing {name} placeholder */
-function getInstallPath(platform, type, name, location = "project") {
-	const config = getRuleTypeConfig(platform, type);
-	if (!config) return null;
-	const pathTemplate = location === "project" ? config.projectPath : config.globalPath;
-	if (!pathTemplate) return null;
-	return pathTemplate.replace("{name}", name);
-}
-/** Get platform configuration */
-function getPlatformConfig(platform) {
-	return PLATFORMS[platform];
-}
 
 //#endregion
 //#region src/platform/utils.ts
@@ -212,19 +191,89 @@ function normalizePlatformInput(value) {
 	throw new Error(`Unknown platform "${value}". Supported platforms: ${PLATFORM_IDS.join(", ")}.`);
 }
 /**
-* 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).
 */
 function isPlatformDir(dirName) {
-	return PLATFORM_IDS.some((id) => PLATFORMS[id].projectDir === dirName);
+	return PLATFORM_IDS.some((id) => PLATFORMS[id].platformDir === dirName);
 }
 /**
-* 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.
 */
 function getPlatformFromDir(dirName) {
-	for (const id of PLATFORM_IDS) if (PLATFORMS[id].projectDir === dirName) return id;
+	for (const id of PLATFORM_IDS) if (PLATFORMS[id].platformDir === dirName) return id;
+	return;
+}
+function normalizePathForInference(value) {
+	return value.replace(/\\/g, "/");
+}
+function getBasename(value) {
+	const normalized = normalizePathForInference(value);
+	const segments = normalized.split("/").filter(Boolean);
+	return segments.at(-1) ?? "";
+}
+/**
+* Infer the platform from a file path by searching for platformDir segments.
+*
+* Example: "/repo/.claude/commands/foo.md" -> "claude"
+*/
+function inferPlatformFromPath(value) {
+	const normalized = normalizePathForInference(value);
+	const segments = normalized.split("/").filter(Boolean);
+	const matches = PLATFORM_IDS.filter((id) => segments.includes(PLATFORMS[id].platformDir));
+	if (matches.length === 1) return matches[0];
 	return;
 }
+/**
+* Return all platforms whose instruction file matches this basename.
+*
+* Example: "CLAUDE.md" -> ["claude"], "AGENTS.md" -> ["opencode", "cursor", "codex"]
+*/
+function inferInstructionPlatformsFromFileName(fileName) {
+	const matches = [];
+	for (const id of PLATFORM_IDS) {
+		const instructionPath = getInstallPath({
+			platform: id,
+			type: "instruction",
+			scope: "project"
+		});
+		if (instructionPath === fileName) matches.push(id);
+	}
+	return matches;
+}
+function getProjectTypeDirMap(platform) {
+	const map = new Map();
+	for (const [type, cfg] of Object.entries(PLATFORMS[platform].types)) {
+		const template = cfg.project;
+		if (!template) continue;
+		if (!template.startsWith("{platformDir}/")) continue;
+		const rest = template.slice(14);
+		const dir = rest.split("/")[0];
+		if (!dir || dir.includes("{")) continue;
+		map.set(dir, type);
+	}
+	return map;
+}
+/**
+* Infer a rule type from a file path for a known platform.
+* Uses PLATFORMS templates as source-of-truth.
+*/
+function inferTypeFromPath(platform, filePath) {
+	const base = getBasename(filePath);
+	const instructionPath = getInstallPath({
+		platform,
+		type: "instruction",
+		scope: "project"
+	});
+	if (instructionPath === base) return "instruction";
+	const normalized = normalizePathForInference(filePath);
+	const segments = normalized.split("/").filter(Boolean);
+	const platformDirIndex = segments.lastIndexOf(PLATFORMS[platform].platformDir);
+	if (platformDirIndex < 0) return;
+	const nextDir = segments[platformDirIndex + 1];
+	if (!nextDir) return;
+	return getProjectTypeDirMap(platform).get(nextDir);
+}
 
 //#endregion
 //#region src/utils/encoding.ts
@@ -238,7 +287,10 @@ function encodeUtf8(value) {
 function decodeUtf8(payload) {
 	const bytes = toUint8Array(payload);
 	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("utf8");
-	return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+	return new TextDecoder("utf-8", {
+		fatal: false,
+		ignoreBOM: false
+	}).decode(bytes);
 }
 function toUint8Array(payload) {
 	if (payload instanceof Uint8Array) return payload;
@@ -247,25 +299,53 @@ function toUint8Array(payload) {
 }
 
 //#endregion
-//#region src/preset/schema.ts
+//#region src/schemas/common.ts
 const PLATFORM_ID_SET = new Set(PLATFORM_IDS);
-const VERSION_REGEX = /^[1-9]\d*\.\d+$/;
-const platformIdSchema = z.enum(PLATFORM_IDS);
-const titleSchema = z.string().trim().min(1, "Title is required").max(80, "Title must be 80 characters or less");
-const descriptionSchema = z.string().trim().min(1, "Description is required").max(500, "Description must be 500 characters or less");
-const versionSchema = z.string().trim().regex(VERSION_REGEX, "Version must be in MAJOR.MINOR format (e.g., 1.3)");
-const majorVersionSchema = z.number().int().positive("Major version must be a positive integer");
 const TAG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const TAG_ERROR = "Must be lowercase alphanumeric with hyphens (e.g., my-tag)";
+/**
+* Schema for a single tag.
+* - Max 35 characters
+* - Lowercase alphanumeric with hyphens
+* - Platform names blocked (redundant with platform field)
+*/
 const tagSchema = z.string().trim().min(1, "Tag cannot be empty").max(35, "Tag must be 35 characters or less").regex(TAG_REGEX, TAG_ERROR).refine((tag) => !PLATFORM_ID_SET.has(tag), { message: "Platform names cannot be used as tags (redundant with platform field)" });
-const tagsSchema = z.array(tagSchema).min(1, "At least one tag is required").max(10, "Maximum 10 tags allowed");
+/**
+* Schema for tags array.
+* - 0-10 tags allowed
+*/
+const tagsSchema = z.array(tagSchema).max(10, "Maximum 10 tags allowed");
+const NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const NAME_ERROR = "Must be lowercase alphanumeric with hyphens (e.g., my-rule)";
+/**
+* Schema for rule name.
+* - Max 64 characters
+* - Lowercase alphanumeric with hyphens
+*/
+const nameSchema = z.string().trim().min(1, "Name is required").max(64, "Name must be 64 characters or less").regex(NAME_REGEX, NAME_ERROR);
+/**
+* Schema for display title.
+* - Max 80 characters
+*/
+const titleSchema = z.string().trim().min(1, "Title is required").max(80, "Title must be 80 characters or less");
+/**
+* Schema for description.
+* - Max 500 characters
+*/
+const descriptionSchema = z.string().trim().max(500, "Description must be 500 characters or less");
+
+//#endregion
+//#region src/rule/schema.ts
+const VERSION_REGEX$1 = /^[1-9]\d*\.\d+$/;
+const platformIdSchema = z.enum(PLATFORM_IDS);
+const normalizedDescriptionSchema = descriptionSchema.optional().default("");
+const normalizedTagsSchema = tagsSchema.optional().default([]);
+const versionSchema = z.string().trim().regex(VERSION_REGEX$1, "Version must be in MAJOR.MINOR format (e.g., 1.3)");
+const majorVersionSchema = z.number().int().positive("Major version must be a positive integer");
 const featureSchema = z.string().trim().min(1, "Feature cannot be empty").max(100, "Feature must be 100 characters or less");
 const featuresSchema = z.array(featureSchema).max(5, "Maximum 5 features allowed");
 const installMessageSchema = z.string().trim().max(2e3, "Install message must be 2000 characters or less");
 const contentSchema = z.string();
-const SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const SLUG_ERROR = "Must be lowercase alphanumeric with hyphens (e.g., my-preset)";
-const slugSchema = z.string().trim().min(1, "Name is required").max(64, "Name must be 64 characters or less").regex(SLUG_REGEX, SLUG_ERROR);
 const COMMON_LICENSES = [
 	"MIT",
 	"Apache-2.0",
@@ -278,69 +358,131 @@ const licenseSchema = z.string().trim().min(1, "License is required").max(128, "
 const pathSchema = z.string().trim().min(1);
 const ignorePatternSchema = z.string().trim().min(1, "Ignore pattern cannot be empty");
 const ignoreSchema = z.array(ignorePatternSchema).max(50, "Maximum 50 ignore patterns allowed");
-const presetConfigSchema = z.object({
+/**
+* Platform entry - either a platform ID string or an object with optional path.
+*
+* Examples:
+* - "opencode" (shorthand, uses default directory)
+* - { platform: "opencode", path: "rules" } (custom path)
+*/
+const platformEntryObjectSchema = z.object({
+	platform: platformIdSchema,
+	path: pathSchema.optional()
+}).strict();
+const platformEntrySchema = z.union([platformIdSchema, platformEntryObjectSchema]);
+/**
+* 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.
+*/
+const ruleTypeSchema = z.enum(RULE_TYPE_TUPLE);
+const typeSchema = ruleTypeSchema.optional();
+/**
+* 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" }]`
+*/
+const ruleConfigSchema = z.object({
 	$schema: z.string().optional(),
-	name: slugSchema,
+	name: nameSchema,
+	type: typeSchema,
 	title: titleSchema,
 	version: majorVersionSchema.optional(),
-	description: descriptionSchema,
-	tags: tagsSchema,
+	description: normalizedDescriptionSchema,
+	tags: normalizedTagsSchema,
 	features: featuresSchema.optional(),
 	license: licenseSchema,
-	platform: platformIdSchema,
-	path: pathSchema.optional(),
-	ignore: ignoreSchema.optional()
+	ignore: ignoreSchema.optional(),
+	platforms: z.array(platformEntrySchema).min(1, "At least one platform is required")
 }).strict();
 const bundledFileSchema = z.object({
 	path: z.string().min(1),
 	size: z.number().int().nonnegative(),
 	checksum: z.string().length(64),
-	contents: z.string()
+	content: z.string()
 });
 /**
-* Schema for what clients send to publish a preset.
+* Schema for per-platform variant in publish input.
+*/
+const publishVariantInputSchema = z.object({
+	platform: platformIdSchema,
+	files: z.array(bundledFileSchema).min(1),
+	readmeContent: contentSchema.optional(),
+	licenseContent: contentSchema.optional(),
+	installMessage: installMessageSchema.optional()
+});
+/**
+* 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-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"
 */
-const presetPublishInputSchema = z.object({
-	name: slugSchema,
-	platform: platformIdSchema,
+const rulePublishInputSchema = z.object({
+	name: nameSchema,
+	type: typeSchema,
 	title: titleSchema,
-	description: descriptionSchema,
-	tags: tagsSchema,
+	description: normalizedDescriptionSchema,
+	tags: normalizedTagsSchema,
 	license: licenseSchema,
-	licenseContent: contentSchema.optional(),
-	readmeContent: contentSchema.optional(),
 	features: featuresSchema.optional(),
-	installMessage: installMessageSchema.optional(),
-	files: z.array(bundledFileSchema).min(1),
+	variants: z.array(publishVariantInputSchema).min(1, "At least one platform variant is required"),
 	version: majorVersionSchema.optional()
 });
 /**
-* Schema for what registries store and return.
-* Includes full namespaced slug and version assigned by registry.
+* 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.
 */
-const presetBundleSchema = presetPublishInputSchema.omit({
-	name: true,
-	version: true
-}).extend({
+const ruleBundleSchema = z.object({
+	name: nameSchema,
+	type: typeSchema,
+	platform: platformIdSchema,
+	title: titleSchema,
+	description: normalizedDescriptionSchema,
+	tags: normalizedTagsSchema,
+	license: licenseSchema,
+	features: featuresSchema.optional(),
+	files: z.array(bundledFileSchema).min(1, "At least one file is required"),
+	readmeContent: contentSchema.optional(),
+	licenseContent: contentSchema.optional(),
+	installMessage: installMessageSchema.optional(),
 	slug: z.string().trim().min(1),
 	version: versionSchema
 });
-const presetSchema = presetBundleSchema.omit({
-	files: true,
-	readmeContent: true,
-	licenseContent: true,
-	installMessage: true
-}).extend({
-	name: z.string().trim().min(1),
-	bundleUrl: z.string().trim().min(1),
-	fileCount: z.number().int().nonnegative(),
-	totalSize: z.number().int().nonnegative()
-});
-const presetIndexSchema = z.record(z.string(), presetSchema);
+
+//#endregion
+//#region src/rule/types.ts
+/** Normalize a raw platform entry to the object form */
+function normalizePlatformEntry(entry) {
+	if (typeof entry === "string") return { platform: entry };
+	return entry;
+}
+
+//#endregion
+//#region src/rule/validate.ts
+function validateRule(config) {
+	const errors = [];
+	const warnings = [];
+	if (!config.platforms || config.platforms.length === 0) errors.push("At least one platform is required.");
+	for (const entry of config.platforms) if (!isSupportedPlatform(entry.platform)) errors.push(`Unknown platform "${entry.platform}". Supported: ${PLATFORM_IDS.join(", ")}`);
+	if (config.type) for (const entry of config.platforms) {
+		if (!isSupportedPlatform(entry.platform)) continue;
+		if (!isValidType(entry.platform, config.type)) errors.push(`Platform "${entry.platform}" does not support type "${config.type}". Rule "${config.name}" cannot target this platform with type "${config.type}".`);
+	}
+	const hasPlaceholderFeatures = config.features?.some((feature) => feature.trim().startsWith("//"));
+	if (hasPlaceholderFeatures) errors.push("Replace placeholder comments in features before publishing.");
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
 
 //#endregion
 //#region src/builder/utils.ts
@@ -349,19 +491,20 @@ function cleanInstallMessage(value) {
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : void 0;
 }
-function encodeItemName(slug, platform) {
-	return `${slug}.${platform}`;
-}
-function validatePresetConfig(config, slug) {
+/**
+* Validate raw rule config from JSON.
+* Returns the raw config shape (before normalization).
+*/
+function validateConfig(config, slug) {
 	try {
-		return presetConfigSchema.parse(config);
+		return ruleConfigSchema.parse(config);
 	} catch (e) {
 		if (e instanceof ZodError) {
 			const messages = e.issues.map((issue) => {
 				const path = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
 				return `${path}${issue.message}`;
 			});
-			throw new Error(`Invalid preset config for ${slug}:\n  - ${messages.join("\n  - ")}`);
+			throw new Error(`Invalid rule config for ${slug}:\n  - ${messages.join("\n  - ")}`);
 		}
 		throw e;
 	}
@@ -384,162 +527,163 @@ async function sha256(data) {
 	return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 /**
-* Builds a PresetPublishInput from preset input.
-* Used by CLI to prepare data for publishing to a registry.
-*/
-async function buildPresetPublishInput(options) {
-	const { preset: presetInput, version } = options;
-	if (!NAME_PATTERN.test(presetInput.name)) throw new Error(`Invalid name "${presetInput.name}". Names must be lowercase kebab-case.`);
-	const presetConfig = validatePresetConfig(presetInput.config, presetInput.name);
-	const platform = presetConfig.platform;
-	ensureKnownPlatform(platform, presetInput.name);
-	if (presetInput.files.length === 0) throw new Error(`Preset ${presetInput.name} does not include any files.`);
-	const files = await createBundledFilesFromInputs(presetInput.files);
-	const installMessage = cleanInstallMessage(presetInput.installMessage);
-	const features = presetConfig.features ?? [];
-	const readmeContent = presetInput.readmeContent?.trim() || void 0;
-	const licenseContent = presetInput.licenseContent?.trim() || void 0;
-	const majorVersion = version ?? presetConfig.version;
+* Builds a RulePublishInput from rule input.
+*
+* RuleInput always has platformFiles array (unified format).
+*/
+async function buildPublishInput(options) {
+	const { rule, version } = options;
+	if (!NAME_PATTERN.test(rule.name)) throw new Error(`Invalid name "${rule.name}". Names must be lowercase kebab-case.`);
+	const config = validateConfig(rule.config, rule.name);
+	const majorVersion = version ?? config.version;
+	const platforms = rule.config.platforms;
+	if (platforms.length === 0) throw new Error(`Rule ${rule.name} must specify at least one platform.`);
+	for (const entry of platforms) ensureKnownPlatform(entry.platform, rule.name);
+	const ruleType = config.type;
+	if (ruleType) {
+		for (const entry of platforms) if (!isValidType(entry.platform, ruleType)) throw new Error(`Platform "${entry.platform}" does not support type "${ruleType}". Rule "${rule.name}" cannot target this platform with type "${ruleType}".`);
+	}
+	const variants = [];
+	for (const entry of platforms) {
+		const platformData = rule.platformFiles.find((pf) => pf.platform === entry.platform);
+		if (!platformData) throw new Error(`Rule ${rule.name} is missing files for platform "${entry.platform}".`);
+		if (platformData.files.length === 0) throw new Error(`Rule ${rule.name} has no files for platform "${entry.platform}".`);
+		const files = await createBundledFilesFromInputs(platformData.files);
+		variants.push({
+			platform: entry.platform,
+			files,
+			readmeContent: platformData.readmeContent?.trim() || rule.readmeContent?.trim() || void 0,
+			licenseContent: platformData.licenseContent?.trim() || rule.licenseContent?.trim() || void 0,
+			installMessage: cleanInstallMessage(platformData.installMessage) || cleanInstallMessage(rule.installMessage)
+		});
+	}
 	return {
-		name: presetInput.name,
-		platform,
-		title: presetConfig.title,
-		description: presetConfig.description,
-		tags: presetConfig.tags ?? [],
-		license: presetConfig.license,
-		licenseContent,
-		readmeContent,
-		features,
-		installMessage,
-		files,
+		name: rule.name,
+		...ruleType && { type: ruleType },
+		title: config.title,
+		description: config.description,
+		tags: config.tags ?? [],
+		license: config.license,
+		features: config.features ?? [],
+		variants,
 		...majorVersion !== void 0 && { version: majorVersion }
 	};
 }
 /**
-* 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
 */
-async function buildPresetRegistry(options) {
+async function buildRegistry(options) {
 	const bundleBase = normalizeBundleBase(options.bundleBase);
-	const entries = [];
+	const rules = [];
 	const bundles = [];
-	for (const presetInput of options.presets) {
-		if (!NAME_PATTERN.test(presetInput.name)) throw new Error(`Invalid name "${presetInput.name}". Names must be lowercase kebab-case.`);
-		const presetConfig = validatePresetConfig(presetInput.config, presetInput.name);
-		const platform = presetConfig.platform;
-		ensureKnownPlatform(platform, presetInput.name);
-		if (presetInput.files.length === 0) throw new Error(`Preset ${presetInput.name} does not include any files.`);
-		const files = await createBundledFilesFromInputs(presetInput.files);
-		const totalSize = files.reduce((sum, file) => sum + file.size, 0);
-		const installMessage = cleanInstallMessage(presetInput.installMessage);
-		const features = presetConfig.features ?? [];
-		const readmeContent = presetInput.readmeContent?.trim() || void 0;
-		const licenseContent = presetInput.licenseContent?.trim() || void 0;
-		const majorVersion = presetConfig.version ?? 1;
-		const version = `${majorVersion}.0`;
-		const slug = presetInput.name;
-		const entry = {
-			name: encodeItemName(slug, platform),
-			slug,
-			platform,
-			title: presetConfig.title,
-			version,
-			description: presetConfig.description,
-			tags: presetConfig.tags ?? [],
-			license: presetConfig.license,
-			features,
-			bundleUrl: getBundlePath(bundleBase, slug, platform, version),
-			fileCount: files.length,
-			totalSize
-		};
-		entries.push(entry);
-		const bundle = {
+	for (const ruleInput of options.rules) {
+		const publishInput = await buildPublishInput({ rule: ruleInput });
+		const slug = publishInput.name;
+		const version = `${publishInput.version ?? 1}.0`;
+		const ruleVariants = publishInput.variants.map((v) => ({
+			platform: v.platform,
+			bundleUrl: getBundlePath(bundleBase, slug, v.platform, version),
+			fileCount: v.files.length,
+			totalSize: v.files.reduce((sum, f) => sum + f.size, 0)
+		}));
+		ruleVariants.sort((a, b) => a.platform.localeCompare(b.platform));
+		const rule = {
 			slug,
-			platform,
-			title: presetConfig.title,
-			version,
-			description: presetConfig.description,
-			tags: presetConfig.tags ?? [],
-			license: presetConfig.license,
-			licenseContent,
-			readmeContent,
-			features,
-			installMessage,
-			files
+			name: publishInput.name,
+			...publishInput.type && { type: publishInput.type },
+			title: publishInput.title,
+			description: publishInput.description,
+			tags: publishInput.tags,
+			license: publishInput.license,
+			features: publishInput.features ?? [],
+			versions: [{
+				version,
+				isLatest: true,
+				variants: ruleVariants
+			}]
 		};
-		bundles.push(bundle);
+		rules.push(rule);
+		for (const variant of publishInput.variants) {
+			const bundle = {
+				name: publishInput.name,
+				...publishInput.type && { type: publishInput.type },
+				slug,
+				platform: variant.platform,
+				title: publishInput.title,
+				version,
+				description: publishInput.description,
+				tags: publishInput.tags,
+				license: publishInput.license,
+				features: publishInput.features,
+				files: variant.files,
+				readmeContent: variant.readmeContent,
+				licenseContent: variant.licenseContent,
+				installMessage: variant.installMessage
+			};
+			bundles.push(bundle);
+		}
 	}
-	sortBySlugAndPlatform(entries);
-	sortBySlugAndPlatform(bundles);
-	const index = entries.reduce((acc, entry) => {
-		acc[entry.name] = entry;
-		return acc;
-	}, {});
+	rules.sort((a, b) => a.slug.localeCompare(b.slug));
+	bundles.sort((a, b) => {
+		if (a.slug === b.slug) return a.platform.localeCompare(b.platform);
+		return a.slug.localeCompare(b.slug);
+	});
 	return {
-		entries,
-		index,
+		rules,
 		bundles
 	};
 }
 async function createBundledFilesFromInputs(files) {
 	const results = await Promise.all(files.map(async (file) => {
-		const payload = normalizeFilePayload(file.contents);
-		const contents = encodeFilePayload(payload, file.path);
+		const payload = normalizeFilePayload(file.content);
+		const content = encodeFilePayload(payload, file.path);
 		const checksum = await sha256(payload);
 		return {
 			path: toPosixPath(file.path),
 			size: payload.length,
 			checksum,
-			contents
+			content
 		};
 	}));
 	return results.sort((a, b) => a.path.localeCompare(b.path));
 }
-function normalizeFilePayload(contents) {
-	if (typeof contents === "string") return new TextEncoder().encode(contents);
-	if (contents instanceof ArrayBuffer) return new Uint8Array(contents);
-	if (ArrayBuffer.isView(contents)) return new Uint8Array(contents.buffer, contents.byteOffset, contents.byteLength);
-	return new Uint8Array(contents);
+function normalizeFilePayload(content) {
+	if (typeof content === "string") return new TextEncoder().encode(content);
+	if (content instanceof ArrayBuffer) return new Uint8Array(content);
+	if (ArrayBuffer.isView(content)) return new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+	return new Uint8Array(content);
 }
 function encodeFilePayload(data, filePath) {
-	const decoder = new TextDecoder("utf-8", { fatal: true });
+	const decoder = new TextDecoder("utf-8", {
+		fatal: true,
+		ignoreBOM: false
+	});
 	try {
 		return decoder.decode(data);
 	} catch {
 		throw new Error(`Binary files are not supported: "${filePath}". Only UTF-8 text files are allowed.`);
 	}
 }
-/**
-* Normalize bundle base by removing trailing slashes.
-* Returns empty string if base is undefined/empty (use default relative path).
-*/
 function normalizeBundleBase(base) {
 	if (!base) return "";
 	return base.replace(/\/+$/, "");
 }
-/**
-* Returns the bundle URL/path for a preset.
-* Format: {base}/{STATIC_BUNDLE_DIR}/{slug}/{platform}/{version}
-*/
-function getBundlePath(base, slug, platform, version = LATEST_VERSION) {
+function getBundlePath(base, slug, platform, version) {
 	const prefix = base ? `${base}/` : "";
 	return `${prefix}${STATIC_BUNDLE_DIR}/${slug}/${platform}/${version}`;
 }
 function ensureKnownPlatform(platform, slug) {
 	if (!isSupportedPlatform(platform)) throw new Error(`Unknown platform "${platform}" in ${slug}. Supported: ${PLATFORM_IDS.join(", ")}`);
 }
-function sortBySlugAndPlatform(items) {
-	items.sort((a, b) => {
-		if (a.slug === b.slug) return a.platform.localeCompare(b.platform);
-		return a.slug.localeCompare(b.slug);
-	});
-}
 
 //#endregion
 //#region src/client/bundle.ts
 function decodeBundledFile(file) {
-	return encodeUtf8(file.contents);
+	return encodeUtf8(file.content);
 }
 async function verifyBundledFileChecksum(file, payload) {
 	const bytes = toUint8Array(payload);
@@ -567,39 +711,42 @@ async function sha256Hex(payload) {
 }
 
 //#endregion
-//#region src/client/registry.ts
+//#region src/constants.ts
 /**
-* Resolves a preset from the registry via API endpoint.
-* Returns the entry metadata and the absolute bundle URL.
+* Shared constants for agentrules.
+*/
+/** Filename for rule configuration */
+const RULE_CONFIG_FILENAME = "agentrules.json";
+/** JSON Schema URL for rule configuration */
+const RULE_SCHEMA_URL = "https://agentrules.directory/schema/agentrules.json";
+/** API root path segment */
+const API_PATH = "api";
+/** Default version identifier for latest rule version */
+const LATEST_VERSION = "latest";
+/**
+* API endpoint paths (relative to registry base URL).
 *
-* @param baseUrl - Registry base URL
-* @param slug - Preset slug
-* @param platform - Target platform
-* @param version - Version to resolve (defaults to "latest")
+* 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
 */
-async function resolvePreset(baseUrl, slug, platform, version = LATEST_VERSION) {
-	const apiUrl = new URL(API_ENDPOINTS.presets.get(slug, platform, version), baseUrl);
-	const response = await fetch(apiUrl);
-	if (!response.ok) {
-		if (response.status === 404) {
-			const versionInfo = version === LATEST_VERSION ? "" : ` version "${version}"`;
-			throw new Error(`Preset "${slug}"${versionInfo} for platform "${platform}" was not found in the registry.`);
-		}
-		throw new Error(`Failed to resolve preset (${response.status} ${response.statusText}).`);
-	}
-	try {
-		const preset = await response.json();
-		const resolvedBundleUrl = new URL(preset.bundleUrl, baseUrl).toString();
-		return {
-			preset,
-			bundleUrl: resolvedBundleUrl
-		};
-	} catch (error) {
-		throw new Error(`Unable to parse preset response: ${error.message}`);
+const API_ENDPOINTS = {
+	rules: {
+		base: `${API_PATH}/rules`,
+		get: (slug) => `${API_PATH}/rules/${slug}`,
+		unpublish: (slug, version) => `${API_PATH}/rules/${slug}/${version}`
+	},
+	auth: {
+		session: `${API_PATH}/auth/get-session`,
+		deviceCode: `${API_PATH}/auth/device/code`,
+		deviceToken: `${API_PATH}/auth/device/token`
 	}
-}
+};
+
+//#endregion
+//#region src/client/registry.ts
 /**
-* Fetches a bundle from an absolute URL or resolves it relative to the registry.
+* Fetches a bundle from an absolute URL.
 */
 async function fetchBundle(bundleUrl) {
 	const response = await fetch(bundleUrl);
@@ -610,61 +757,116 @@ async function fetchBundle(bundleUrl) {
 		throw new Error(`Unable to parse bundle JSON: ${error.message}`);
 	}
 }
+/**
+* Resolves a slug to get all versions and platform variants.
+*
+* @param baseUrl - Registry base URL
+* @param slug - Content slug (may contain slashes, e.g., "username/my-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
+*/
+async function resolveSlug(baseUrl, slug, version) {
+	const url = new URL(API_ENDPOINTS.rules.get(slug), baseUrl);
+	if (version) url.searchParams.set("version", version);
+	let response;
+	try {
+		response = await fetch(url);
+	} catch (error) {
+		throw new Error(`Failed to connect to registry: ${error.message}`);
+	}
+	if (response.status === 404) return null;
+	if (!response.ok) {
+		let errorMessage = `Registry returned ${response.status} ${response.statusText}`;
+		try {
+			const body = await response.json();
+			if (body && typeof body === "object" && "error" in body && typeof body.error === "string") errorMessage = body.error;
+		} catch {}
+		throw new Error(errorMessage);
+	}
+	const data = await response.json();
+	for (const ver of data.versions) for (const variant of ver.variants) if ("bundleUrl" in variant) variant.bundleUrl = new URL(variant.bundleUrl, baseUrl).toString();
+	return data;
+}
 
 //#endregion
-//#region src/rule/schema.ts
-const NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+//#region src/resolve/schema.ts
+const VERSION_REGEX = /^[1-9]\d*\.\d+$/;
+const ruleVariantBundleSchema = z.object({
+	platform: platformIdSchema,
+	bundleUrl: z.string().min(1),
+	fileCount: z.number().int().nonnegative(),
+	totalSize: z.number().int().nonnegative()
+});
+const ruleVariantInlineSchema = z.object({
+	platform: platformIdSchema,
+	content: z.string().min(1),
+	fileCount: z.number().int().nonnegative(),
+	totalSize: z.number().int().nonnegative()
+});
+const ruleVariantSchema = z.union([ruleVariantBundleSchema, ruleVariantInlineSchema]);
+const ruleVersionSchema = z.object({
+	version: z.string().regex(VERSION_REGEX, "Version must be MAJOR.MINOR format"),
+	isLatest: z.boolean(),
+	publishedAt: z.string().datetime().optional(),
+	variants: z.array(ruleVariantSchema).min(1)
+});
+const resolvedRuleSchema = z.object({
+	slug: z.string().min(1),
+	name: z.string().min(1),
+	title: z.string().min(1),
+	description: z.string(),
+	tags: z.array(z.string()),
+	license: z.string(),
+	features: z.array(z.string()),
+	versions: z.array(ruleVersionSchema).min(1)
+});
+const resolveResponseSchema = resolvedRuleSchema;
+
+//#endregion
+//#region src/resolve/utils.ts
 /**
-* Schema for the rule name.
-* This is what users provide when creating a rule.
-*/
-const ruleNameSchema = z.string().trim().min(1, "Name is required").max(64, "Name must be 64 characters or less").regex(NAME_REGEX, "Must be lowercase alphanumeric with hyphens");
-const ruleTitleSchema = z.string().trim().min(1, "Title is required").max(80, "Title must be 80 characters or less");
-const ruleDescriptionSchema = z.string().trim().max(500, "Description must be 500 characters or less");
-const rulePlatformSchema = z.enum(PLATFORM_IDS);
-const ruleTypeSchema = z.string().trim().min(1).max(32);
-const ruleContentSchema = z.string().min(1, "Content is required").max(1e5, "Content must be 100KB or less");
-const ruleTagSchema = z.string().trim().min(1).max(32).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Tags must be lowercase alphanumeric with single hyphens between words");
-const ruleTagsSchema = z.array(ruleTagSchema).min(1, "At least 1 tag is required").max(10, "Maximum 10 tags allowed");
-/** Common fields shared across all platform-type combinations */
-const ruleCommonFields = {
-	name: ruleNameSchema,
-	title: ruleTitleSchema,
-	description: ruleDescriptionSchema.optional(),
-	content: ruleContentSchema,
-	tags: ruleTagsSchema
-};
+* Type guard for rule variant with bundleUrl
+*/
+function hasBundle(variant) {
+	return "bundleUrl" in variant;
+}
 /**
-* Discriminated union schema for platform + type combinations.
-* Each platform has its own set of valid types.
-*/
-const rulePlatformTypeSchema = z.discriminatedUnion("platform", [
-	z.object({
-		platform: z.literal("opencode"),
-		type: z.enum(PLATFORM_RULE_TYPES.opencode)
-	}),
-	z.object({
-		platform: z.literal("claude"),
-		type: z.enum(PLATFORM_RULE_TYPES.claude)
-	}),
-	z.object({
-		platform: z.literal("cursor"),
-		type: z.enum(PLATFORM_RULE_TYPES.cursor)
-	}),
-	z.object({
-		platform: z.literal("codex"),
-		type: z.enum(PLATFORM_RULE_TYPES.codex)
-	})
-]);
-/** Schema for rule creation with discriminated union for platform+type */
-const ruleCreateInputSchema = z.object(ruleCommonFields).and(rulePlatformTypeSchema);
-const ruleUpdateInputSchema = z.object({
-	name: ruleNameSchema,
-	title: ruleTitleSchema.optional(),
-	description: ruleDescriptionSchema.optional(),
-	content: ruleContentSchema.optional(),
-	tags: ruleTagsSchema.optional()
-});
+* Type guard for rule variant with inline content
+*/
+function hasInlineContent(variant) {
+	return "content" in variant;
+}
+/**
+* Get the latest version from a resolved rule
+*/
+function getLatestVersion(item) {
+	return item.versions.find((v) => v.isLatest);
+}
+/**
+* Get a specific version from a resolved rule
+*/
+function getVersion(item, version) {
+	return item.versions.find((v) => v.version === version);
+}
+/**
+* Get a specific platform variant from a rule version
+*/
+function getVariant(version, platform) {
+	return version.variants.find((v) => v.platform === platform);
+}
+/**
+* Get all available platforms for a rule version
+*/
+function getPlatforms(version) {
+	return version.variants.map((v) => v.platform);
+}
+/**
+* Check if a platform is available in any version of a rule
+*/
+function hasPlatform(item, platform) {
+	return item.versions.some((v) => v.variants.some((variant) => variant.platform === platform));
+}
 
 //#endregion
 //#region src/utils/diff.ts
@@ -690,4 +892,4 @@ function normalizeBundlePath(value) {
 }
 
 //#endregion
-export { AGENT_RULES_DIR, API_ENDPOINTS, COMMON_LICENSES, LATEST_VERSION, PLATFORMS, PLATFORM_IDS, PLATFORM_ID_TUPLE, PLATFORM_RULE_TYPES, PRESET_CONFIG_FILENAME, PRESET_SCHEMA_URL, 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, COMMON_LICENSES, LATEST_VERSION, PLATFORMS, PLATFORM_IDS, PLATFORM_ID_TUPLE, PLATFORM_RULE_TYPES, RULE_CONFIG_FILENAME, RULE_SCHEMA_URL, RULE_TYPE_TUPLE, STATIC_BUNDLE_DIR, 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 };