@abraca/schema 2.3.0

package/src/manifest/plugin-manifest.ts

@@ -0,0 +1,212 @@
+/**
+ * Runtime validation schema for plugin manifests (manifest v1).
+ *
+ * The TypeScript types live in `@abraca/plugin/src/manifest.ts` and stay
+ * pure — `@abraca/plugin` itself ships zero schemas per `feedback_schema_free_core`.
+ * This file is the opt-in Zod validator used by:
+ *
+ * - the registry server's submission pipeline (verifies submitted manifests
+ *   before storing the artifact)
+ * - the `@abraca/plugin-cli` `validate` command (local pre-submit linting)
+ * - hosts (`cou-shell`, `@abraca/nuxt`) before instantiating an external
+ *   plugin, when they want runtime validation in addition to the
+ *   compile-time `PluginManifest` typing.
+ *
+ * The inferred shape is asserted to be structurally identical to
+ * `PluginManifest` from `@abraca/plugin` via `_check` type aliases below —
+ * if either side drifts, the typecheck fails.
+ */
+
+import { z } from "zod";
+
+import type {
+	PluginManifest,
+	PluginCapability,
+} from "@abraca/plugin";
+
+// ── Capability vocabulary ─────────────────────────────────────────────────────
+
+/**
+ * Capabilities with no dynamic suffix. Anything outside this set and the two
+ * prefix families (`network[:*]`, `page-type:<slug>`) is rejected.
+ *
+ * Encoded as a regex pattern (not a `.refine()` callback) so the
+ * Zod-to-JSON-Schema codegen captures it — otherwise the registry server's
+ * Rust validator would have to re-implement the vocabulary in parallel.
+ */
+const CAPABILITY_PATTERN =
+	"^(fs:read|fs:write|clipboard:read|clipboard:write|doc-read|doc-write|awareness|server-runner|command-palette|toolbar|bubble-menu|slash-command|drag-handle|chat:send|chat:read|notifications:show|network|network:\\S+|page-type:[a-z][a-z0-9-]*)$";
+
+export const PluginCapabilitySchema = z
+	.string()
+	.regex(new RegExp(CAPABILITY_PATTERN), {
+		message:
+			"unknown plugin capability — see PluginCapability in @abraca/plugin",
+	})
+	.transform((s) => s as PluginCapability);
+
+// ── Primitive field schemas ───────────────────────────────────────────────────
+
+/** Lowercase-kebab slug. Starts with a letter; no consecutive dashes; no trailing dash. */
+export const PluginIdSchema = z
+	.string()
+	.regex(
+		/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
+		"id must be lowercase-kebab (e.g. 'spatial', 'plugin-coder', 'my-2nd-plugin')",
+	);
+
+/**
+ * Strict semver `MAJOR.MINOR.PATCH` with optional pre-release / build metadata.
+ * Reference: https://semver.org/spec/v2.0.0.html#backusnaur-form-grammar-for-valid-semver-versions
+ */
+export const SemverSchema = z
+	.string()
+	.regex(
+		/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/,
+		"version must be valid semver (e.g. '1.2.3', '0.1.0-alpha.1')",
+	);
+
+/**
+ * Loose semver range — accepts `^1.2.3`, `~1.2`, `>=1.0 <2`, `1.x`, etc.
+ * Not parsed here; the registry server runs `semver.validRange` for strict
+ * validation. We just guard against obvious junk.
+ */
+export const SemverRangeSchema = z
+	.string()
+	.min(1)
+	.max(80)
+	.regex(/^[\d.xX*~^<>=|\s&,a-zA-Z+-]+$/, "invalid semver range");
+
+/** `sha256-<64 hex chars>`. */
+export const IntegritySchema = z
+	.string()
+	.regex(
+		/^sha256-[0-9a-f]{64}$/,
+		"integrity must be 'sha256-' + 64 lowercase hex chars",
+	);
+
+/** Relative POSIX path. No `..` segments, no absolute, no protocols. */
+export const RelativePathSchema = z
+	.string()
+	.min(1)
+	.max(256)
+	.refine(
+		(p) =>
+			!p.startsWith("/") &&
+			!/^[a-z]+:\/\//i.test(p) &&
+			!p.split("/").includes(".."),
+		"must be a relative path with no '..' segments",
+	);
+
+// ── Sub-schemas ───────────────────────────────────────────────────────────────
+
+export const PluginManifestAuthorSchema = z.object({
+	github: z.string().min(1).max(64).optional(),
+	name: z.string().min(1).max(120).optional(),
+	url: z.string().url().max(512).optional(),
+	email: z.string().email().max(254).optional(),
+});
+
+export const PluginPricingSchema = z.enum(["free", "optional", "paid"]);
+
+export const PluginVersionStatusSchema = z.enum([
+	"live",
+	"pending",
+	"rejected",
+	"superseded",
+]);
+
+export const PluginManifestContributesSchema = z.object({
+	pageTypes: z.array(z.string().min(1)).readonly().optional(),
+	extensions: z.array(z.string().min(1)).readonly().optional(),
+	awarenessFields: z.array(z.string().min(1)).readonly().optional(),
+	serverRunners: z.array(z.string().min(1)).readonly().optional(),
+	commands: z.array(z.string().min(1)).readonly().optional(),
+	settingsPanels: z.array(z.string().min(1)).readonly().optional(),
+});
+
+// ── Top-level manifest schema ─────────────────────────────────────────────────
+
+export const PluginManifestSchema = z.object({
+	manifestVersion: z.literal(1),
+	id: PluginIdSchema,
+	name: z.string().min(1).max(80).optional(),
+	version: SemverSchema,
+	author: PluginManifestAuthorSchema,
+	license: z.string().min(1).max(80),
+	description: z.string().min(1).max(280),
+	readme: z.string().max(100_000).optional(),
+	homepage: z.string().url().max(512).optional(),
+	/** `github:org/repo` shorthand or any URL — registry server normalises. */
+	repository: z
+		.string()
+		.min(3)
+		.max(512)
+		.optional(),
+	minAbracadabraVersion: SemverRangeSchema.optional(),
+	entry: RelativePathSchema,
+	integrity: IntegritySchema,
+	pricing: PluginPricingSchema.optional(),
+	screenshots: z.array(RelativePathSchema).max(20).readonly().optional(),
+	categories: z.array(z.string().min(1).max(40)).max(10).readonly().optional(),
+	capabilities: z.object({
+		required: z.array(PluginCapabilitySchema).readonly(),
+		optional: z.array(PluginCapabilitySchema).readonly().optional(),
+	}),
+	contributes: PluginManifestContributesSchema.optional(),
+	peerDeps: z.record(z.string(), SemverRangeSchema).optional(),
+});
+
+// ── Type identity assertions ──────────────────────────────────────────────────
+//
+// If either of these aliases fails to typecheck, the Zod schema has drifted
+// from `PluginManifest` in @abraca/plugin and the two halves of the contract
+// are out of sync. CI runs vue-tsc which catches the drift at build time.
+
+type _SchemaInfersPluginManifest = z.infer<typeof PluginManifestSchema> extends PluginManifest
+	? true
+	: never;
+
+type _PluginManifestSatisfiesSchema = PluginManifest extends z.infer<typeof PluginManifestSchema>
+	? true
+	: never;
+
+// Force the aliases to be referenced so tsc doesn't elide them.
+const _check1: _SchemaInfersPluginManifest = true;
+const _check2: _PluginManifestSatisfiesSchema = true;
+void _check1;
+void _check2;
+
+// ── Convenience helpers ───────────────────────────────────────────────────────
+
+export interface ManifestValidationIssue {
+	readonly path: ReadonlyArray<PropertyKey>;
+	readonly message: string;
+	readonly code?: string;
+}
+
+export type ManifestValidationResult =
+	| { ok: true; value: PluginManifest }
+	| { ok: false; errors: ReadonlyArray<ManifestValidationIssue> };
+
+/**
+ * Parse and validate a manifest. Always returns a result object — never
+ * throws. Useful for surface UIs (the registry submission flow, the CLI's
+ * `validate` command) that want to render every issue at once.
+ */
+export function validatePluginManifest(
+	value: unknown,
+): ManifestValidationResult {
+	const parsed = PluginManifestSchema.safeParse(value);
+	if (parsed.success) {
+		return { ok: true, value: parsed.data as PluginManifest };
+	}
+	return {
+		ok: false,
+		errors: parsed.error.issues.map((i) => ({
+			path: i.path,
+			message: i.message,
+			code: i.code,
+		})),
+	};
+}

