@ucdjs/schemas 0.1.1-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Lucas Nørgård
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @ucdjs/schemas
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![codecov][codecov-src]][codecov-href]
+
+This package provides schemas for different UCDJS components, including Api Responses, Environment Variables, and more.
+
+## Installation
+
+```bash
+npm install @ucdjs/schemas
+```
+
+## 📄 License
+
+Published under [MIT License](./LICENSE).
+
+[npm-version-src]: https://img.shields.io/npm/v/@ucdjs/schemas?style=flat&colorA=18181B&colorB=4169E1
+[npm-version-href]: https://npmjs.com/package/@ucdjs/schemas
+[npm-downloads-src]: https://img.shields.io/npm/dm/@ucdjs/schemas?style=flat&colorA=18181B&colorB=4169E1
+[npm-downloads-href]: https://npmjs.com/package/@ucdjs/schemas
+[codecov-src]: https://img.shields.io/codecov/c/gh/ucdjs/ucd?style=flat&colorA=18181B&colorB=4169E1
+[codecov-href]: https://codecov.io/gh/ucdjs/ucd

package/dist/index.d.mts

@@ -0,0 +1,189 @@
+import { z } from "zod";
+
+//#region src/api.d.ts
+declare const ApiErrorSchema: z.ZodObject<{
+  message: z.ZodString;
+  status: z.ZodNumber;
+  timestamp: z.ZodString;
+}, z.core.$strip>;
+type ApiError = z.infer<typeof ApiErrorSchema>;
+/**
+ * Schema for .well-known/ucd-config.json endpoint configuration
+ */
+declare const UCDWellKnownConfigSchema: z.ZodObject<{
+  version: z.ZodDefault<z.ZodString>;
+  endpoints: z.ZodObject<{
+    files: z.ZodString;
+    manifest: z.ZodString;
+    versions: z.ZodString;
+  }, z.core.$strip>;
+  versions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type UCDWellKnownConfig = z.infer<typeof UCDWellKnownConfigSchema>;
+//#endregion
+//#region src/fs.d.ts
+declare const UCDStoreManifestSchema: z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodObject<{
+  expectedFiles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>>;
+type UCDStoreManifest = z.output<typeof UCDStoreManifestSchema>;
+declare const FileEntrySchema: z.ZodUnion<readonly [z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  lastModified: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+  type: z.ZodLiteral<"directory">;
+}, z.core.$strip>, z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  lastModified: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+  type: z.ZodLiteral<"file">;
+}, z.core.$strip>]>;
+type FileEntry = z.infer<typeof FileEntrySchema>;
+declare const FileEntryListSchema: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  lastModified: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+  type: z.ZodLiteral<"directory">;
+}, z.core.$strip>, z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  lastModified: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+  type: z.ZodLiteral<"file">;
+}, z.core.$strip>]>>;
+type FileEntryList = z.infer<typeof FileEntryListSchema>;
+//#endregion
+//#region src/lockfile.d.ts
+/**
+ * Schema for the lockfile structure
+ */
+declare const LockfileSchema: z.ZodObject<{
+  lockfileVersion: z.ZodLiteral<1>;
+  createdAt: z.ZodCoercedDate<unknown>;
+  updatedAt: z.ZodCoercedDate<unknown>;
+  versions: z.ZodRecord<z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    fileCount: z.ZodInt;
+    totalSize: z.ZodInt;
+    createdAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+  }, z.core.$strip>>;
+  filters: z.ZodOptional<z.ZodObject<{
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disableDefaultExclusions: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type Lockfile = z.output<typeof LockfileSchema>;
+type LockfileInput = z.input<typeof LockfileSchema>;
+/**
+ * Schema for a version snapshot
+ */
+declare const SnapshotSchema: z.ZodObject<{
+  unicodeVersion: z.ZodString;
+  files: z.ZodRecord<z.ZodString, z.ZodObject<{
+    hash: z.ZodString;
+    fileHash: z.ZodString;
+    size: z.ZodInt;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type Snapshot = z.output<typeof SnapshotSchema>;
+//#endregion
+//#region src/manifest.d.ts
+/**
+ * Schema for a single expected file in the manifest.
+ * Provides multiple path formats for different use cases.
+ */
+declare const ExpectedFileSchema: z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  storePath: z.ZodString;
+}, z.core.$strip>;
+type ExpectedFile = z.infer<typeof ExpectedFileSchema>;
+declare const UCDStoreVersionManifestSchema: z.ZodObject<{
+  expectedFiles: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    storePath: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type UCDStoreVersionManifest = z.infer<typeof UCDStoreVersionManifestSchema>;
+//#endregion
+//#region src/types.d.ts
+type DeepOmit<T, K extends PropertyKey> = T extends object ? T extends any[] ? DeepOmit<T[number], K>[] : { [P in Exclude<keyof T, K>]: DeepOmit<T[P], K> } : T;
+//#endregion
+//#region src/unicode.d.ts
+declare const UnicodeVersionSchema: z.ZodObject<{
+  version: z.ZodString;
+  documentationUrl: z.ZodURL;
+  date: z.ZodNullable<z.ZodString>;
+  url: z.ZodURL;
+  mappedUcdVersion: z.ZodNullable<z.ZodString>;
+  type: z.ZodEnum<{
+    draft: "draft";
+    stable: "stable";
+    unsupported: "unsupported";
+  }>;
+}, z.core.$strip>;
+type UnicodeVersion = z.output<typeof UnicodeVersionSchema>;
+declare const UnicodeVersionListSchema: z.ZodArray<z.ZodObject<{
+  version: z.ZodString;
+  documentationUrl: z.ZodURL;
+  date: z.ZodNullable<z.ZodString>;
+  url: z.ZodURL;
+  mappedUcdVersion: z.ZodNullable<z.ZodString>;
+  type: z.ZodEnum<{
+    draft: "draft";
+    stable: "stable";
+    unsupported: "unsupported";
+  }>;
+}, z.core.$strip>>;
+type UnicodeVersionList = z.output<typeof UnicodeVersionListSchema>;
+declare const UnicodeVersionDetailsSchema: z.ZodObject<{
+  version: z.ZodString;
+  documentationUrl: z.ZodURL;
+  date: z.ZodNullable<z.ZodString>;
+  url: z.ZodURL;
+  mappedUcdVersion: z.ZodNullable<z.ZodString>;
+  type: z.ZodEnum<{
+    draft: "draft";
+    stable: "stable";
+    unsupported: "unsupported";
+  }>;
+  statistics: z.ZodDefault<z.ZodObject<{
+    totalCharacters: z.ZodInt;
+    newCharacters: z.ZodInt;
+    totalBlocks: z.ZodInt;
+    newBlocks: z.ZodInt;
+    totalScripts: z.ZodInt;
+    newScripts: z.ZodInt;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type UnicodeVersionDetails = z.output<typeof UnicodeVersionDetailsSchema>;
+declare const UnicodeFileTreeNodeSchema: z.ZodUnion<readonly [z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  lastModified: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+  type: z.ZodLiteral<"directory">;
+  readonly children: z.ZodArray<typeof UnicodeFileTreeNodeSchema>;
+}, z.core.$strip>, z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  lastModified: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+  type: z.ZodLiteral<"file">;
+}, z.core.$strip>]>;
+type UnicodeFileTreeNode = z.infer<typeof UnicodeFileTreeNodeSchema>;
+type UnicodeFileTreeNodeWithoutLastModified = DeepOmit<UnicodeFileTreeNode, "lastModified">;
+declare const UnicodeFileTreeSchema: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  lastModified: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+  type: z.ZodLiteral<"directory">;
+  readonly children: z.ZodArray<typeof UnicodeFileTreeNodeSchema>;
+}, z.core.$strip>, z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  lastModified: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
+  type: z.ZodLiteral<"file">;
+}, z.core.$strip>]>>;
+type UnicodeFileTree = z.infer<typeof UnicodeFileTreeSchema>;
+//#endregion
+export { type ApiError, ApiErrorSchema, type ExpectedFile, ExpectedFileSchema, type FileEntry, type FileEntryList, FileEntryListSchema, FileEntrySchema, type Lockfile, type LockfileInput, LockfileSchema, type Snapshot, SnapshotSchema, type UCDStoreManifest, UCDStoreManifestSchema, type UCDStoreVersionManifest, UCDStoreVersionManifestSchema, type UCDWellKnownConfig, UCDWellKnownConfigSchema, type UnicodeFileTree, type UnicodeFileTreeNode, UnicodeFileTreeNodeSchema, type UnicodeFileTreeNodeWithoutLastModified, UnicodeFileTreeSchema, type UnicodeVersion, type UnicodeVersionDetails, UnicodeVersionDetailsSchema, type UnicodeVersionList, UnicodeVersionListSchema, UnicodeVersionSchema };

