@agentrules/core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,237 @@
+import { z } from "zod";
+
+//#region src/types.d.ts
+type PlatformId = "opencode" | "codex" | "claude" | "cursor";
+type AuthorInfo = {
+  name: string;
+  email?: string;
+  url?: string;
+};
+type PlatformSpecificConfig = {
+  features?: string[];
+  installMessage?: string;
+};
+type PresetConfig = {
+  title: string;
+  version: string;
+  description: string;
+  tags?: string[];
+  author?: AuthorInfo;
+  license?: string;
+  primary?: PlatformId;
+  platforms: Partial<Record<PlatformId, PlatformSpecificConfig>>;
+};
+type BundledFile = {
+  path: string;
+  size: number;
+  checksum: string;
+  encoding: "utf-8" | "base64";
+  contents: string;
+};
+type RegistryBundle = {
+  slug: string;
+  platform: PlatformId;
+  title: string;
+  version: string;
+  description: string;
+  tags: string[];
+  author?: AuthorInfo;
+  license?: string;
+  features?: string[];
+  installMessage?: string;
+  files: BundledFile[];
+};
+type RegistryEntry = {
+  name: string;
+  slug: string;
+  platform: PlatformId;
+  title: string;
+  version: string;
+  description: string;
+  tags: string[];
+  author?: AuthorInfo;
+  license?: string;
+  features?: string[];
+  installMessage?: string;
+  bundlePath: string;
+  fileCount: number;
+  totalBytes: number;
+  isPrimary?: boolean;
+};
+type RegistryData = {
+  $schema: string;
+  items: RegistryEntry[];
+};
+type RegistryIndex = Record<string, RegistryEntry>;
+type RegistryIndexItem = RegistryEntry; //#endregion
+//#region src/build-utils.d.ts
+declare function normalizeBundlePublicBase(value: string): string;
+declare function isAbsoluteUrl(value: string): boolean;
+declare function cleanInstallMessage(value: unknown): string | undefined;
+declare function encodeItemName(slug: string, platform: PlatformId): string;
+declare function validatePresetConfig(config: unknown, slug: string): PresetConfig;
+declare function collectBundledFiles(files: Record<string, string>): BundledFile[];
+
+//#endregion
+//#region src/bundle.d.ts
+declare function decodeBundledFile(file: BundledFile): Uint8Array;
+declare function verifyBundledFileChecksum(file: BundledFile, payload: ArrayBuffer | ArrayBufferView): Promise<void>;
+declare function isLikelyText(payload: ArrayBuffer | ArrayBufferView): boolean;
+declare function toUtf8String(payload: ArrayBuffer | ArrayBufferView): string;
+
+//#endregion
+//#region src/diff.d.ts
+type DiffPreviewOptions = {
+  context?: number;
+  maxLines?: number;
+};
+declare function createDiffPreview(path: string, currentText: string, incomingText: string, options?: DiffPreviewOptions): string;
+
+//#endregion
+//#region src/encoding.d.ts
+declare function toPosixPath(pathValue: string): string;
+declare function encodeUtf8(value: string): Uint8Array<ArrayBuffer>;
+declare function decodeUtf8(payload: ArrayBuffer | ArrayBufferView): string;
+declare function toUint8Array(payload: ArrayBuffer | ArrayBufferView): Uint8Array<ArrayBufferLike>;
+
+//#endregion
+//#region src/paths.d.ts
+declare function normalizeBundlePath(value: string): string;
+declare function normalizePathFragment(value?: string): string | undefined;
+declare function maybeStripPrefix(pathInput: string, prefix?: string): string;
+
+//#endregion
+//#region src/platform.d.ts
+declare const PLATFORM_IDS: ["opencode", "codex", "claude", "cursor"];
+declare function isSupportedPlatform(value: string): value is PlatformId;
+declare function normalizePlatformInput(value: string): PlatformId;
+
+//#endregion
+//#region src/preset.d.ts
+declare function definePreset(config: PresetConfig): PresetConfig;
+
+//#endregion
+//#region src/registry.d.ts
+type FetchRegistryBundleResult = {
+  bundle: RegistryBundle;
+  etag: string | null;
+};
+declare function fetchRegistryIndex(baseUrl: string): Promise<RegistryIndex>;
+declare function fetchRegistryBundle(baseUrl: string, bundlePath: string): Promise<FetchRegistryBundleResult>;
+declare function resolveRegistryEntry(index: RegistryIndex, input: string, explicitPlatform?: PlatformId): RegistryEntry;
+
+//#endregion
+//#region src/schema.d.ts
+declare const platformIdSchema: z.ZodEnum<{
+  opencode: "opencode";
+  codex: "codex";
+  claude: "claude";
+  cursor: "cursor";
+}>;
+declare const authorSchema: z.ZodObject<{
+  name: z.ZodString;
+  email: z.ZodOptional<z.ZodEmail>;
+  url: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>;
+declare const platformPresetSchema: z.ZodObject<{
+  title: z.ZodString;
+  version: z.ZodString;
+  description: z.ZodString;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  author: z.ZodOptional<z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    url: z.ZodOptional<z.ZodURL>;
+  }, z.core.$strict>>;
+  license: z.ZodOptional<z.ZodString>;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  installMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const bundledFileSchema: z.ZodObject<{
+  path: z.ZodString;
+  size: z.ZodNumber;
+  checksum: z.ZodString;
+  encoding: z.ZodUnion<readonly [z.ZodLiteral<"utf-8">, z.ZodLiteral<"base64">]>;
+  contents: z.ZodString;
+}, z.core.$strip>;
+declare const registryBundleSchema: z.ZodObject<{
+  slug: z.ZodString;
+  platform: z.ZodEnum<{
+    opencode: "opencode";
+    codex: "codex";
+    claude: "claude";
+    cursor: "cursor";
+  }>;
+  title: z.ZodString;
+  version: z.ZodString;
+  description: z.ZodString;
+  tags: z.ZodArray<z.ZodString>;
+  author: z.ZodOptional<z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    url: z.ZodOptional<z.ZodURL>;
+  }, z.core.$strict>>;
+  license: 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;
+    encoding: z.ZodUnion<readonly [z.ZodLiteral<"utf-8">, z.ZodLiteral<"base64">]>;
+    contents: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const registryEntrySchema: z.ZodObject<{
+  title: z.ZodString;
+  version: z.ZodString;
+  description: z.ZodString;
+  tags: z.ZodArray<z.ZodString>;
+  author: z.ZodOptional<z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    url: z.ZodOptional<z.ZodURL>;
+  }, z.core.$strict>>;
+  license: z.ZodOptional<z.ZodString>;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  installMessage: z.ZodOptional<z.ZodString>;
+  platform: z.ZodEnum<{
+    opencode: "opencode";
+    codex: "codex";
+    claude: "claude";
+    cursor: "cursor";
+  }>;
+  slug: z.ZodString;
+  name: z.ZodString;
+  bundlePath: z.ZodString;
+  fileCount: z.ZodNumber;
+  totalBytes: z.ZodNumber;
+}, z.core.$strip>;
+declare const registryIndexSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+  title: z.ZodString;
+  version: z.ZodString;
+  description: z.ZodString;
+  tags: z.ZodArray<z.ZodString>;
+  author: z.ZodOptional<z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    url: z.ZodOptional<z.ZodURL>;
+  }, z.core.$strict>>;
+  license: z.ZodOptional<z.ZodString>;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  installMessage: z.ZodOptional<z.ZodString>;
+  platform: z.ZodEnum<{
+    opencode: "opencode";
+    codex: "codex";
+    claude: "claude";
+    cursor: "cursor";
+  }>;
+  slug: z.ZodString;
+  name: z.ZodString;
+  bundlePath: z.ZodString;
+  fileCount: z.ZodNumber;
+  totalBytes: z.ZodNumber;
+}, z.core.$strip>>;
+
+//#endregion
+export { AuthorInfo, BundledFile, DiffPreviewOptions, FetchRegistryBundleResult, PLATFORM_IDS, PlatformId, PlatformSpecificConfig, PresetConfig, RegistryBundle, RegistryData, RegistryEntry, RegistryIndex, RegistryIndexItem, authorSchema, bundledFileSchema, cleanInstallMessage, collectBundledFiles, createDiffPreview, decodeBundledFile, decodeUtf8, definePreset, encodeItemName, encodeUtf8, fetchRegistryBundle, fetchRegistryIndex, isAbsoluteUrl, isLikelyText, isSupportedPlatform, maybeStripPrefix, normalizeBundlePath, normalizeBundlePublicBase, normalizePathFragment, normalizePlatformInput, platformIdSchema, platformPresetSchema, registryBundleSchema, registryEntrySchema, registryIndexSchema, resolveRegistryEntry, toPosixPath, toUint8Array, toUtf8String, validatePresetConfig, verifyBundledFileChecksum };