package/src/query.ts

@@ -0,0 +1,150 @@
+/**
+ * V2 query layer — predicate AST.
+ *
+ * Mirrors InstantDB / Prisma `where` shapes: column → predicate pairs
+ * composed with boolean AND/OR/NOT. The Rust compiler at
+ * `crates/abracadabra/src/query.rs` walks the same shape and emits
+ * indexed SQL against `doc_meta_index`.
+ *
+ * Columns are restricted to the universal-meta projection: `priority`,
+ * `dateStart`, `dateEnd`, `tags`, `status`, `assignedTo`. Anything else
+ * is rejected. Adding a column requires both:
+ *   1. A new column on `doc_meta_index` (migration in `abracadabra-rs`)
+ *   2. A new entry in `META_COLUMNS` below
+ *
+ * The schema is intentionally narrow — only the operators the v2 query
+ * layer can actually execute against indexed columns are accepted. New
+ * operators require server changes; the schema is the contract.
+ */
+
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Columns
+// ---------------------------------------------------------------------------
+
+/**
+ * Whitelisted indexed columns on `doc_meta_index`. Adding to this list
+ * requires a parallel migration on the server. Order is the canonical
+ * documentation order — not enforced.
+ */
+export const META_COLUMNS = [
+	"priority",
+	"dateStart",
+	"dateEnd",
+	"tags",
+	"status",
+	"assignedTo",
+] as const;
+
+export type MetaColumn = (typeof META_COLUMNS)[number];
+
+const ColumnEnum = z.enum(META_COLUMNS);
+
+// ---------------------------------------------------------------------------
+// Operators
+// ---------------------------------------------------------------------------
+
+const ScalarValue = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+
+/**
+ * Numeric / lexicographic comparison operators. Apply to integer
+ * (`priority`), date (`dateStart`, `dateEnd`), and string
+ * (`status`, `assignedTo`) columns. Strings compare lexicographically
+ * — useful for date filtering on the SQLite path where dates are TEXT.
+ */
+const RangeOps = z.strictObject({
+	eq: ScalarValue.optional(),
+	neq: ScalarValue.optional(),
+	gt: ScalarValue.optional(),
+	gte: ScalarValue.optional(),
+	lt: ScalarValue.optional(),
+	lte: ScalarValue.optional(),
+	in: z.array(ScalarValue).optional(),
+	between: z.tuple([ScalarValue, ScalarValue]).optional(),
+});
+
+/**
+ * Operators for the `tags` column. `tags` is a JSON array.
+ * `contains: "x"` matches when the array includes the string `x`.
+ * `containsAll: ["x","y"]` requires all listed tags to be present.
+ * `containsAny: ["x","y"]` requires at least one.
+ */
+const TagOps = z.strictObject({
+	contains: z.string().optional(),
+	containsAll: z.array(z.string()).optional(),
+	containsAny: z.array(z.string()).optional(),
+	isEmpty: z.boolean().optional(),
+});
+
+/** Per-column predicate. `null` => column IS NULL. */
+const ColumnPredicate = z.union([
+	ScalarValue, // shorthand `{ priority: 3 }` == `{ priority: { eq: 3 } }`
+	RangeOps,
+	TagOps,
+]);
+
+// ---------------------------------------------------------------------------
+// Composition
+// ---------------------------------------------------------------------------
+
+/**
+ * A clause is either:
+ *   - A leaf: `{ column: predicate, ... }` with multiple columns AND-ed
+ *     implicitly.
+ *   - A composition node: `{ AND: [clause, ...] }`, `{ OR: [...] }`,
+ *     `{ NOT: clause }`.
+ *
+ * The Zod schema below tolerates mixing leaf columns and composer keys
+ * at the same level; the Rust compiler rejects that case with a clear
+ * error. Keeping the Zod schema permissive on this point lets us evolve
+ * the rule without re-versioning the wire shape.
+ */
+export interface WhereClause {
+	readonly AND?: ReadonlyArray<WhereClause>;
+	readonly OR?: ReadonlyArray<WhereClause>;
+	readonly NOT?: WhereClause;
+	readonly priority?: z.infer<typeof ColumnPredicate>;
+	readonly dateStart?: z.infer<typeof ColumnPredicate>;
+	readonly dateEnd?: z.infer<typeof ColumnPredicate>;
+	readonly tags?: z.infer<typeof ColumnPredicate>;
+	readonly status?: z.infer<typeof ColumnPredicate>;
+	readonly assignedTo?: z.infer<typeof ColumnPredicate>;
+}
+
+export const WhereClauseSchema: z.ZodType<WhereClause> = z.lazy(() =>
+	z.strictObject({
+		AND: z.array(WhereClauseSchema).optional(),
+		OR: z.array(WhereClauseSchema).optional(),
+		NOT: WhereClauseSchema.optional(),
+		priority: ColumnPredicate.optional(),
+		dateStart: ColumnPredicate.optional(),
+		dateEnd: ColumnPredicate.optional(),
+		tags: ColumnPredicate.optional(),
+		status: ColumnPredicate.optional(),
+		assignedTo: ColumnPredicate.optional(),
+	}),
+);
+
+/**
+ * Parse + normalise a raw `where` object. Returns a discriminated
+ * result so call sites can render server-friendly error messages on
+ * the wire.
+ */
+export function parseWhereClause(
+	raw: unknown,
+):
+	| { ok: true; value: WhereClause }
+	| { ok: false; errors: ReadonlyArray<{ path: ReadonlyArray<PropertyKey>; message: string }> } {
+	const parsed = WhereClauseSchema.safeParse(raw);
+	if (parsed.success) {
+		return { ok: true, value: parsed.data };
+	}
+	return {
+		ok: false,
+		errors: parsed.error.issues.map((i) => ({
+			path: i.path,
+			message: i.message,
+		})),
+	};
+}