package/dist/index.mjs

@@ -0,0 +1,262 @@
+import { dedent } from "@luxass/utils";
+import { z } from "zod";
+
+//#region src/api.ts
+const ApiErrorSchema = z.object({
+	message: z.string().meta({ description: "Human-readable error message describing what went wrong" }),
+	status: z.number().meta({ description: "HTTP status code matching the response status" }),
+	timestamp: z.string().meta({ description: "ISO 8601 timestamp when the error occurred" })
+}).meta({ description: dedent`
+    Standard error response format used consistently across all API endpoints.
+
+    Contains essential information for debugging and user feedback. The specific error scenarios and status codes are documented in the individual endpoint response definitions.
+  ` });
+/**
+* Schema for .well-known/ucd-config.json endpoint configuration
+*/
+const UCDWellKnownConfigSchema = z.object({
+	version: z.string().default("1.0"),
+	endpoints: z.object({
+		files: z.string(),
+		manifest: z.string(),
+		versions: z.string()
+	}),
+	versions: z.array(z.string()).default([])
+}).meta({
+	id: "UCDWellKnownConfig",
+	description: dedent`
+    Configuration schema for the .well-known/ucd-config.json endpoint.
+
+    This configuration provides clients with the necessary information to interact with the UCD API server, including endpoint paths and optional metadata about the server itself.
+
+    The \`manifest\` endpoint is deprecated. Use the per-version endpoint \`/.well-known/ucd-store/{version}.json\` instead for better performance and caching.
+  `
+});
+
+//#endregion
+//#region src/fs.ts
+const UCDStoreManifestSchema = z.record(z.string(), z.object({ expectedFiles: z.array(z.string()).default([]) }).default({ expectedFiles: [] })).meta({
+	id: "UCDStoreManifest",
+	description: dedent`
+    A record of per-version metadata for the UCD store.
+    Each key is the version string, and the value is an object holding metadata.
+
+    Fields:
+    - expectedFiles: string[] (defaults to [])
+
+    ## Example
+    \`\`\`json
+    {
+      "15.1.0": { "expectedFiles": ["UnicodeData.txt", "PropList.txt"] },
+      "14.0.0": { "expectedFiles": [] }
+    }
+    \`\`\`
+
+    The path is relative to the root of the UCD Api Server, typically \`https://api.ucdjs.dev/api/v1/files\`. E.g. \`15.1.0\` would resolve to \`https://api.ucdjs.dev/api/v1/files/15.1.0\`.
+  `
+});
+const FileEntryBaseSchema = z.object({
+	name: z.string(),
+	path: z.string(),
+	lastModified: z.number().or(z.null())
+});
+const FileEntryDirectorySchema = FileEntryBaseSchema.extend({ type: z.literal("directory") });
+const FileEntryFileSchema = FileEntryBaseSchema.extend({ type: z.literal("file") });
+const FileEntrySchema = z.union([FileEntryDirectorySchema, FileEntryFileSchema]).meta({
+	id: "FileEntry",
+	description: dedent`
+    Response schema for a file entry in the UCD store.
+
+    This schema represents either a directory listing or a file response.
+  `
+}).superRefine((data, ctx) => {
+	if (data.type === "directory" && !data.path.endsWith("/")) ctx.addIssue({
+		code: "custom",
+		message: "Directory paths must end with a trailing slash ('/')."
+	});
+	if (!data.path.startsWith("/")) ctx.addIssue({
+		code: "custom",
+		message: "Paths must start with a leading slash ('/')."
+	});
+});
+const FileEntryListSchema = z.array(FileEntrySchema).meta({
+	id: "FileEntryList",
+	description: "An array of file entries, each representing either a file or a directory."
+});
+
+//#endregion
+//#region src/lockfile.ts
+/**
+* Schema for ISO 8601 date strings that coerces to Date objects.
+* Accepts ISO date strings, numbers (timestamps), or Date objects as input.
+* Always outputs a Date object after parsing.
+*/
+const DateSchema = z.coerce.date();
+/**
+* Schema for a single version entry in the lockfile
+*/
+const LockfileVersionEntrySchema = z.object({
+	path: z.string(),
+	fileCount: z.int().nonnegative(),
+	totalSize: z.int().nonnegative(),
+	createdAt: DateSchema,
+	updatedAt: DateSchema
+});
+/**
+* Schema for filters applied when creating/updating the lockfile.
+*/
+const LockfileFiltersSchema = z.object({
+	include: z.array(z.string()).optional(),
+	exclude: z.array(z.string()).optional(),
+	disableDefaultExclusions: z.boolean().optional()
+});
+/**
+* Schema for the lockfile structure
+*/
+const LockfileSchema = z.object({
+	lockfileVersion: z.literal(1),
+	createdAt: DateSchema,
+	updatedAt: DateSchema,
+	versions: z.record(z.string(), LockfileVersionEntrySchema),
+	filters: LockfileFiltersSchema.optional()
+});
+/**
+* Schema for a single file entry in a snapshot
+*/
+const SnapshotFileEntrySchema = z.object({
+	hash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+	fileHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+	size: z.int().nonnegative()
+});
+/**
+* Schema for a version snapshot
+*/
+const SnapshotSchema = z.object({
+	unicodeVersion: z.string(),
+	files: z.record(z.string(), SnapshotFileEntrySchema)
+});
+
+//#endregion
+//#region src/manifest.ts
+/**
+* Schema for a single expected file in the manifest.
+* Provides multiple path formats for different use cases.
+*/
+const ExpectedFileSchema = z.object({
+	name: z.string().meta({ description: "Filename only" }),
+	path: z.string().meta({ description: "Path relative to /api/v1/files endpoint (includes /ucd/ for versions >= 4.1.0)" }),
+	storePath: z.string().meta({ description: "Path for store subdomain (without /ucd/ prefix)" })
+}).meta({
+	id: "ExpectedFile",
+	description: "A file expected to be present in a UCD version"
+});
+const UCDStoreVersionManifestSchema = z.object({ expectedFiles: z.array(ExpectedFileSchema).meta({ description: "List of expected files for this version with their paths" }) }).meta({
+	id: "UCDStoreVersionManifest",
+	description: dedent`
+    Response schema for per-version manifest endpoint.
+    Matches the schema from /.well-known/ucd-store/{version}.json
+  `
+});
+
+//#endregion
+//#region src/unicode.ts
+const UnicodeVersionSchema = z.object({
+	version: z.string().meta({ description: "The version of the Unicode standard." }),
+	documentationUrl: z.url().meta({ description: "The URL to the Unicode version documentation." }),
+	date: z.string().regex(/^\d{4}$/, "Year must be a four-digit number").meta({ description: "The year of the Unicode version." }).nullable(),
+	url: z.url().meta({ description: "The URL to the Unicode Character Database (UCD) for this version." }),
+	mappedUcdVersion: z.string().nullable().meta({ description: "The corresponding UCD version mapping for this Unicode version. Null if same as version." }),
+	type: z.enum([
+		"draft",
+		"stable",
+		"unsupported"
+	]).meta({ description: "The status of the Unicode version. 'unsupported' means the version exists but is not yet supported by the API." })
+}).meta({
+	id: "UnicodeVersion",
+	description: "Represents a Unicode version with its metadata and support status.",
+	examples: [
+		{
+			version: "17.0.0",
+			documentationUrl: "https://www.unicode.org/versions/Unicode17.0.0/",
+			date: null,
+			url: "https://www.unicode.org/Public/17.0.0",
+			mappedUcdVersion: null,
+			type: "draft"
+		},
+		{
+			version: "16.0.0",
+			documentationUrl: "https://www.unicode.org/versions/Unicode16.0.0/",
+			date: "2024",
+			url: "https://www.unicode.org/Public/16.0.0",
+			mappedUcdVersion: null,
+			type: "stable"
+		},
+		{
+			version: "15.1.0",
+			documentationUrl: "https://www.unicode.org/versions/Unicode15.1.0/",
+			date: "2023",
+			url: "https://www.unicode.org/Public/15.1.0",
+			mappedUcdVersion: null,
+			type: "stable"
+		}
+	]
+});
+const UnicodeVersionListSchema = z.array(UnicodeVersionSchema).meta({
+	id: "UnicodeVersionList",
+	description: "A list of Unicode versions with their metadata and support status."
+});
+const UnicodeVersionDetailsSchema = UnicodeVersionSchema.extend({ statistics: z.object({
+	totalCharacters: z.int().nonnegative().meta({ description: "Total number of characters in this Unicode version." }),
+	newCharacters: z.int().nonnegative().meta({ description: "Number of new characters added in this version." }),
+	totalBlocks: z.int().nonnegative().meta({ description: "Total number of blocks in this Unicode version." }),
+	newBlocks: z.int().nonnegative().meta({ description: "Number of new blocks added in this version." }),
+	totalScripts: z.int().nonnegative().meta({ description: "Total number of scripts in this Unicode version." }),
+	newScripts: z.int().nonnegative().meta({ description: "Number of new scripts added in this version." })
+}).default({
+	newBlocks: 0,
+	newCharacters: 0,
+	newScripts: 0,
+	totalBlocks: 0,
+	totalCharacters: 0,
+	totalScripts: 0
+}).meta({ description: "Statistics about this Unicode version. May be null if statistics are not available." }) }).meta({
+	id: "UnicodeVersionDetails",
+	description: "Detailed information about a Unicode version, including metadata and statistics.",
+	examples: [{
+		version: "16.0.0",
+		documentationUrl: "https://www.unicode.org/versions/Unicode16.0.0/",
+		date: "2024",
+		url: "https://www.unicode.org/Public/16.0.0",
+		mappedUcdVersion: null,
+		type: "stable",
+		statistics: {
+			totalCharacters: 149813,
+			newCharacters: 5185,
+			totalBlocks: 331,
+			newBlocks: 4,
+			totalScripts: 165,
+			newScripts: 2
+		}
+	}]
+});
+const UnicodeFileTreeFileSchema = FileEntryFileSchema.meta({
+	id: "UnicodeFileTreeFile",
+	description: "A file node in the Unicode file tree."
+});
+const UnicodeFileTreeDirectorySchema = FileEntryDirectorySchema.extend({ get children() {
+	return z.array(UnicodeFileTreeNodeSchema);
+} }).meta({
+	id: "UnicodeFileTreeDirectory",
+	description: "A directory node in the Unicode file tree, containing child nodes."
+});
+const UnicodeFileTreeNodeSchema = z.union([UnicodeFileTreeDirectorySchema, UnicodeFileTreeFileSchema]).meta({
+	id: "UnicodeFileTreeNode",
+	description: "A recursive file tree node; directories include children, files do not."
+});
+const UnicodeFileTreeSchema = z.array(UnicodeFileTreeNodeSchema).meta({
+	id: "UnicodeFileTree",
+	description: "A recursive file tree structure rooted at an array of entries."
+});
+
+//#endregion
+export { ApiErrorSchema, ExpectedFileSchema, FileEntryListSchema, FileEntrySchema, LockfileSchema, SnapshotSchema, UCDStoreManifestSchema, UCDStoreVersionManifestSchema, UCDWellKnownConfigSchema, UnicodeFileTreeNodeSchema, UnicodeFileTreeSchema, UnicodeVersionDetailsSchema, UnicodeVersionListSchema, UnicodeVersionSchema };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@ucdjs/schemas",
+  "version": "0.1.1-beta.1",
+  "type": "module",
+  "author": {
+    "name": "Lucas Nørgård",
+    "email": "lucasnrgaard@gmail.com",
+    "url": "https://luxass.dev"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/ucdjs/ucd",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ucdjs/ucd.git",
+    "directory": "packages/schemas"
+  },
+  "bugs": {
+    "url": "https://github.com/ucdjs/ucd/issues"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.18"
+  },
+  "dependencies": {
+    "@luxass/utils": "2.7.3",
+    "zod": "4.3.6"
+  },
+  "devDependencies": {
+    "@luxass/eslint-config": "7.2.0",
+    "eslint": "10.0.0",
+    "publint": "0.3.17",
+    "tsdown": "0.20.3",
+    "typescript": "5.9.3",
+    "@ucdjs-tooling/tsconfig": "1.0.0",
+    "@ucdjs-tooling/tsdown-config": "1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown --tsconfig=./tsconfig.build.json",
+    "dev": "tsdown --watch",
+    "clean": "git clean -xdf dist node_modules",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit -p tsconfig.build.json"
+  }
+}