@lvl99dotcom/paintcanvas 0.6.0 → 0.8.0

package/README.md

@@ -89,9 +89,9 @@ The demo is published at https://lvl99.github.io/paintcanvas/app/. To run it loc
 pnpm dev
 ```
 
-Starts a development server and opens the demo in your browser. It uses the source directly, so saving a change to `src/`, `demo/` or `locales/` reloads the page with the change straight away. (The whole page reloads because custom elements can't be redefined in a running page, so the drawing starts again.)
+Starts a development server and opens the demo in your browser. It uses the source directly, so saving a change to `src/`, `demo/` or `locales/` reloads the page with the change straight away. (The whole page reloads because custom elements can't be redefined in a running page, so the drawing starts again.) It uses vite.demo.config.ts, which also gives the demo the commit it was built from (see scripts/build-info.ts).
 
-- http://localhost:5190/: a full-page PaintCanvas with a layers panel, the colour palette (from the colours at the top of the toolbar), a menu with input settings, keyboard shortcuts, settings import and export, a theme picker (light, dark or system) and a "New drawing" button. The drawing and the settings, including the theme and language, are kept in the browser, so they survive reloads. Below 600px wide, the toolbar and the layers rail sit over the canvas.
+- http://localhost:5190/: a full-page PaintCanvas with a layers panel, the colour palette (from the colours at the top of the toolbar), a menu with PaintCanvas's version, input settings, a "Draw with the GPU" switch, keyboard shortcuts, settings import and export, a theme picker (light, dark or system) and a "New drawing" button. The drawing and the settings, including the theme, language and rendering (CPU or GPU), are kept in the browser, so they survive reloads. Below 600px wide, the toolbar and the layers rail sit over the canvas.
 - http://localhost:5190/elements.html: the base elements.
 
 To try it with a pen or touch on another device (e.g. a tablet) on the same network, run `pnpm dev --host` and open the network address it prints. This makes the server reachable by anyone on that network.
@@ -130,6 +130,7 @@ Tests sit in a `tests` folder beside the code. Unit tests (`*.test.ts`) run in j
 | `pnpm coverage`         | Runs both, with a coverage report in `coverage/`                                    |
 | `pnpm build`            | Builds the package into `dist/`: ES modules matching `src/`, with types             |
 | `pnpm build:validators` | Regenerates the validators after changing the preset, message or document schemas   |
+| `pnpm build:schemas`    | Writes new versions of the published JSON schemas into `schemas/`                   |
 | `pnpm icons:build`      | Optimises the icons' SVGs and makes their PNGs (`pnpm build` and `pnpm dev` run it) |
 | `pnpm dev`              | Starts the demo, reloading it when files change (`pnpm demo` does the same)         |
 | `pnpm docs`             | Starts the documentation site (`pnpm docs:build` builds it into `docs/build/`)      |

package/dist/lib/assets/index.d.ts

@@ -0,0 +1,92 @@
+import type { Validator } from "../validation/validators.generated.js";
+import type { AssetCollectionFile } from "./schema";
+export * from "./schema";
+/** Why reading or writing an asset file failed */
+export type AssetFileErrorReason = 
+/** The file couldn't be read, or isn't JSON */
+"read"
+/** The file isn't this kind of file, or doesn't match its schema */
+ | "invalid"
+/** The file is a version the app can't read */
+ | "unsupported"
+/** There's nothing to export */
+ | "empty";
+/** Reading or writing an asset file failed, for a reason the user can be told */
+export declare class AssetFileError extends Error {
+    readonly reason: AssetFileErrorReason;
+    constructor(reason: AssetFileErrorReason);
+}
+/** Turns a file of an older version into the next version */
+export interface AssetFileMigration {
+    /** Version it migrates from: a schema version, or one named by `legacyVersion` */
+    from: string;
+    /** Version it migrates to */
+    to: string;
+    /** The file's data in the newer version (its `$schema` and `@type` are set for you) */
+    migrate(data: Record<string, unknown>): Record<string, unknown>;
+}
+/** What an asset file is */
+export interface AssetFileConfig<T> {
+    /** Name of the collection's schema, e.g. `brush-preset-collection` */
+    schema: string;
+    /** Version of the collection's schema the app writes */
+    version: string;
+    /** The collection's `@type`, e.g. `PaintCanvas/BrushConfigCollection` */
+    type: string;
+    /** Checks a file of the current version */
+    validate: Validator<AssetCollectionFile<T>>;
+    /** Names exported files, e.g. `brush-presets` makes `paintcanvas-brush-presets-2026-11-11.json` */
+    fileName: string;
+    /** Migrations from older versions, applied one after another */
+    migrations?: readonly AssetFileMigration[];
+    /** The version of a file from before versioned schemas (e.g. `legacy-1`), or undefined if it isn't one */
+    legacyVersion?: (data: Record<string, unknown>) => string | undefined;
+}
+/**
+ * Reads and writes the collection files that users export and import assets of one kind in (e.g. brush presets),
+ * migrating files of older versions to the current one.
+ *
+ * @example
+ * const presets = brushPresetFile.parse(await file.text()); // throws AssetFileError
+ * const json = brushPresetFile.write(presets);
+ */
+export default class AssetFile<T> {
+    readonly config: AssetFileConfig<T>;
+    constructor(config: AssetFileConfig<T>);
+    /** URL of the schema of the files this writes */
+    get schemaUrl(): string;
+    /**
+     * The version of a file of this kind, or undefined if it isn't one.
+     *
+     * @example
+     * brushPresetFile.versionOf({ $schema: ".../brush-preset-collection-1.0.0.json" }); // "1.0.0"
+     */
+    versionOf(data: Record<string, unknown>): string | undefined;
+    /**
+     * The assets in a file's data, migrated from an older version if needed. Throws an `AssetFileError` if it isn't
+     * this kind of file, isn't valid, or is a version that can't be read.
+     */
+    read(data: unknown): T[];
+    /**
+     * The assets in a file's text. Throws an `AssetFileError` if it isn't JSON, or (see `read`) can't be read.
+     *
+     * @example
+     * brushPresetFile.parse('{ "$schema": "...", "@type": "PaintCanvas/BrushConfigCollection", "items": [] }'); // []
+     */
+    parse(text: string): T[];
+    /**
+     * Write assets to a file (JSON) of the current version. Throws an `AssetFileError` if there are none, or they don't
+     * match the schema.
+     *
+     * @example
+     * brushPresetFile.write([myPreset]); // '{ "$schema": "...", "@type": "PaintCanvas/BrushConfigCollection", "items": [...] }'
+     */
+    write(items: readonly T[]): string;
+    /**
+     * The name of a file exported on a day, starting with a prefix (see `PaintCanvasNames.filePrefix`).
+     *
+     * @example
+     * brushPresetFile.fileName(new Date(2026, 10, 11)); // "paintcanvas-brush-presets-2026-11-11.json"
+     */
+    fileName(date?: Date, prefix?: string): string;
+}

package/dist/lib/assets/index.js

@@ -0,0 +1,106 @@
+import { compareVersions, majorVersion, parseSchemaUrl, schemaUrl } from "../schemas/index.js";
+import { DID_PATTERN, MAX_AUTHOR_TEXT_LENGTH, MAX_URL_LENGTH, UUID_PATTERN, authorDetailsSchema, authorSchema, collectionSchema, fileSchemaUrlSchema } from "./schema.js";
+// src/lib/assets/index.ts
+/** Reading or writing an asset file failed, for a reason the user can be told */
+var AssetFileError = class extends Error {
+	reason;
+	constructor(reason) {
+		super(`Asset file error: ${reason}`);
+		this.reason = reason;
+	}
+};
+/** Whether a value is a plain object */
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Reads and writes the collection files that users export and import assets of one kind in (e.g. brush presets),
+* migrating files of older versions to the current one.
+*
+* @example
+* const presets = brushPresetFile.parse(await file.text()); // throws AssetFileError
+* const json = brushPresetFile.write(presets);
+*/
+var AssetFile = class {
+	config;
+	constructor(config) {
+		this.config = config;
+	}
+	/** URL of the schema of the files this writes */
+	get schemaUrl() {
+		return schemaUrl(this.config.schema, this.config.version);
+	}
+	/**
+	* The version of a file of this kind, or undefined if it isn't one.
+	*
+	* @example
+	* brushPresetFile.versionOf({ $schema: ".../brush-preset-collection-1.0.0.json" }); // "1.0.0"
+	*/
+	versionOf(data) {
+		const named = parseSchemaUrl(data.$schema);
+		if (named) return named.name === this.config.schema ? named.version : void 0;
+		return this.config.legacyVersion?.(data);
+	}
+	/**
+	* The assets in a file's data, migrated from an older version if needed. Throws an `AssetFileError` if it isn't
+	* this kind of file, isn't valid, or is a version that can't be read.
+	*/
+	read(data) {
+		if (!isRecord(data)) throw new AssetFileError("invalid");
+		let version = this.versionOf(data);
+		if (version === void 0) throw new AssetFileError("invalid");
+		const { migrations = [], type, validate } = this.config;
+		for (let migration = migrations.find((m) => m.from === version); migration; migration = migrations.find((m) => m.from === version)) {
+			data = {
+				...migration.migrate(data),
+				$schema: schemaUrl(this.config.schema, migration.to),
+				"@type": type
+			};
+			version = migration.to;
+		}
+		if (majorVersion(version) !== majorVersion(this.config.version) || compareVersions(version, this.config.version) > 0) throw new AssetFileError("unsupported");
+		if (!validate(data)) throw new AssetFileError("invalid");
+		return data.items;
+	}
+	/**
+	* The assets in a file's text. Throws an `AssetFileError` if it isn't JSON, or (see `read`) can't be read.
+	*
+	* @example
+	* brushPresetFile.parse('{ "$schema": "...", "@type": "PaintCanvas/BrushConfigCollection", "items": [] }'); // []
+	*/
+	parse(text) {
+		let data;
+		try {
+			data = JSON.parse(text);
+		} catch {
+			throw new AssetFileError("read");
+		}
+		return this.read(data);
+	}
+	/**
+	* Write assets to a file (JSON) of the current version. Throws an `AssetFileError` if there are none, or they don't
+	* match the schema.
+	*
+	* @example
+	* brushPresetFile.write([myPreset]); // '{ "$schema": "...", "@type": "PaintCanvas/BrushConfigCollection", "items": [...] }'
+	*/
+	write(items) {
+		if (items.length === 0) throw new AssetFileError("empty");
+		const file = {
+			$schema: this.schemaUrl,
+			"@type": this.config.type,
+			items
+		};
+		if (!this.config.validate(file)) throw new AssetFileError("invalid");
+		return JSON.stringify(file, null, 2);
+	}
+	/**
+	* The name of a file exported on a day, starting with a prefix (see `PaintCanvasNames.filePrefix`).
+	*
+	* @example
+	* brushPresetFile.fileName(new Date(2026, 10, 11)); // "paintcanvas-brush-presets-2026-11-11.json"
+	*/
+	fileName(date = /* @__PURE__ */ new Date(), prefix = "paintcanvas") {
+		const pad = (n) => String(n).padStart(2, "0");
+		return `${prefix}-${this.config.fileName}-${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}.json`;
+	}
+};
+export { AssetFileError, DID_PATTERN, MAX_AUTHOR_TEXT_LENGTH, MAX_URL_LENGTH, UUID_PATTERN, authorDetailsSchema, authorSchema, collectionSchema, AssetFile as default, fileSchemaUrlSchema };

package/dist/lib/assets/schema.d.ts

@@ -0,0 +1,151 @@
+/** Matches a lowercase UUID */
+export declare const UUID_PATTERN = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+/** Matches a decentralised identifier, e.g. `did:plc:abc123` */
+export declare const DID_PATTERN = "^did:[a-z]+:[a-zA-Z0-9._:%-]+$";
+/** Longest author name or handle (characters) */
+export declare const MAX_AUTHOR_TEXT_LENGTH = 100;
+/** Longest URL in an asset (characters) */
+export declare const MAX_URL_LENGTH = 2048;
+/** Who made an asset or document */
+export interface AssetAuthorDetails {
+    /** Their decentralised identifier, e.g. an ATProto account's `did:plc:…` */
+    did?: string;
+    /** Their name */
+    name: string;
+    /** Their handle or username, which tells their assets apart from others with the same name */
+    handle?: string;
+    /** Their email */
+    email?: string;
+    /** Their website */
+    homepage?: string;
+}
+/** Who made an asset: their name, or their details */
+export type AssetAuthor = string | AssetAuthorDetails;
+/** Schema of an author's details */
+export declare const authorDetailsSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["name"];
+    readonly properties: {
+        readonly did: {
+            readonly type: "string";
+            readonly maxLength: 2048;
+            readonly pattern: "^did:[a-z]+:[a-zA-Z0-9._:%-]+$";
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 100;
+        };
+        readonly handle: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 100;
+        };
+        readonly email: {
+            readonly type: "string";
+            readonly maxLength: 254;
+        };
+        readonly homepage: {
+            readonly type: "string";
+            readonly maxLength: 2048;
+        };
+    };
+};
+/** Schema of an asset's author: a name, or their details */
+export declare const authorSchema: {
+    readonly anyOf: readonly [{
+        readonly type: "string";
+        readonly minLength: 1;
+        readonly maxLength: 100;
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["name"];
+        readonly properties: {
+            readonly did: {
+                readonly type: "string";
+                readonly maxLength: 2048;
+                readonly pattern: "^did:[a-z]+:[a-zA-Z0-9._:%-]+$";
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 100;
+            };
+            readonly handle: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 100;
+            };
+            readonly email: {
+                readonly type: "string";
+                readonly maxLength: 254;
+            };
+            readonly homepage: {
+                readonly type: "string";
+                readonly maxLength: 2048;
+            };
+        };
+    }];
+};
+/** Schema of the `$schema` a file names (any version: the app checks which ones it reads) */
+export declare const fileSchemaUrlSchema: {
+    readonly type: "string";
+    readonly minLength: 1;
+    readonly maxLength: 2048;
+};
+/** A collection file: what users export and import one or more assets in */
+export interface AssetCollectionFile<T> {
+    /** URL of the collection's schema, which names its version */
+    $schema: string;
+    /** The kind of collection, e.g. `PaintCanvas/BrushConfigCollection` */
+    "@type": string;
+    /** The assets */
+    items: T[];
+}
+/** What a collection schema is made from */
+export interface CollectionSchemaOptions {
+    /** The collection schema's name, e.g. `brush-preset-collection` */
+    name: string;
+    /** The collection schema's version */
+    version: string;
+    /** The collection's `@type` */
+    type: string;
+    /** `$id` of each item's schema */
+    item: string;
+    /** Most items in one file */
+    maxItems: number;
+}
+/**
+ * The schema of a collection file holding assets of one kind.
+ *
+ * @example
+ * collectionSchema({ name: "brush-preset-collection", version: "1.0.0", type: "PaintCanvas/BrushConfigCollection",
+ *   item: brushPresetSchema.$id, maxItems: 1000 });
+ */
+export declare const collectionSchema: ({ name, version, type, item, maxItems, }: CollectionSchemaOptions) => {
+    $schema: string;
+    $id: string;
+    "@type": string;
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        $schema: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 2048;
+        };
+        "@type": {
+            const: string;
+        };
+        items: {
+            type: string;
+            maxItems: number;
+            items: {
+                $ref: string;
+            };
+        };
+    };
+};

package/dist/lib/assets/schema.js

@@ -0,0 +1,76 @@
+import { SCHEMA_DIALECT, schemaUrl } from "../schemas/index.js";
+// src/lib/assets/schema.ts
+/** Matches a lowercase UUID */
+var UUID_PATTERN = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+/** Matches a decentralised identifier, e.g. `did:plc:abc123` */
+var DID_PATTERN = "^did:[a-z]+:[a-zA-Z0-9._:%-]+$";
+/** Longest author name or handle (characters) */
+var MAX_AUTHOR_TEXT_LENGTH = 100;
+/** Longest URL in an asset (characters) */
+var MAX_URL_LENGTH = 2048;
+/** Short text, such as an author's name */
+var authorText = {
+	type: "string",
+	minLength: 1,
+	maxLength: 100
+};
+/** Schema of an author's details */
+var authorDetailsSchema = {
+	type: "object",
+	additionalProperties: false,
+	required: ["name"],
+	properties: {
+		did: {
+			type: "string",
+			maxLength: MAX_URL_LENGTH,
+			pattern: DID_PATTERN
+		},
+		name: authorText,
+		handle: authorText,
+		email: {
+			type: "string",
+			maxLength: 254
+		},
+		homepage: {
+			type: "string",
+			maxLength: MAX_URL_LENGTH
+		}
+	}
+};
+/** Schema of an asset's author: a name, or their details */
+var authorSchema = { anyOf: [authorText, authorDetailsSchema] };
+/** Schema of the `$schema` a file names (any version: the app checks which ones it reads) */
+var fileSchemaUrlSchema = {
+	type: "string",
+	minLength: 1,
+	maxLength: MAX_URL_LENGTH
+};
+/**
+* The schema of a collection file holding assets of one kind.
+*
+* @example
+* collectionSchema({ name: "brush-preset-collection", version: "1.0.0", type: "PaintCanvas/BrushConfigCollection",
+*   item: brushPresetSchema.$id, maxItems: 1000 });
+*/
+var collectionSchema = ({ name, version, type, item, maxItems }) => ({
+	$schema: SCHEMA_DIALECT,
+	$id: schemaUrl(name, version),
+	"@type": type,
+	type: "object",
+	additionalProperties: false,
+	required: [
+		"$schema",
+		"@type",
+		"items"
+	],
+	properties: {
+		$schema: fileSchemaUrlSchema,
+		"@type": { const: type },
+		items: {
+			type: "array",
+			maxItems,
+			items: { $ref: item }
+		}
+	}
+});
+export { DID_PATTERN, MAX_AUTHOR_TEXT_LENGTH, MAX_URL_LENGTH, UUID_PATTERN, authorDetailsSchema, authorSchema, collectionSchema, fileSchemaUrlSchema };

package/dist/lib/brushes/presetFile/index.d.ts

@@ -1,32 +1,11 @@
+import AssetFile from "../../assets";
 import type { BrushConfig } from "../types";
-/** Messages shown when importing or exporting presets fails */
-export declare const PRESET_FILE_ERRORS: {
-    readonly incompatible: "Brush preset JSON file not compatible";
-    readonly read: "Failed to read brush preset JSON file";
-    readonly export: "Error exporting brush preset JSON file";
-    readonly empty: "No brush presets to export";
-};
-/** Importing or exporting presets failed, with a message for the user */
-export declare class PresetFileError extends Error {
-}
 /**
- * The file name presets are exported to on a day, starting with a prefix (see `PaintCanvasNames.filePrefix`).
+ * Reads and writes brush preset collection files. Files from before versioned schemas (`format`, `version: 1` and
+ * `presets`) are migrated.
  *
  * @example
- * presetFileName(new Date(2026, 9, 24)); // "paintcanvas-brush-presets-2026-10-24.json"
- * presetFileName(new Date(2026, 9, 24), "myapp"); // "myapp-brush-presets-2026-10-24.json"
+ * const presets = brushPresetFile.parse(await file.text()); // throws AssetFileError
+ * const json = brushPresetFile.write(app.customPresets.presets);
  */
-export declare const presetFileName: (date?: Date, prefix?: string) => string;
-/**
- * Write presets to a brush preset file (JSON) of a format (see `PaintCanvasNames.presetFileFormat`). Throws a
- * `PresetFileError` if there are none, or one can't be exported (e.g. its shape isn't a PNG data URL).
- *
- * @example
- * exportPresetFile([myPreset]); // '{ "format": "paintcanvas-brush-presets", "version": 1, "presets": [...] }'
- */
-export declare const exportPresetFile: (presets: BrushConfig[], format?: string) => string;
-/**
- * Read the presets in a brush preset file of one of the given formats (PaintCanvas's by default).
- * Throws a `PresetFileError` if it isn't valid JSON or a compatible file.
- */
-export declare const parsePresetFile: (text: string, formats?: readonly string[]) => BrushConfig[];
+export declare const brushPresetFile: AssetFile<BrushConfig>;

package/dist/lib/brushes/presetFile/index.js

@@ -1,55 +1,42 @@
-import { BRUSH_PRESET_FILE_FORMAT, BRUSH_PRESET_FILE_FORMATS } from "../../presets/schema.js";
-import { isValidBrushPreset, isValidBrushPresetFile } from "../../presets/index.js";
+import AssetFile from "../../assets/index.js";
+import { BRUSH_PRESET_COLLECTION_SCHEMA_VERSION, BRUSH_PRESET_COLLECTION_TYPE } from "../../presets/schema.js";
+import "../../presets/index.js";
+import { validateBrushPresetCollection } from "../../validation/validators.generated.js";
 // src/lib/brushes/presetFile/index.ts
-/** Messages shown when importing or exporting presets fails */
-var PRESET_FILE_ERRORS = {
-	incompatible: "Brush preset JSON file not compatible",
-	read: "Failed to read brush preset JSON file",
-	export: "Error exporting brush preset JSON file",
-	empty: "No brush presets to export"
-};
-/** Importing or exporting presets failed, with a message for the user */
-var PresetFileError = class extends Error {};
 /**
-* The file name presets are exported to on a day, starting with a prefix (see `PaintCanvasNames.filePrefix`).
-*
-* @example
-* presetFileName(new Date(2026, 9, 24)); // "paintcanvas-brush-presets-2026-10-24.json"
-* presetFileName(new Date(2026, 9, 24), "myapp"); // "myapp-brush-presets-2026-10-24.json"
+* A preset from a brush preset file from before versioned schemas, with its author's `website` renamed `homepage`.
 */
-var presetFileName = (date = /* @__PURE__ */ new Date(), prefix = "paintcanvas") => {
-	const pad = (n) => String(n).padStart(2, "0");
-	return `${prefix}-brush-presets-${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}.json`;
+var migrateLegacyPreset = (preset) => {
+	const author = preset?.author;
+	if (typeof author !== "object" || author === null || !("website" in author)) return preset;
+	const { website, ...rest } = author;
+	return {
+		...preset,
+		author: {
+			...rest,
+			homepage: website
+		}
+	};
 };
 /**
-* Write presets to a brush preset file (JSON) of a format (see `PaintCanvasNames.presetFileFormat`). Throws a
-* `PresetFileError` if there are none, or one can't be exported (e.g. its shape isn't a PNG data URL).
+* Reads and writes brush preset collection files. Files from before versioned schemas (`format`, `version: 1` and
+* `presets`) are migrated.
 *
 * @example
-* exportPresetFile([myPreset]); // '{ "format": "paintcanvas-brush-presets", "version": 1, "presets": [...] }'
+* const presets = brushPresetFile.parse(await file.text()); // throws AssetFileError
+* const json = brushPresetFile.write(app.customPresets.presets);
 */
-var exportPresetFile = (presets, format = BRUSH_PRESET_FILE_FORMAT) => {
-	if (presets.length === 0) throw new PresetFileError(PRESET_FILE_ERRORS.empty);
-	if (!presets.every((preset) => isValidBrushPreset(preset).valid)) throw new PresetFileError(PRESET_FILE_ERRORS.export);
-	return JSON.stringify({
-		format,
-		version: 1,
-		presets
-	}, null, 2);
-};
-/**
-* Read the presets in a brush preset file of one of the given formats (PaintCanvas's by default).
-* Throws a `PresetFileError` if it isn't valid JSON or a compatible file.
-*/
-var parsePresetFile = (text, formats = BRUSH_PRESET_FILE_FORMATS) => {
-	let data;
-	try {
-		data = JSON.parse(text);
-	} catch {
-		throw new PresetFileError(PRESET_FILE_ERRORS.incompatible);
-	}
-	const result = isValidBrushPresetFile(data);
-	if (!result.valid || !formats.includes(result.value.format)) throw new PresetFileError(PRESET_FILE_ERRORS.incompatible);
-	return result.value.presets;
-};
-export { PRESET_FILE_ERRORS, PresetFileError, exportPresetFile, parsePresetFile, presetFileName };
+var brushPresetFile = new AssetFile({
+	schema: "brush-preset-collection",
+	version: BRUSH_PRESET_COLLECTION_SCHEMA_VERSION,
+	type: BRUSH_PRESET_COLLECTION_TYPE,
+	validate: validateBrushPresetCollection,
+	fileName: "brush-presets",
+	legacyVersion: (data) => typeof data.format === "string" && data.version === 1 ? "legacy-1" : void 0,
+	migrations: [{
+		from: "legacy-1",
+		to: "1.0.0",
+		migrate: (data) => ({ items: Array.isArray(data.presets) ? data.presets.map(migrateLegacyPreset) : data.presets })
+	}]
+});
+export { brushPresetFile };

package/dist/lib/brushes/types/index.d.ts

@@ -1,15 +1,6 @@
 import type { ProfilePoint } from "../../profiles";
-export interface AssetAuthorDetails {
-    /** Author's name */
-    name: string;
-    /** Author's handle or username, which tells their presets apart from others with the same name */
-    handle?: string;
-    /** Author's email */
-    email?: string;
-    /** Author's website */
-    website?: string;
-}
-export type AssetAuthor = string | AssetAuthorDetails;
+import type { AssetAuthor } from "../../assets/schema";
+export type { AssetAuthor, AssetAuthorDetails } from "../../assets/schema";
 /** Which colour settings a brush varies */
 export declare enum ColourMode {
     HSL = 0,

package/dist/lib/classes/AssetSync/index.d.ts

@@ -0,0 +1,45 @@
+import type { Asset, AssetStoreLike } from "../../storage";
+/** Event dispatched when loading or saving assets fails (detail: the error) */
+export declare const ASSET_SYNC_ERROR_EVENT = "error";
+/** Assets kept in memory that `AssetSync` keeps in a store */
+export interface SyncedAssets<T extends Asset> extends EventTarget {
+    /** The assets, in order (dispatching `change` when they change) */
+    readonly items: readonly T[];
+    /** Add assets loaded from the store (untrusted: leave out invalid ones), replacing ones with the same IDs */
+    merge(items: unknown[]): void;
+}
+/**
+ * Keeps assets held in memory (e.g. profile graphs) in a store: the saved assets are added when it starts, assets only
+ * in memory are saved (e.g. ones restored from older app settings), then each change saves the assets that changed and
+ * deletes the ones that are gone.
+ *
+ * Dispatches an `error` event (with the error as `detail`) when loading or saving fails.
+ *
+ * @example
+ * const sync = new AssetSync(profiles, new IndexedDbAssetStore("profiles"));
+ * await sync.ready;
+ * sync.stop();
+ */
+export default class AssetSync<T extends Asset> extends EventTarget {
+    readonly assets: SyncedAssets<T>;
+    readonly store: AssetStoreLike<T>;
+    /** Resolves once the saved assets are loaded and any only in memory are saved */
+    readonly ready: Promise<void>;
+    /** Each asset as last saved, as JSON, by ID */
+    private saved;
+    private stopped;
+    /** Saving, one change after another */
+    private saving;
+    private readonly onChange;
+    constructor(assets: SyncedAssets<T>, store: AssetStoreLike<T>);
+    /**
+     * Stop keeping changes (ones already being saved finish).
+     */
+    stop(): void;
+    /** Load the saved assets, then save the ones only in memory and listen for changes */
+    private start;
+    /** Save the assets that changed since they were last saved, and delete the ones that are gone */
+    private save;
+    /** Tell listeners loading or saving failed */
+    private fail;
+}