package/src/types/calendar.ts

@@ -0,0 +1,23 @@
+/**
+ * `calendar` — event calendar with month/week/day views. Direct
+ * children are events (untyped); per-event `datetimeStart` /
+ * `datetimeEnd` / `allDay` / `color` use universal keys.
+ */
+
+import { z } from "zod";
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const CalendarMeta = UniversalMeta.extend({
+	calendarWeekStart: z.enum(["sun", "mon"]).optional(),
+	calendarView: z.enum(["month", "week", "day"]).optional(),
+	calendarShowWeekNumbers: z.boolean().optional(),
+});
+
+export const Calendar = defineDocType({
+	name: "calendar",
+	version: 1,
+	meta: CalendarMeta,
+});
+
+export const calendarSchema = defineSchema({ types: [Calendar] });

package/src/types/chart.ts

@@ -0,0 +1,36 @@
+/**
+ * `chart` — manual data points or aggregation over document trees.
+ * Direct children are data points (untyped); per-point `number` /
+ * `color` / `tags` use universal keys.
+ */
+
+import { z } from "zod";
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const ChartMeta = UniversalMeta.extend({
+	chartType: z.enum(["bar", "stacked bar", "line", "donut", "treemap"]).optional(),
+	chartMetric: z
+		.enum([
+			"value",
+			"type",
+			"tag",
+			"status",
+			"priority",
+			"activity",
+			"completion",
+		])
+		.optional(),
+	chartColorScheme: z.enum(["default", "warm", "cool", "mono"]).optional(),
+	chartLimit: z.number().int().min(3).max(30).optional(),
+	chartShowLegend: z.boolean().optional(),
+	chartShowValues: z.boolean().optional(),
+});
+
+export const Chart = defineDocType({
+	name: "chart",
+	version: 1,
+	meta: ChartMeta,
+});
+
+export const chartSchema = defineSchema({ types: [Chart] });