package/dist/index.js

@@ -0,0 +1,306 @@
+import { createTwoFilesPatch } from "diff";
+import { z } from "zod";
+
+//#region src/encoding.ts
+function toPosixPath(pathValue) {
+	return pathValue.split("\\").join("/");
+}
+function encodeUtf8(value) {
+	if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(value, "utf8"));
+	return new TextEncoder().encode(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);
+}
+function toUint8Array(payload) {
+	if (payload instanceof Uint8Array) return payload;
+	if (ArrayBuffer.isView(payload)) return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength);
+	return new Uint8Array(payload);
+}
+
+//#endregion
+//#region src/build-utils.ts
+function normalizeBundlePublicBase(value) {
+	const trimmed = value.trim();
+	if (!trimmed) throw new Error("--bundle-base must be a non-empty string");
+	if (isAbsoluteUrl(trimmed)) return trimmed.replace(/\/+$/, "");
+	let normalized = trimmed;
+	if (!normalized.startsWith("/")) normalized = `/${normalized}`;
+	normalized = normalized.replace(/\/+$/, "");
+	return normalized === "" ? "/" : normalized;
+}
+function isAbsoluteUrl(value) {
+	return /^[a-zA-Z][a-zA-Z\d+-.]*:/.test(value);
+}
+function cleanInstallMessage(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function encodeItemName(slug, platform) {
+	return `${slug}.${platform}`;
+}
+function validatePresetConfig(config, slug) {
+	if (!config || typeof config !== "object") throw new Error(`Invalid preset config export for ${slug}`);
+	const preset = config;
+	if (!preset.title || typeof preset.title !== "string") throw new Error(`Preset ${slug} is missing a title`);
+	if (!preset.version || typeof preset.version !== "string") throw new Error(`Preset ${slug} is missing a version`);
+	if (!preset.description || typeof preset.description !== "string") throw new Error(`Preset ${slug} is missing a description`);
+	if (!preset.platforms || typeof preset.platforms !== "object") throw new Error(`Preset ${slug} is missing platforms map`);
+	return preset;
+}
+function collectBundledFiles(files) {
+	return Object.entries(files).map(([path, contents]) => {
+		const normalizedPath = toPosixPath(path);
+		const payload = encodeUtf8(contents);
+		return {
+			path: normalizedPath,
+			size: payload.length,
+			checksum: "",
+			encoding: "utf-8",
+			contents
+		};
+	}).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+//#endregion
+//#region src/bundle.ts
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_LOOKUP = Object.fromEntries(Array.from(BASE64_ALPHABET).map((char, index) => [char, index]));
+function decodeBundledFile(file) {
+	if (file.encoding === "utf-8") return encodeUtf8(file.contents);
+	if (file.encoding === "base64") return decodeBase64(file.contents);
+	throw new Error(`Unsupported encoding "${file.encoding}" for ${file.path}.`);
+}
+async function verifyBundledFileChecksum(file, payload) {
+	const bytes = toUint8Array(payload);
+	const computed = await sha256Hex(bytes);
+	if (computed !== file.checksum) throw new Error(`Checksum mismatch for ${file.path}. Expected ${file.checksum}, received ${computed}.`);
+}
+function isLikelyText(payload) {
+	const bytes = toUint8Array(payload);
+	const sample = bytes.subarray(0, Math.min(bytes.length, 128));
+	for (const byte of sample) {
+		if (byte === 0) return false;
+		if (byte < 9) return false;
+		if (byte > 13 && byte < 32) return false;
+	}
+	return true;
+}
+function toUtf8String(payload) {
+	return decodeUtf8(payload);
+}
+function decodeBase64(input) {
+	const sanitized = input.replace(/[^A-Za-z0-9+/=]/g, "");
+	if (sanitized.length % 4 !== 0) throw new Error("Invalid base64 payload length.");
+	let outputLength = sanitized.length / 4 * 3;
+	if (sanitized.endsWith("==")) outputLength -= 2;
+	else if (sanitized.endsWith("=")) outputLength -= 1;
+	const bytes = new Uint8Array(outputLength);
+	let byteIndex = 0;
+	for (let i = 0; i < sanitized.length; i += 4) {
+		const chunk = sanitized.slice(i, i + 4);
+		const enc1 = decodeBase64Char(chunk[0]);
+		const enc2 = decodeBase64Char(chunk[1]);
+		const enc3 = chunk[2] === "=" ? 0 : decodeBase64Char(chunk[2]);
+		const enc4 = chunk[3] === "=" ? 0 : decodeBase64Char(chunk[3]);
+		const combined = enc1 * 262144 + enc2 * 4096 + enc3 * 64 + enc4;
+		bytes[byteIndex] = Math.floor(combined / 65536) % 256;
+		byteIndex += 1;
+		if (chunk[2] !== "=") {
+			bytes[byteIndex] = Math.floor(combined / 256) % 256;
+			byteIndex += 1;
+		}
+		if (chunk[3] !== "=") {
+			bytes[byteIndex] = combined % 256;
+			byteIndex += 1;
+		}
+	}
+	return bytes;
+}
+function decodeBase64Char(char) {
+	const value = BASE64_LOOKUP[char];
+	if (value === void 0) throw new Error(`Invalid base64 character "${char}".`);
+	return value;
+}
+async function sha256Hex(payload) {
+	const crypto = globalThis.crypto;
+	if (!crypto?.subtle) throw new Error("SHA-256 hashing requires Web Crypto API support.");
+	const digest = await crypto.subtle.digest("SHA-256", payload);
+	return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+//#region src/diff.ts
+const DEFAULT_CONTEXT = 2;
+const DEFAULT_MAX_LINES = 40;
+function createDiffPreview(path, currentText, incomingText, options = {}) {
+	const patch = createTwoFilesPatch(`${path} (current)`, `${path} (incoming)`, currentText, incomingText, void 0, void 0, { context: options.context ?? DEFAULT_CONTEXT });
+	const lines = patch.trim().split("\n");
+	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+	const limited = lines.slice(0, maxLines);
+	if (lines.length > maxLines) limited.push("...");
+	return limited.join("\n");
+}
+
+//#endregion
+//#region src/paths.ts
+function normalizeBundlePath(value) {
+	return value.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/^\/+/, "");
+}
+function normalizePathFragment(value) {
+	if (!value) return;
+	const normalized = value.replace(/\\/g, "/").replace(/^\/+/, "");
+	return normalized.replace(/\/+$/, "");
+}
+function maybeStripPrefix(pathInput, prefix) {
+	if (!prefix) return pathInput;
+	if (pathInput === prefix) return "";
+	if (pathInput.startsWith(`${prefix}/`)) return pathInput.slice(prefix.length + 1);
+	return pathInput;
+}
+
+//#endregion
+//#region src/platform.ts
+const PLATFORM_IDS = [
+	"opencode",
+	"codex",
+	"claude",
+	"cursor"
+];
+function isSupportedPlatform(value) {
+	return PLATFORM_IDS.includes(value);
+}
+function normalizePlatformInput(value) {
+	const normalized = value.toLowerCase();
+	if (isSupportedPlatform(normalized)) return normalized;
+	throw new Error(`Unknown platform "${value}". Supported platforms: ${PLATFORM_IDS.join(", ")}.`);
+}
+
+//#endregion
+//#region src/preset.ts
+function definePreset(config) {
+	return config;
+}
+
+//#endregion
+//#region src/registry.ts
+async function fetchRegistryIndex(baseUrl) {
+	const indexUrl = new URL("registry.index.json", baseUrl);
+	const response = await fetch(indexUrl);
+	if (!response.ok) throw new Error(`Failed to load registry index (${response.status} ${response.statusText}).`);
+	try {
+		return await response.json();
+	} catch (error) {
+		throw new Error(`Unable to parse registry index JSON: ${error.message}`);
+	}
+}
+async function fetchRegistryBundle(baseUrl, bundlePath) {
+	const bundleUrl = new URL(bundlePath, baseUrl);
+	const response = await fetch(bundleUrl);
+	if (!response.ok) throw new Error(`Failed to download bundle (${response.status} ${response.statusText}).`);
+	try {
+		const bundle = await response.json();
+		return {
+			bundle,
+			etag: response.headers.get("etag")
+		};
+	} catch (error) {
+		throw new Error(`Unable to parse bundle JSON: ${error.message}`);
+	}
+}
+function resolveRegistryEntry(index, input, explicitPlatform) {
+	const map = new Map();
+	for (const [key, value] of Object.entries(index)) map.set(key.toLowerCase(), value);
+	const normalizedInput = input.toLowerCase();
+	const direct = map.get(normalizedInput);
+	if (direct) return direct;
+	let slugHint = normalizedInput;
+	let platform = explicitPlatform;
+	if (!platform) {
+		const parts = normalizedInput.split(".");
+		const maybePlatform = parts.at(-1);
+		if (maybePlatform && PLATFORM_IDS.includes(maybePlatform)) {
+			platform = maybePlatform;
+			slugHint = parts.slice(0, -1).join(".");
+		}
+	}
+	const matches = Object.values(index).filter((entry) => entry.slug.toLowerCase() === slugHint);
+	if (platform) {
+		const match = matches.find((entry) => entry.platform === platform);
+		if (match) return match;
+		throw new Error(`Preset "${input}" is not available for platform "${platform}".`);
+	}
+	if (matches.length === 1) return matches[0];
+	if (matches.length > 1) {
+		const platforms = matches.map((entry) => entry.platform).join(", ");
+		throw new Error(`Preset "${input}" is available for multiple platforms (${platforms}). Use --platform to pick one or specify <slug>.<platform>.`);
+	}
+	throw new Error(`Preset "${input}" was not found in the active registry.`);
+}
+
+//#endregion
+//#region src/schema.ts
+const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const platformIdSchema = z.enum([
+	"opencode",
+	"codex",
+	"claude",
+	"cursor"
+]);
+const authorSchema = z.object({
+	name: z.string().trim().min(1),
+	email: z.email().trim().optional(),
+	url: z.url().trim().optional()
+}).strict();
+const titleSchema = z.string().trim().min(1).max(120);
+const descriptionSchema = z.string().trim().min(1).max(500);
+const versionSchema = z.string().trim().regex(SEMVER_REGEX, "Version must follow semantic versioning");
+const tagSchema = z.string().trim().min(1).max(48);
+const tagsSchema = z.array(tagSchema).max(10);
+const featureSchema = z.string().trim().min(1).max(160);
+const featuresSchema = z.array(featureSchema).max(10);
+const installMessageSchema = z.string().trim().max(4e3);
+const licenseSchema = z.string().trim().max(80);
+const platformPresetSchema = z.object({
+	title: titleSchema,
+	version: versionSchema,
+	description: descriptionSchema,
+	tags: tagsSchema.optional(),
+	author: authorSchema.optional(),
+	license: licenseSchema.optional(),
+	features: featuresSchema.optional(),
+	installMessage: installMessageSchema.optional()
+}).strict();
+const bundledFileSchema = z.object({
+	path: z.string().min(1),
+	size: z.number().int().nonnegative(),
+	checksum: z.string().length(64),
+	encoding: z.union([z.literal("utf-8"), z.literal("base64")]),
+	contents: z.string()
+});
+const registryBundleSchema = z.object({
+	slug: z.string().trim().min(1),
+	platform: platformIdSchema,
+	title: titleSchema,
+	version: versionSchema,
+	description: descriptionSchema,
+	tags: tagsSchema,
+	author: authorSchema.optional(),
+	license: licenseSchema.optional(),
+	features: featuresSchema.optional(),
+	installMessage: installMessageSchema.optional(),
+	files: z.array(bundledFileSchema).min(1)
+});
+const registryEntrySchema = registryBundleSchema.omit({ files: true }).extend({
+	name: z.string().trim().min(1),
+	bundlePath: z.string().trim().min(1),
+	fileCount: z.number().int().nonnegative(),
+	totalBytes: z.number().int().nonnegative()
+});
+const registryIndexSchema = z.record(z.string(), registryEntrySchema);
+
+//#endregion
+export { PLATFORM_IDS, authorSchema, bundledFileSchema, cleanInstallMessage, collectBundledFiles, createDiffPreview, decodeBundledFile, decodeUtf8, definePreset, encodeItemName, encodeUtf8, fetchRegistryBundle, fetchRegistryIndex, isAbsoluteUrl, isLikelyText, isSupportedPlatform, maybeStripPrefix, normalizeBundlePath, normalizeBundlePublicBase, normalizePathFragment, normalizePlatformInput, platformIdSchema, platformPresetSchema, registryBundleSchema, registryEntrySchema, registryIndexSchema, resolveRegistryEntry, toPosixPath, toUint8Array, toUtf8String, validatePresetConfig, verifyBundledFileChecksum };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@agentrules/core",
+  "version": "0.0.1",
+  "author": "Brian Cheung <bcheung.dev@gmail.com> (https://github.com/bcheung)",
+  "license": "MIT",
+  "homepage": "https://docs.agentrules.directory",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentrules-sh/agentrules",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/agentrules-sh/agentrules/issues"
+  },
+  "keywords": [
+    "agentrules",
+    "agents",
+    "agentic",
+    "coding",
+    "development"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "diff": "^8.0.2",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "tsdown": "^0.9.0",
+    "typescript": "5.7.2"
+  }
+}