@genetik/schema 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eugene Michasiw
+
+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,39 @@
+# @genetik/schema
+
+Block types, config (JSON Schema), slots, and reference modes for the Genetik JSON-driven UI ecosystem.
+
+## Install
+
+```bash
+pnpm add @genetik/schema
+```
+
+## Usage
+
+```ts
+import {
+  createSchema,
+  registerBlockType,
+  getBlockType,
+  validateConfig,
+} from "@genetik/schema";
+
+const schema = createSchema({ version: "1.0.0" });
+registerBlockType(schema, {
+  name: "text",
+  configSchema: { type: "object", properties: { content: { type: "string" } }, required: ["content"] },
+  slots: [],
+});
+
+const result = validateConfig(schema, "text", { content: "Hello" });
+// result.valid === true
+```
+
+See the [docs](https://github.com/...) or `apps/docs/docs/packages/schema.md` in the repo for full API and concepts.
+
+## Scripts
+
+- `pnpm build` - Build with tsdown (ESM + CJS + types)
+- `pnpm test` - Run tests
+- `pnpm check-types` - TypeScript check
+- `pnpm lint` - ESLint

package/dist/index.cjs

@@ -0,0 +1,204 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let ajv = require("ajv");
+ajv = __toESM(ajv);
+let ajv_formats = require("ajv-formats");
+ajv_formats = __toESM(ajv_formats);
+
+//#region src/registry.ts
+const DEFAULT_REFERENCE_MODE = "id";
+function resolveOptions(configOptions) {
+	return {
+		slotReferenceMode: DEFAULT_REFERENCE_MODE,
+		...configOptions
+	};
+}
+function toSlotDefinition(slot, referenceMode) {
+	return {
+		name: slot.name,
+		multiple: slot.multiple,
+		referenceMode
+	};
+}
+function toBlockTypeDefinition(block, referenceMode) {
+	return {
+		name: block.name,
+		configSchema: block.configSchema,
+		slots: block.slots.map((s) => toSlotDefinition(s, referenceMode))
+	};
+}
+function buildContentSchema(blockNames) {
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		type: "object",
+		required: ["entryId", "nodes"],
+		properties: {
+			entryId: { type: "string" },
+			nodes: {
+				type: "object",
+				additionalProperties: { $ref: "#/definitions/ContentNode" }
+			}
+		},
+		definitions: { ContentNode: {
+			type: "object",
+			required: [
+				"id",
+				"block",
+				"config"
+			],
+			properties: {
+				id: { type: "string" },
+				block: blockNames.length > 0 ? {
+					type: "string",
+					enum: blockNames
+				} : { type: "string" },
+				config: { type: "object" }
+			},
+			additionalProperties: true
+		} }
+	};
+}
+/**
+* Creates a schema from config. Runs plugins (which can register blocks and add options),
+* then builds block types with global slotReferenceMode. Returns the schema with getters
+* and a contentSchema (JSON Schema for the content document).
+*/
+function createSchema(config) {
+	const blocks = [...config.registerBlocks ?? []];
+	const options = resolveOptions(config.options);
+	const context = {
+		registerBlock(block) {
+			blocks.push(block);
+		},
+		options,
+		version: config.version
+	};
+	for (const plugin of config.registerPlugins ?? []) plugin(context);
+	const referenceMode = options.slotReferenceMode ?? DEFAULT_REFERENCE_MODE;
+	const blockTypes = /* @__PURE__ */ new Map();
+	for (const block of blocks) blockTypes.set(block.name, toBlockTypeDefinition(block, referenceMode));
+	const contentSchema = buildContentSchema(Array.from(blockTypes.keys()));
+	return {
+		blockTypes,
+		meta: config.version !== void 0 ? { version: config.version } : void 0,
+		contentSchema,
+		options,
+		version: config.version,
+		getBlockType(name) {
+			return blockTypes.get(name);
+		},
+		getBlockTypeNames() {
+			return Array.from(blockTypes.keys());
+		},
+		hasBlockType(name) {
+			return blockTypes.has(name);
+		}
+	};
+}
+/**
+* Returns the block type definition for the given name, or undefined if not registered.
+*/
+function getBlockType(schema, name) {
+	return schema.blockTypes.get(name);
+}
+/**
+* Returns true if the schema has a block type with the given name.
+*/
+function hasBlockType(schema, name) {
+	return schema.blockTypes.has(name);
+}
+/**
+* Returns all registered block type names.
+*/
+function getBlockTypeNames(schema) {
+	return Array.from(schema.blockTypes.keys());
+}
+
+//#endregion
+//#region src/validate.ts
+const Ajv = ajv.default;
+const addFormats = ajv_formats.default;
+const ajv$1 = new Ajv({
+	allErrors: true,
+	strict: false
+});
+addFormats(ajv$1);
+/**
+* Validates a config object against a block type's JSON Schema.
+* Returns { valid: true, errors: null } on success, or { valid: false, errors } on failure.
+*/
+function validateConfig(schema, blockTypeName, config) {
+	const blockType = getBlockType(schema, blockTypeName);
+	if (!blockType) return {
+		valid: false,
+		errors: [{
+			instancePath: "",
+			schemaPath: "",
+			keyword: "blockType",
+			message: `Unknown block type: ${blockTypeName}`,
+			params: {}
+		}]
+	};
+	return validateConfigAgainstDefinition(blockType, config);
+}
+/**
+* Validates a config object against a block type definition's JSON Schema.
+* Use this when you already have the BlockTypeDefinition (e.g. from getBlockType).
+*/
+function validateConfigAgainstDefinition(blockType, config) {
+	let validate;
+	try {
+		validate = ajv$1.compile(blockType.configSchema);
+	} catch (err) {
+		return {
+			valid: false,
+			errors: [{
+				instancePath: "",
+				schemaPath: "",
+				keyword: "schema",
+				message: err instanceof Error ? err.message : "Invalid config schema",
+				params: {}
+			}]
+		};
+	}
+	const valid = validate(config);
+	return {
+		valid,
+		errors: valid ? null : validate.errors ?? []
+	};
+}
+
+//#endregion
+exports.createSchema = createSchema;
+exports.getBlockType = getBlockType;
+exports.getBlockTypeNames = getBlockTypeNames;
+exports.hasBlockType = hasBlockType;
+exports.validateConfig = validateConfig;
+exports.validateConfigAgainstDefinition = validateConfigAgainstDefinition;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["AjvDefault","addFormatsDefault","ajv"],"sources":["../src/registry.ts","../src/validate.ts"],"sourcesContent":["import type {\n  BlockInput,\n  BlockTypeDefinition,\n  GenetikSchema,\n  JsonSchema,\n  SchemaConfig,\n  SchemaOptions,\n  SlotDefinition,\n  SlotReferenceMode,\n} from \"./types.js\";\n\nconst DEFAULT_REFERENCE_MODE: SlotReferenceMode = \"id\";\n\nfunction resolveOptions(configOptions?: SchemaOptions): SchemaOptions {\n  return {\n    slotReferenceMode: DEFAULT_REFERENCE_MODE,\n    ...configOptions,\n  };\n}\n\nfunction toSlotDefinition(slot: { name: string; multiple: boolean }, referenceMode: SlotReferenceMode): SlotDefinition {\n  return {\n    name: slot.name,\n    multiple: slot.multiple,\n    referenceMode,\n  };\n}\n\nfunction toBlockTypeDefinition(block: BlockInput, referenceMode: SlotReferenceMode): BlockTypeDefinition {\n  return {\n    name: block.name,\n    configSchema: block.configSchema,\n    slots: block.slots.map((s) => toSlotDefinition(s, referenceMode)),\n  };\n}\n\nfunction buildContentSchema(blockNames: string[]): JsonSchema {\n  return {\n    $schema: \"https://json-schema.org/draft/2020-12/schema\",\n    type: \"object\",\n    required: [\"entryId\", \"nodes\"],\n    properties: {\n      entryId: { type: \"string\" },\n      nodes: {\n        type: \"object\",\n        additionalProperties: { $ref: \"#/definitions/ContentNode\" },\n      },\n    },\n    definitions: {\n      ContentNode: {\n        type: \"object\",\n        required: [\"id\", \"block\", \"config\"],\n        properties: {\n          id: { type: \"string\" },\n          block: blockNames.length > 0 ? { type: \"string\", enum: blockNames } : { type: \"string\" },\n          config: { type: \"object\" },\n        },\n        additionalProperties: true,\n      },\n    },\n  };\n}\n\nexport interface SchemaInstance extends GenetikSchema {\n  /** JSON Schema that describes the content document (entryId + nodes). */\n  contentSchema: JsonSchema;\n  /** Resolved options (includes slotReferenceMode). */\n  options: SchemaOptions;\n  /** Schema version if set. */\n  version?: string;\n  getBlockType(name: string): BlockTypeDefinition | undefined;\n  getBlockTypeNames(): string[];\n  hasBlockType(name: string): boolean;\n}\n\n/**\n * Creates a schema from config. Runs plugins (which can register blocks and add options),\n * then builds block types with global slotReferenceMode. Returns the schema with getters\n * and a contentSchema (JSON Schema for the content document).\n */\nexport function createSchema(config: SchemaConfig): SchemaInstance {\n  const blocks: BlockInput[] = [...(config.registerBlocks ?? [])];\n  const options = resolveOptions(config.options);\n\n  const context: import(\"./types.js\").SchemaPluginContext = {\n    registerBlock(block: BlockInput) {\n      blocks.push(block);\n    },\n    options,\n    version: config.version,\n  };\n\n  for (const plugin of config.registerPlugins ?? []) {\n    plugin(context);\n  }\n\n  const referenceMode = (options.slotReferenceMode ?? DEFAULT_REFERENCE_MODE) as SlotReferenceMode;\n  const blockTypes = new Map<string, BlockTypeDefinition>();\n  for (const block of blocks) {\n    blockTypes.set(block.name, toBlockTypeDefinition(block, referenceMode));\n  }\n\n  const blockNames = Array.from(blockTypes.keys());\n  const contentSchema = buildContentSchema(blockNames);\n\n  const schema: GenetikSchema = {\n    blockTypes,\n    meta: config.version !== undefined ? { version: config.version } : undefined,\n  };\n\n  return {\n    ...schema,\n    contentSchema,\n    options,\n    version: config.version,\n    getBlockType(name: string) {\n      return blockTypes.get(name);\n    },\n    getBlockTypeNames() {\n      return Array.from(blockTypes.keys());\n    },\n    hasBlockType(name: string) {\n      return blockTypes.has(name);\n    },\n  };\n}\n\n/**\n * Returns the block type definition for the given name, or undefined if not registered.\n */\nexport function getBlockType(schema: GenetikSchema, name: string): BlockTypeDefinition | undefined {\n  return schema.blockTypes.get(name);\n}\n\n/**\n * Returns true if the schema has a block type with the given name.\n */\nexport function hasBlockType(schema: GenetikSchema, name: string): boolean {\n  return schema.blockTypes.has(name);\n}\n\n/**\n * Returns all registered block type names.\n */\nexport function getBlockTypeNames(schema: GenetikSchema): string[] {\n  return Array.from(schema.blockTypes.keys());\n}\n","import AjvDefault from \"ajv\";\nimport addFormatsDefault from \"ajv-formats\";\nimport type { ErrorObject, ValidateFunction } from \"ajv\";\nimport type { BlockTypeDefinition, GenetikSchema } from \"./types.js\";\nimport { getBlockType } from \"./registry.js\";\n\n// ESM/NodeNext: default export types don't expose constructor/call; assert through unknown\nconst Ajv = AjvDefault as unknown as new (opts?: { allErrors?: boolean; strict?: boolean }) => { compile: (schema: object) => ValidateFunction };\nconst addFormats = addFormatsDefault as unknown as (ajv: InstanceType<typeof Ajv>) => void;\nconst ajv = new Ajv({ allErrors: true, strict: false });\naddFormats(ajv);\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: ErrorObject[] | null;\n}\n\n/**\n * Validates a config object against a block type's JSON Schema.\n * Returns { valid: true, errors: null } on success, or { valid: false, errors } on failure.\n */\nexport function validateConfig(\n  schema: GenetikSchema,\n  blockTypeName: string,\n  config: unknown\n): ValidationResult {\n  const blockType = getBlockType(schema, blockTypeName);\n  if (!blockType) {\n    return {\n      valid: false,\n      errors: [\n        {\n          instancePath: \"\",\n          schemaPath: \"\",\n          keyword: \"blockType\",\n          message: `Unknown block type: ${blockTypeName}`,\n          params: {},\n        } satisfies ErrorObject,\n      ],\n    };\n  }\n  return validateConfigAgainstDefinition(blockType, config);\n}\n\n/**\n * Validates a config object against a block type definition's JSON Schema.\n * Use this when you already have the BlockTypeDefinition (e.g. from getBlockType).\n */\nexport function validateConfigAgainstDefinition(\n  blockType: BlockTypeDefinition,\n  config: unknown\n): ValidationResult {\n  let validate: ValidateFunction;\n  try {\n    validate = ajv.compile(blockType.configSchema);\n  } catch (err) {\n    return {\n      valid: false,\n      errors: [\n        {\n          instancePath: \"\",\n          schemaPath: \"\",\n          keyword: \"schema\",\n          message: err instanceof Error ? err.message : \"Invalid config schema\",\n          params: {},\n        } satisfies ErrorObject,\n      ],\n    };\n  }\n  const valid = validate(config);\n  return {\n    valid,\n    errors: valid ? null : (validate.errors ?? []),\n  };\n}\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,159 @@
+import { ErrorObject } from "ajv";
+
+//#region src/types.d.ts
+/**
+ * Reference mode for slots (global on schema). How child nodes can be specified.
+ * - id: slot value is an id or array of ids (canonical form).
+ * - inline: slot may contain inline node(s), normalized to flat + ids before storage/rendering.
+ * - both: slot accepts either id(s) or inline node(s).
+ */
+type SlotReferenceMode = "id" | "inline" | "both";
+/**
+ * Slot definition at runtime: has referenceMode (from schema options).
+ */
+interface SlotDefinition {
+  /** Slot name (e.g. "children", "header", "footer"). */
+  name: string;
+  /** If true, slot holds an ordered list of nodes; if false, a single node. */
+  multiple: boolean;
+  /** From schema options; whether the slot accepts id references, inline nodes, or both. */
+  referenceMode: SlotReferenceMode;
+}
+/**
+ * Slot input when registering a block. No referenceMode — that comes from schema options.
+ */
+interface SlotInput {
+  /** Slot name (e.g. "children", "header", "footer"). */
+  name: string;
+  /** If true, slot holds an ordered list of nodes; if false, a single node. */
+  multiple: boolean;
+}
+/**
+ * JSON Schema is a plain object. We use a generic object type for flexibility.
+ * Block config is validated against this schema (e.g. via ajv).
+ */
+type JsonSchema = Record<string, unknown>;
+/**
+ * Block input when registering. Slots have no referenceMode (global on schema).
+ */
+interface BlockInput {
+  /** Block type name (e.g. "hero", "card", "text"). */
+  name: string;
+  /** JSON Schema for this block's config. */
+  configSchema: JsonSchema;
+  /** Slots this block exposes. */
+  slots: SlotInput[];
+}
+/**
+ * Runtime block type: slots have referenceMode filled from schema options.
+ */
+interface BlockTypeDefinition {
+  /** Block type name (e.g. "hero", "card", "text"). */
+  name: string;
+  /** JSON Schema for this block's config. */
+  configSchema: JsonSchema;
+  /** Slots with referenceMode applied. */
+  slots: SlotDefinition[];
+}
+/**
+ * Schema-level options. slotReferenceMode applies to all slots globally.
+ */
+interface SchemaOptions {
+  /** How slots accept children. Default "id". */
+  slotReferenceMode?: SlotReferenceMode;
+  [key: string]: unknown;
+}
+/**
+ * Context passed to plugins. Plugins can register blocks and read/mutate options.
+ */
+interface SchemaPluginContext {
+  /** Register a block type. */
+  registerBlock(block: BlockInput): void;
+  /** Resolved options (includes slotReferenceMode). Mutate to add plugin options. */
+  options: SchemaOptions;
+  /** Schema version if set. */
+  version?: string;
+}
+/**
+ * Build-time plugin. Can register blocks and/or add options.
+ */
+type SchemaPlugin = (context: SchemaPluginContext) => void;
+/**
+ * Config for createSchema. Our API (not JSON Schema).
+ */
+interface SchemaConfig {
+  /** Block types to register. */
+  registerBlocks?: BlockInput[];
+  /** Plugins run in order; each can register blocks and add options. */
+  registerPlugins?: SchemaPlugin[];
+  /** Schema version (e.g. "1.0.0"). */
+  version?: string;
+  /** Schema options (e.g. slotReferenceMode). Merged with plugin-added options. */
+  options?: SchemaOptions;
+}
+/**
+ * Schema metadata: version for migrations and compatibility.
+ */
+interface SchemaMeta {
+  /** Schema version (e.g. "1.0.0"). */
+  version: string;
+}
+/**
+ * Runtime schema: block types + meta. createSchema also adds contentSchema and getters.
+ */
+interface GenetikSchema {
+  /** Map of block type name to definition. */
+  blockTypes: Map<string, BlockTypeDefinition>;
+  /** Optional schema metadata (e.g. version). */
+  meta?: SchemaMeta;
+}
+//#endregion
+//#region src/registry.d.ts
+interface SchemaInstance extends GenetikSchema {
+  /** JSON Schema that describes the content document (entryId + nodes). */
+  contentSchema: JsonSchema;
+  /** Resolved options (includes slotReferenceMode). */
+  options: SchemaOptions;
+  /** Schema version if set. */
+  version?: string;
+  getBlockType(name: string): BlockTypeDefinition | undefined;
+  getBlockTypeNames(): string[];
+  hasBlockType(name: string): boolean;
+}
+/**
+ * Creates a schema from config. Runs plugins (which can register blocks and add options),
+ * then builds block types with global slotReferenceMode. Returns the schema with getters
+ * and a contentSchema (JSON Schema for the content document).
+ */
+declare function createSchema(config: SchemaConfig): SchemaInstance;
+/**
+ * Returns the block type definition for the given name, or undefined if not registered.
+ */
+declare function getBlockType(schema: GenetikSchema, name: string): BlockTypeDefinition | undefined;
+/**
+ * Returns true if the schema has a block type with the given name.
+ */
+declare function hasBlockType(schema: GenetikSchema, name: string): boolean;
+/**
+ * Returns all registered block type names.
+ */
+declare function getBlockTypeNames(schema: GenetikSchema): string[];
+//#endregion
+//#region src/validate.d.ts
+interface ValidationResult {
+  valid: boolean;
+  errors: ErrorObject[] | null;
+}
+/**
+ * Validates a config object against a block type's JSON Schema.
+ * Returns { valid: true, errors: null } on success, or { valid: false, errors } on failure.
+ */
+declare function validateConfig(schema: GenetikSchema, blockTypeName: string, config: unknown): ValidationResult;
+/**
+ * Validates a config object against a block type definition's JSON Schema.
+ * Use this when you already have the BlockTypeDefinition (e.g. from getBlockType).
+ */
+declare function validateConfigAgainstDefinition(blockType: BlockTypeDefinition, config: unknown): ValidationResult;
+//#endregion
+export { type BlockInput, type BlockTypeDefinition, type GenetikSchema, type JsonSchema, type SchemaConfig, type SchemaInstance, type SchemaMeta, type SchemaOptions, type SchemaPlugin, type SchemaPluginContext, type SlotDefinition, type SlotInput, type SlotReferenceMode, type ValidationResult, createSchema, getBlockType, getBlockTypeNames, hasBlockType, validateConfig, validateConfigAgainstDefinition };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/registry.ts","../src/validate.ts"],"mappings":";;;;;;AAMA;;;KAAY,iBAAA;;AAKZ;;UAAiB,cAAA;EAMiB;EAJhC,IAAA;EAEA;EAAA,QAAA;EAEe;EAAf,aAAA,EAAe,iBAAA;AAAA;AAMjB;;;AAAA,UAAiB,SAAA;EAIP;EAFR,IAAA;EASoB;EAPpB,QAAA;AAAA;;AAYF;;;KALY,UAAA,GAAa,MAAA;;;;UAKR,UAAA;EAMR;EAJP,IAAA;EAIgB;EAFhB,YAAA,EAAc,UAAA;EAQoB;EANlC,KAAA,EAAO,SAAA;AAAA;;;;UAMQ,mBAAA;EAMR;EAJP,IAAA;EAIqB;EAFrB,YAAA,EAAc,UAAA;EAQc;EAN5B,KAAA,EAAO,cAAA;AAAA;;;;UAMQ,aAAA;EAGH;EADZ,iBAAA,GAAoB,iBAAA;EAAA,CACnB,GAAA;AAAA;;;;UAMc,mBAAA;EAIf;EAFA,aAAA,CAAc,KAAA,EAAO,UAAA;EAIrB;EAFA,OAAA,EAAS,aAAA;EAEF;EAAP,OAAA;AAAA;;;;KAMU,YAAA,IAAgB,OAAA,EAAS,mBAAA;;;;UAKpB,YAAA;EAQL;EANV,cAAA,GAAiB,UAAA;EAMM;EAJvB,eAAA,GAAkB,YAAA;EAFD;EAIjB,OAAA;EAFkB;EAIlB,OAAA,GAAU,aAAA;AAAA;;;;UAMK,UAAA;EAAU;EAEzB,OAAA;AAAA;;AAMF;;UAAiB,aAAA;EAES;EAAxB,UAAA,EAAY,GAAA,SAAY,mBAAA;EAEjB;EAAP,IAAA,GAAO,UAAA;AAAA;;;UCpDQ,cAAA,SAAuB,aAAA;;EAEtC,aAAA,EAAe,UAAA;ED3DY;EC6D3B,OAAA,EAAS,aAAA;ED7DkB;EC+D3B,OAAA;EACA,YAAA,CAAa,IAAA,WAAe,mBAAA;EAC5B,iBAAA;EACA,YAAA,CAAa,IAAA;AAAA;;;;;;iBAQC,YAAA,CAAa,MAAA,EAAQ,YAAA,GAAe,cAAA;ADzDpD;;;AAAA,iBC2GgB,YAAA,CAAa,MAAA,EAAQ,aAAA,EAAe,IAAA,WAAe,mBAAA;;ADhGnE;;iBCuGgB,YAAA,CAAa,MAAA,EAAQ,aAAA,EAAe,IAAA;;;ADlGpD;iBCyGgB,iBAAA,CAAkB,MAAA,EAAQ,aAAA;;;UCpIzB,gBAAA;EACf,KAAA;EACA,MAAA,EAAQ,WAAA;AAAA;;;AFHV;;iBEUgB,cAAA,CACd,MAAA,EAAQ,aAAA,EACR,aAAA,UACA,MAAA,YACC,gBAAA;;;;;iBAuBa,+BAAA,CACd,SAAA,EAAW,mBAAA,EACX,MAAA,YACC,gBAAA"}

package/dist/index.d.mts

@@ -0,0 +1,159 @@
+import { ErrorObject } from "ajv";
+
+//#region src/types.d.ts
+/**
+ * Reference mode for slots (global on schema). How child nodes can be specified.
+ * - id: slot value is an id or array of ids (canonical form).
+ * - inline: slot may contain inline node(s), normalized to flat + ids before storage/rendering.
+ * - both: slot accepts either id(s) or inline node(s).
+ */
+type SlotReferenceMode = "id" | "inline" | "both";
+/**
+ * Slot definition at runtime: has referenceMode (from schema options).
+ */
+interface SlotDefinition {
+  /** Slot name (e.g. "children", "header", "footer"). */
+  name: string;
+  /** If true, slot holds an ordered list of nodes; if false, a single node. */
+  multiple: boolean;
+  /** From schema options; whether the slot accepts id references, inline nodes, or both. */
+  referenceMode: SlotReferenceMode;
+}
+/**
+ * Slot input when registering a block. No referenceMode — that comes from schema options.
+ */
+interface SlotInput {
+  /** Slot name (e.g. "children", "header", "footer"). */
+  name: string;
+  /** If true, slot holds an ordered list of nodes; if false, a single node. */
+  multiple: boolean;
+}
+/**
+ * JSON Schema is a plain object. We use a generic object type for flexibility.
+ * Block config is validated against this schema (e.g. via ajv).
+ */
+type JsonSchema = Record<string, unknown>;
+/**
+ * Block input when registering. Slots have no referenceMode (global on schema).
+ */
+interface BlockInput {
+  /** Block type name (e.g. "hero", "card", "text"). */
+  name: string;
+  /** JSON Schema for this block's config. */
+  configSchema: JsonSchema;
+  /** Slots this block exposes. */
+  slots: SlotInput[];
+}
+/**
+ * Runtime block type: slots have referenceMode filled from schema options.
+ */
+interface BlockTypeDefinition {
+  /** Block type name (e.g. "hero", "card", "text"). */
+  name: string;
+  /** JSON Schema for this block's config. */
+  configSchema: JsonSchema;
+  /** Slots with referenceMode applied. */
+  slots: SlotDefinition[];
+}
+/**
+ * Schema-level options. slotReferenceMode applies to all slots globally.
+ */
+interface SchemaOptions {
+  /** How slots accept children. Default "id". */
+  slotReferenceMode?: SlotReferenceMode;
+  [key: string]: unknown;
+}
+/**
+ * Context passed to plugins. Plugins can register blocks and read/mutate options.
+ */
+interface SchemaPluginContext {
+  /** Register a block type. */
+  registerBlock(block: BlockInput): void;
+  /** Resolved options (includes slotReferenceMode). Mutate to add plugin options. */
+  options: SchemaOptions;
+  /** Schema version if set. */
+  version?: string;
+}
+/**
+ * Build-time plugin. Can register blocks and/or add options.
+ */
+type SchemaPlugin = (context: SchemaPluginContext) => void;
+/**
+ * Config for createSchema. Our API (not JSON Schema).
+ */
+interface SchemaConfig {
+  /** Block types to register. */
+  registerBlocks?: BlockInput[];
+  /** Plugins run in order; each can register blocks and add options. */
+  registerPlugins?: SchemaPlugin[];
+  /** Schema version (e.g. "1.0.0"). */
+  version?: string;
+  /** Schema options (e.g. slotReferenceMode). Merged with plugin-added options. */
+  options?: SchemaOptions;
+}
+/**
+ * Schema metadata: version for migrations and compatibility.
+ */
+interface SchemaMeta {
+  /** Schema version (e.g. "1.0.0"). */
+  version: string;
+}
+/**
+ * Runtime schema: block types + meta. createSchema also adds contentSchema and getters.
+ */
+interface GenetikSchema {
+  /** Map of block type name to definition. */
+  blockTypes: Map<string, BlockTypeDefinition>;
+  /** Optional schema metadata (e.g. version). */
+  meta?: SchemaMeta;
+}
+//#endregion
+//#region src/registry.d.ts
+interface SchemaInstance extends GenetikSchema {
+  /** JSON Schema that describes the content document (entryId + nodes). */
+  contentSchema: JsonSchema;
+  /** Resolved options (includes slotReferenceMode). */
+  options: SchemaOptions;
+  /** Schema version if set. */
+  version?: string;
+  getBlockType(name: string): BlockTypeDefinition | undefined;
+  getBlockTypeNames(): string[];
+  hasBlockType(name: string): boolean;
+}
+/**
+ * Creates a schema from config. Runs plugins (which can register blocks and add options),
+ * then builds block types with global slotReferenceMode. Returns the schema with getters
+ * and a contentSchema (JSON Schema for the content document).
+ */
+declare function createSchema(config: SchemaConfig): SchemaInstance;
+/**
+ * Returns the block type definition for the given name, or undefined if not registered.
+ */
+declare function getBlockType(schema: GenetikSchema, name: string): BlockTypeDefinition | undefined;
+/**
+ * Returns true if the schema has a block type with the given name.
+ */
+declare function hasBlockType(schema: GenetikSchema, name: string): boolean;
+/**
+ * Returns all registered block type names.
+ */
+declare function getBlockTypeNames(schema: GenetikSchema): string[];
+//#endregion
+//#region src/validate.d.ts
+interface ValidationResult {
+  valid: boolean;
+  errors: ErrorObject[] | null;
+}
+/**
+ * Validates a config object against a block type's JSON Schema.
+ * Returns { valid: true, errors: null } on success, or { valid: false, errors } on failure.
+ */
+declare function validateConfig(schema: GenetikSchema, blockTypeName: string, config: unknown): ValidationResult;
+/**
+ * Validates a config object against a block type definition's JSON Schema.
+ * Use this when you already have the BlockTypeDefinition (e.g. from getBlockType).
+ */
+declare function validateConfigAgainstDefinition(blockType: BlockTypeDefinition, config: unknown): ValidationResult;
+//#endregion
+export { type BlockInput, type BlockTypeDefinition, type GenetikSchema, type JsonSchema, type SchemaConfig, type SchemaInstance, type SchemaMeta, type SchemaOptions, type SchemaPlugin, type SchemaPluginContext, type SlotDefinition, type SlotInput, type SlotReferenceMode, type ValidationResult, createSchema, getBlockType, getBlockTypeNames, hasBlockType, validateConfig, validateConfigAgainstDefinition };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/registry.ts","../src/validate.ts"],"mappings":";;;;;;AAMA;;;KAAY,iBAAA;;AAKZ;;UAAiB,cAAA;EAMiB;EAJhC,IAAA;EAEA;EAAA,QAAA;EAEe;EAAf,aAAA,EAAe,iBAAA;AAAA;AAMjB;;;AAAA,UAAiB,SAAA;EAIP;EAFR,IAAA;EASoB;EAPpB,QAAA;AAAA;;AAYF;;;KALY,UAAA,GAAa,MAAA;;;;UAKR,UAAA;EAMR;EAJP,IAAA;EAIgB;EAFhB,YAAA,EAAc,UAAA;EAQoB;EANlC,KAAA,EAAO,SAAA;AAAA;;;;UAMQ,mBAAA;EAMR;EAJP,IAAA;EAIqB;EAFrB,YAAA,EAAc,UAAA;EAQc;EAN5B,KAAA,EAAO,cAAA;AAAA;;;;UAMQ,aAAA;EAGH;EADZ,iBAAA,GAAoB,iBAAA;EAAA,CACnB,GAAA;AAAA;;;;UAMc,mBAAA;EAIf;EAFA,aAAA,CAAc,KAAA,EAAO,UAAA;EAIrB;EAFA,OAAA,EAAS,aAAA;EAEF;EAAP,OAAA;AAAA;;;;KAMU,YAAA,IAAgB,OAAA,EAAS,mBAAA;;;;UAKpB,YAAA;EAQL;EANV,cAAA,GAAiB,UAAA;EAMM;EAJvB,eAAA,GAAkB,YAAA;EAFD;EAIjB,OAAA;EAFkB;EAIlB,OAAA,GAAU,aAAA;AAAA;;;;UAMK,UAAA;EAAU;EAEzB,OAAA;AAAA;;AAMF;;UAAiB,aAAA;EAES;EAAxB,UAAA,EAAY,GAAA,SAAY,mBAAA;EAEjB;EAAP,IAAA,GAAO,UAAA;AAAA;;;UCpDQ,cAAA,SAAuB,aAAA;;EAEtC,aAAA,EAAe,UAAA;ED3DY;EC6D3B,OAAA,EAAS,aAAA;ED7DkB;EC+D3B,OAAA;EACA,YAAA,CAAa,IAAA,WAAe,mBAAA;EAC5B,iBAAA;EACA,YAAA,CAAa,IAAA;AAAA;;;;;;iBAQC,YAAA,CAAa,MAAA,EAAQ,YAAA,GAAe,cAAA;ADzDpD;;;AAAA,iBC2GgB,YAAA,CAAa,MAAA,EAAQ,aAAA,EAAe,IAAA,WAAe,mBAAA;;ADhGnE;;iBCuGgB,YAAA,CAAa,MAAA,EAAQ,aAAA,EAAe,IAAA;;;ADlGpD;iBCyGgB,iBAAA,CAAkB,MAAA,EAAQ,aAAA;;;UCpIzB,gBAAA;EACf,KAAA;EACA,MAAA,EAAQ,WAAA;AAAA;;;AFHV;;iBEUgB,cAAA,CACd,MAAA,EAAQ,aAAA,EACR,aAAA,UACA,MAAA,YACC,gBAAA;;;;;iBAuBa,+BAAA,CACd,SAAA,EAAW,mBAAA,EACX,MAAA,YACC,gBAAA"}

package/dist/index.mjs

@@ -0,0 +1,169 @@
+import AjvDefault from "ajv";
+import addFormatsDefault from "ajv-formats";
+
+//#region src/registry.ts
+const DEFAULT_REFERENCE_MODE = "id";
+function resolveOptions(configOptions) {
+	return {
+		slotReferenceMode: DEFAULT_REFERENCE_MODE,
+		...configOptions
+	};
+}
+function toSlotDefinition(slot, referenceMode) {
+	return {
+		name: slot.name,
+		multiple: slot.multiple,
+		referenceMode
+	};
+}
+function toBlockTypeDefinition(block, referenceMode) {
+	return {
+		name: block.name,
+		configSchema: block.configSchema,
+		slots: block.slots.map((s) => toSlotDefinition(s, referenceMode))
+	};
+}
+function buildContentSchema(blockNames) {
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		type: "object",
+		required: ["entryId", "nodes"],
+		properties: {
+			entryId: { type: "string" },
+			nodes: {
+				type: "object",
+				additionalProperties: { $ref: "#/definitions/ContentNode" }
+			}
+		},
+		definitions: { ContentNode: {
+			type: "object",
+			required: [
+				"id",
+				"block",
+				"config"
+			],
+			properties: {
+				id: { type: "string" },
+				block: blockNames.length > 0 ? {
+					type: "string",
+					enum: blockNames
+				} : { type: "string" },
+				config: { type: "object" }
+			},
+			additionalProperties: true
+		} }
+	};
+}
+/**
+* Creates a schema from config. Runs plugins (which can register blocks and add options),
+* then builds block types with global slotReferenceMode. Returns the schema with getters
+* and a contentSchema (JSON Schema for the content document).
+*/
+function createSchema(config) {
+	const blocks = [...config.registerBlocks ?? []];
+	const options = resolveOptions(config.options);
+	const context = {
+		registerBlock(block) {
+			blocks.push(block);
+		},
+		options,
+		version: config.version
+	};
+	for (const plugin of config.registerPlugins ?? []) plugin(context);
+	const referenceMode = options.slotReferenceMode ?? DEFAULT_REFERENCE_MODE;
+	const blockTypes = /* @__PURE__ */ new Map();
+	for (const block of blocks) blockTypes.set(block.name, toBlockTypeDefinition(block, referenceMode));
+	const contentSchema = buildContentSchema(Array.from(blockTypes.keys()));
+	return {
+		blockTypes,
+		meta: config.version !== void 0 ? { version: config.version } : void 0,
+		contentSchema,
+		options,
+		version: config.version,
+		getBlockType(name) {
+			return blockTypes.get(name);
+		},
+		getBlockTypeNames() {
+			return Array.from(blockTypes.keys());
+		},
+		hasBlockType(name) {
+			return blockTypes.has(name);
+		}
+	};
+}
+/**
+* Returns the block type definition for the given name, or undefined if not registered.
+*/
+function getBlockType(schema, name) {
+	return schema.blockTypes.get(name);
+}
+/**
+* Returns true if the schema has a block type with the given name.
+*/
+function hasBlockType(schema, name) {
+	return schema.blockTypes.has(name);
+}
+/**
+* Returns all registered block type names.
+*/
+function getBlockTypeNames(schema) {
+	return Array.from(schema.blockTypes.keys());
+}
+
+//#endregion
+//#region src/validate.ts
+const Ajv = AjvDefault;
+const addFormats = addFormatsDefault;
+const ajv = new Ajv({
+	allErrors: true,
+	strict: false
+});
+addFormats(ajv);
+/**
+* Validates a config object against a block type's JSON Schema.
+* Returns { valid: true, errors: null } on success, or { valid: false, errors } on failure.
+*/
+function validateConfig(schema, blockTypeName, config) {
+	const blockType = getBlockType(schema, blockTypeName);
+	if (!blockType) return {
+		valid: false,
+		errors: [{
+			instancePath: "",
+			schemaPath: "",
+			keyword: "blockType",
+			message: `Unknown block type: ${blockTypeName}`,
+			params: {}
+		}]
+	};
+	return validateConfigAgainstDefinition(blockType, config);
+}
+/**
+* Validates a config object against a block type definition's JSON Schema.
+* Use this when you already have the BlockTypeDefinition (e.g. from getBlockType).
+*/
+function validateConfigAgainstDefinition(blockType, config) {
+	let validate;
+	try {
+		validate = ajv.compile(blockType.configSchema);
+	} catch (err) {
+		return {
+			valid: false,
+			errors: [{
+				instancePath: "",
+				schemaPath: "",
+				keyword: "schema",
+				message: err instanceof Error ? err.message : "Invalid config schema",
+				params: {}
+			}]
+		};
+	}
+	const valid = validate(config);
+	return {
+		valid,
+		errors: valid ? null : validate.errors ?? []
+	};
+}
+
+//#endregion
+export { createSchema, getBlockType, getBlockTypeNames, hasBlockType, validateConfig, validateConfigAgainstDefinition };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/registry.ts","../src/validate.ts"],"sourcesContent":["import type {\n  BlockInput,\n  BlockTypeDefinition,\n  GenetikSchema,\n  JsonSchema,\n  SchemaConfig,\n  SchemaOptions,\n  SlotDefinition,\n  SlotReferenceMode,\n} from \"./types.js\";\n\nconst DEFAULT_REFERENCE_MODE: SlotReferenceMode = \"id\";\n\nfunction resolveOptions(configOptions?: SchemaOptions): SchemaOptions {\n  return {\n    slotReferenceMode: DEFAULT_REFERENCE_MODE,\n    ...configOptions,\n  };\n}\n\nfunction toSlotDefinition(slot: { name: string; multiple: boolean }, referenceMode: SlotReferenceMode): SlotDefinition {\n  return {\n    name: slot.name,\n    multiple: slot.multiple,\n    referenceMode,\n  };\n}\n\nfunction toBlockTypeDefinition(block: BlockInput, referenceMode: SlotReferenceMode): BlockTypeDefinition {\n  return {\n    name: block.name,\n    configSchema: block.configSchema,\n    slots: block.slots.map((s) => toSlotDefinition(s, referenceMode)),\n  };\n}\n\nfunction buildContentSchema(blockNames: string[]): JsonSchema {\n  return {\n    $schema: \"https://json-schema.org/draft/2020-12/schema\",\n    type: \"object\",\n    required: [\"entryId\", \"nodes\"],\n    properties: {\n      entryId: { type: \"string\" },\n      nodes: {\n        type: \"object\",\n        additionalProperties: { $ref: \"#/definitions/ContentNode\" },\n      },\n    },\n    definitions: {\n      ContentNode: {\n        type: \"object\",\n        required: [\"id\", \"block\", \"config\"],\n        properties: {\n          id: { type: \"string\" },\n          block: blockNames.length > 0 ? { type: \"string\", enum: blockNames } : { type: \"string\" },\n          config: { type: \"object\" },\n        },\n        additionalProperties: true,\n      },\n    },\n  };\n}\n\nexport interface SchemaInstance extends GenetikSchema {\n  /** JSON Schema that describes the content document (entryId + nodes). */\n  contentSchema: JsonSchema;\n  /** Resolved options (includes slotReferenceMode). */\n  options: SchemaOptions;\n  /** Schema version if set. */\n  version?: string;\n  getBlockType(name: string): BlockTypeDefinition | undefined;\n  getBlockTypeNames(): string[];\n  hasBlockType(name: string): boolean;\n}\n\n/**\n * Creates a schema from config. Runs plugins (which can register blocks and add options),\n * then builds block types with global slotReferenceMode. Returns the schema with getters\n * and a contentSchema (JSON Schema for the content document).\n */\nexport function createSchema(config: SchemaConfig): SchemaInstance {\n  const blocks: BlockInput[] = [...(config.registerBlocks ?? [])];\n  const options = resolveOptions(config.options);\n\n  const context: import(\"./types.js\").SchemaPluginContext = {\n    registerBlock(block: BlockInput) {\n      blocks.push(block);\n    },\n    options,\n    version: config.version,\n  };\n\n  for (const plugin of config.registerPlugins ?? []) {\n    plugin(context);\n  }\n\n  const referenceMode = (options.slotReferenceMode ?? DEFAULT_REFERENCE_MODE) as SlotReferenceMode;\n  const blockTypes = new Map<string, BlockTypeDefinition>();\n  for (const block of blocks) {\n    blockTypes.set(block.name, toBlockTypeDefinition(block, referenceMode));\n  }\n\n  const blockNames = Array.from(blockTypes.keys());\n  const contentSchema = buildContentSchema(blockNames);\n\n  const schema: GenetikSchema = {\n    blockTypes,\n    meta: config.version !== undefined ? { version: config.version } : undefined,\n  };\n\n  return {\n    ...schema,\n    contentSchema,\n    options,\n    version: config.version,\n    getBlockType(name: string) {\n      return blockTypes.get(name);\n    },\n    getBlockTypeNames() {\n      return Array.from(blockTypes.keys());\n    },\n    hasBlockType(name: string) {\n      return blockTypes.has(name);\n    },\n  };\n}\n\n/**\n * Returns the block type definition for the given name, or undefined if not registered.\n */\nexport function getBlockType(schema: GenetikSchema, name: string): BlockTypeDefinition | undefined {\n  return schema.blockTypes.get(name);\n}\n\n/**\n * Returns true if the schema has a block type with the given name.\n */\nexport function hasBlockType(schema: GenetikSchema, name: string): boolean {\n  return schema.blockTypes.has(name);\n}\n\n/**\n * Returns all registered block type names.\n */\nexport function getBlockTypeNames(schema: GenetikSchema): string[] {\n  return Array.from(schema.blockTypes.keys());\n}\n","import AjvDefault from \"ajv\";\nimport addFormatsDefault from \"ajv-formats\";\nimport type { ErrorObject, ValidateFunction } from \"ajv\";\nimport type { BlockTypeDefinition, GenetikSchema } from \"./types.js\";\nimport { getBlockType } from \"./registry.js\";\n\n// ESM/NodeNext: default export types don't expose constructor/call; assert through unknown\nconst Ajv = AjvDefault as unknown as new (opts?: { allErrors?: boolean; strict?: boolean }) => { compile: (schema: object) => ValidateFunction };\nconst addFormats = addFormatsDefault as unknown as (ajv: InstanceType<typeof Ajv>) => void;\nconst ajv = new Ajv({ allErrors: true, strict: false });\naddFormats(ajv);\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: ErrorObject[] | null;\n}\n\n/**\n * Validates a config object against a block type's JSON Schema.\n * Returns { valid: true, errors: null } on success, or { valid: false, errors } on failure.\n */\nexport function validateConfig(\n  schema: GenetikSchema,\n  blockTypeName: string,\n  config: unknown\n): ValidationResult {\n  const blockType = getBlockType(schema, blockTypeName);\n  if (!blockType) {\n    return {\n      valid: false,\n      errors: [\n        {\n          instancePath: \"\",\n          schemaPath: \"\",\n          keyword: \"blockType\",\n          message: `Unknown block type: ${blockTypeName}`,\n          params: {},\n        } satisfies ErrorObject,\n      ],\n    };\n  }\n  return validateConfigAgainstDefinition(blockType, config);\n}\n\n/**\n * Validates a config object against a block type definition's JSON Schema.\n * Use this when you already have the BlockTypeDefinition (e.g. from getBlockType).\n */\nexport function validateConfigAgainstDefinition(\n  blockType: BlockTypeDefinition,\n  config: unknown\n): ValidationResult {\n  let validate: ValidateFunction;\n  try {\n    validate = ajv.compile(blockType.configSchema);\n  } catch (err) {\n    return {\n      valid: false,\n      errors: [\n        {\n          instancePath: \"\",\n          schemaPath: \"\",\n          keyword: \"schema\",\n          message: err instanceof Error ? err.message : \"Invalid config schema\",\n          params: {},\n        } satisfies ErrorObject,\n      ],\n    };\n  }\n  const valid = validate(config);\n  return {\n    valid,\n    errors: valid ? null : (validate.errors ?? []),\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@genetik/schema",
+  "version": "0.0.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1"
+  },
+  "devDependencies": {
+    "eslint": "^9.39.1",
+    "tsdown": "0.20.3",
+    "typescript": "5.9.2",
+    "vitest": "^2.1.8",
+    "@genetik/eslint-config": "0.0.0",
+    "@genetik/typescript-config": "0.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "eslint . --max-warnings 0",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}