package/src/types/checklist.ts

@@ -0,0 +1,22 @@
+/**
+ * `checklist` — collaborative checklist with sub-tasks and due dates.
+ * Unlimited descendant nesting; all descendants are untyped (per-task
+ * `checked` / `priority` / `dateEnd` flow through universal keys).
+ */
+
+import { z } from "zod";
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const ChecklistMeta = UniversalMeta.extend({
+	checklistFilter: z.enum(["all", "active", "completed"]).optional(),
+	checklistSort: z.enum(["manual", "priority", "due"]).optional(),
+});
+
+export const Checklist = defineDocType({
+	name: "checklist",
+	version: 1,
+	meta: ChecklistMeta,
+});
+
+export const checklistSchema = defineSchema({ types: [Checklist] });

package/src/types/dashboard.ts

@@ -0,0 +1,18 @@
+/**
+ * `dashboard` — arranges documents as draggable icons / widgets.
+ * Descendants are untyped; per-item `desk*` layout keys flow through
+ * the untyped meta path.
+ */
+
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const DashboardMeta = UniversalMeta;
+
+export const Dashboard = defineDocType({
+	name: "dashboard",
+	version: 1,
+	meta: DashboardMeta,
+});
+
+export const dashboardSchema = defineSchema({ types: [Dashboard] });

package/src/types/doc.ts

@@ -0,0 +1,19 @@
+/**
+ * `doc` — the default rich-text page type. Body is a TipTap-backed
+ * `Y.Text`; descendants are untyped tree entries.
+ */
+
+import { defineDocType, defineSchema } from "../index.ts";
+import { ytext } from "../crdt.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const DocMeta = UniversalMeta;
+
+export const Doc = defineDocType({
+	name: "doc",
+	version: 1,
+	meta: DocMeta,
+	body: ytext(),
+});
+
+export const docSchema = defineSchema({ types: [Doc] });

package/src/types/gallery.ts

@@ -0,0 +1,24 @@
+/**
+ * `gallery` — visual grid of items with rich content. Direct children
+ * are items (untyped tree entries).
+ */
+
+import { z } from "zod";
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const GalleryMeta = UniversalMeta.extend({
+	galleryColumns: z.number().int().min(1).max(6).optional(),
+	galleryAspect: z.enum(["square", "4:3", "3:2", "16:9", "free"]).optional(),
+	galleryCardStyle: z.enum(["default", "compact", "detailed"]).optional(),
+	galleryShowLabels: z.boolean().optional(),
+	gallerySortBy: z.enum(["manual", "date", "name", "rating"]).optional(),
+});
+
+export const Gallery = defineDocType({
+	name: "gallery",
+	version: 1,
+	meta: GalleryMeta,
+});
+
+export const gallerySchema = defineSchema({ types: [Gallery] });

package/src/types/graph.ts

@@ -0,0 +1,21 @@
+/**
+ * `graph` — force-directed knowledge graph rendering. Descendants are
+ * untyped (per-node `graphX` / `graphY` / `graphPinned` are written to
+ * descendant meta but not validated by the registry).
+ */
+
+import { z } from "zod";
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const GraphMeta = UniversalMeta.extend({
+	showRefEdges: z.boolean().optional(),
+});
+
+export const Graph = defineDocType({
+	name: "graph",
+	version: 1,
+	meta: GraphMeta,
+});
+
+export const graphSchema = defineSchema({ types: [Graph] });

package/src/types/kanban.ts

@@ -0,0 +1,27 @@
+/**
+ * `kanban` — drag-and-drop board. Direct children are columns;
+ * grandchildren are cards. Both descendants are untyped tree entries
+ * — only the board itself carries `type: "kanban"` and the per-board
+ * view-config keys below.
+ */
+
+import { z } from "zod";
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const KanbanMeta = UniversalMeta.extend({
+	kanbanColumnWidth: z.enum(["narrow", "default", "wide"]).optional(),
+	kanbanShowIcon: z.boolean().optional(),
+	kanbanShowTags: z.boolean().optional(),
+	kanbanShowPriority: z.boolean().optional(),
+	kanbanShowDueDate: z.boolean().optional(),
+	kanbanShowCover: z.boolean().optional(),
+});
+
+export const Kanban = defineDocType({
+	name: "kanban",
+	version: 1,
+	meta: KanbanMeta,
+});
+
+export const kanbanSchema = defineSchema({ types: [Kanban] });

package/src/types/map.ts

@@ -0,0 +1,21 @@
+/**
+ * `map` — collaborative world map. Direct children are markers / lines
+ * / measure entries (untyped, distinguished by descendant `geoType`
+ * key flowing through the untyped meta path).
+ */
+
+import { z } from "zod";
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const MapMeta = UniversalMeta.extend({
+	mapShowLabels: z.boolean().optional(),
+});
+
+export const MapDocType = defineDocType({
+	name: "map",
+	version: 1,
+	meta: MapMeta,
+});
+
+export const mapSchema = defineSchema({ types: [MapDocType] });

package/src/types/outline.ts

@@ -0,0 +1,17 @@
+/**
+ * `outline` — hierarchical outline with keyboard navigation. Unlimited
+ * descendant nesting; all descendants are untyped.
+ */
+
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const OutlineMeta = UniversalMeta;
+
+export const Outline = defineDocType({
+	name: "outline",
+	version: 1,
+	meta: OutlineMeta,
+});
+
+export const outlineSchema = defineSchema({ types: [Outline] });

package/src/types/overview.ts

@@ -0,0 +1,17 @@
+/**
+ * `overview` — space home: activity, people, stats. Descendants are
+ * regular pages; no overview-specific config keys today.
+ */
+
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const OverviewMeta = UniversalMeta;
+
+export const Overview = defineDocType({
+	name: "overview",
+	version: 1,
+	meta: OverviewMeta,
+});
+
+export const overviewSchema = defineSchema({ types: [Overview] });

package/src/types/prose.ts

@@ -0,0 +1,19 @@
+/**
+ * `prose` — long-form prose with serif typography. Same body shape as
+ * `doc` (Y.Text TipTap content); descendants are untyped.
+ */
+
+import { defineDocType, defineSchema } from "../index.ts";
+import { ytext } from "../crdt.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const ProseMeta = UniversalMeta;
+
+export const Prose = defineDocType({
+	name: "prose",
+	version: 1,
+	meta: ProseMeta,
+	body: ytext(),
+});
+
+export const proseSchema = defineSchema({ types: [Prose] });

package/src/types/sheets.ts

@@ -0,0 +1,24 @@
+/**
+ * `sheets` — spreadsheet with formulas + formatting. Direct children
+ * are columns; grandchildren are positional cells (both untyped).
+ * Per-cell `formula` / `bold` / `bgColor` / `numberFormat` etc. flow
+ * through the untyped meta path.
+ */
+
+import { z } from "zod";
+import { defineDocType, defineSchema } from "../index.ts";
+import { UniversalMeta } from "./universal.ts";
+
+export const SheetsMeta = UniversalMeta.extend({
+	sheetsDefaultColWidth: z.number().min(40).max(500).optional(),
+	sheetsDefaultRowHeight: z.number().min(20).max(100).optional(),
+	sheetsShowGridlines: z.boolean().optional(),
+});
+
+export const Sheets = defineDocType({
+	name: "sheets",
+	version: 1,
+	meta: SheetsMeta,
+});
+
+export const sheetsSchema = defineSchema({ types: [Sheets] });