@abraca/dabra 2.0.9 → 2.3.0

package/src/BackgroundSyncManager.ts

@@ -73,6 +73,19 @@ class Semaphore {
 	}
 }
 
+/**
+ * Server-accepted doc-id format. The Rust server's `DocId::from_string`
+ * is a strict UUID parse; any other string returns 422. Stale entries in
+ * the doc-tree map (legacy slug ids from earlier demos, manual experiments)
+ * would otherwise emit one 422 per `syncAll()` forever — see the warn
+ * below in `_buildQueue`.
+ */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function isValidDocId(id: string): boolean {
+	return UUID_RE.test(id);
+}
+
 export class BackgroundSyncManager extends EventEmitter {
 	private readonly rootProvider: AbracadabraProvider;
 	private readonly client: AbracadabraClient;
@@ -82,6 +95,8 @@ export class BackgroundSyncManager extends EventEmitter {
 	private readonly persistence: BackgroundSyncPersistence;
 	private readonly semaphore: Semaphore;
 	private readonly syncStates = new Map<string, DocSyncState>();
+	/** Doc ids we've already warned about; keeps the log to one line per id. */
+	private readonly _warnedInvalidIds = new Set<string>();
 
 	private _destroyed = false;
 	private _initPromise: Promise<void> | null = null;
@@ -298,7 +313,25 @@ export class BackgroundSyncManager extends EventEmitter {
 	private _buildQueue(entries: Array<[string, any]>): string[] {
 		type Sortable = { docId: string; priority: number };
 
-		const items: Sortable[] = entries.map(([docId, v]) => {
+		// Drop ids the server can't parse (non-UUID). One-time warn per id
+		// so the operator can chase down where the stale entry is, but no
+		// log storm on every sync run.
+		const filtered: Array<[string, any]> = [];
+		for (const entry of entries) {
+			const [docId] = entry;
+			if (isValidDocId(docId)) {
+				filtered.push(entry);
+				continue;
+			}
+			if (!this._warnedInvalidIds.has(docId)) {
+				this._warnedInvalidIds.add(docId);
+				console.warn(
+					`[BackgroundSyncManager] skipping non-UUID doc id "${docId}" in doc-tree — server would reject it (422). Likely a stale entry from an earlier seeder; remove it from the tree to silence this.`,
+				);
+			}
+		}
+
+		const items: Sortable[] = filtered.map(([docId, v]) => {
 			const state = this.syncStates.get(docId);
 			const updatedAt: number = v?.updatedAt ?? v?.createdAt ?? 0;
 

package/src/DocumentManager.ts

@@ -31,6 +31,13 @@ import { TreeManager } from "./TreeManager.ts";
 import { ContentManager } from "./ContentManager.ts";
 import { MetaManager } from "./MetaManager.ts";
 import { waitForSync } from "./DocUtils.ts";
+import type { TreeEntry, PageMeta } from "./DocTypes.ts";
+import {
+	projectTreeEntry,
+	TypedDocTypeMismatchError,
+	type SchemaRegistryLike,
+	type TypedDocsClient,
+} from "./SchemaTypes.ts";
 
 export interface DocumentManagerConfig {
 	/** Server base URL (http or https). */
@@ -107,6 +114,69 @@ export class DocumentManager {
 		this.meta = new MetaManager(this);
 	}
 
+	/**
+	 * Bind a schema registry to a typed accessor surface. The returned
+	 * client offers `.get(type, id)` with the registry's meta types
+	 * inferred at the call site, removing the need to pass `schema`
+	 * to every lookup. The provider remains schema-free at runtime —
+	 * `schema` is only used to drive type inference (see
+	 * `SchemaRegistryLike` for the structural witness).
+	 *
+	 * @example
+	 *   const docs = dm.docs(kanbanSchema);
+	 *   const board = docs.get("kanban", id);
+	 *   if (board) console.log(board.meta.kanbanColumnWidth); // typed
+	 */
+	docs<TMap extends Record<string, unknown>>(
+		_schema: SchemaRegistryLike<TMap>,
+	): TypedDocsClient<TMap> {
+		const tree = this.tree;
+		const meta = this.meta;
+		const expectType = <N extends keyof TMap & string>(
+			expected: N,
+			id: string,
+		): void => {
+			const entry = tree.get(id);
+			const actual = entry?.type;
+			if (actual !== expected) {
+				throw new TypedDocTypeMismatchError(id, expected, actual);
+			}
+		};
+		return {
+			get: <N extends keyof TMap & string>(expectedType: N, id: string) =>
+				projectTreeEntry<TMap, N>(tree.get(id), expectedType),
+			getEntry: (id: string) => tree.get(id),
+			narrow: <N extends keyof TMap & string>(
+				expectedType: N,
+				entry: TreeEntry | null | undefined,
+			) => projectTreeEntry<TMap, N>(entry ?? null, expectedType),
+			update: <N extends keyof TMap & string>(
+				expectedType: N,
+				id: string,
+				patch: Partial<TMap[N]>,
+			) => {
+				expectType(expectedType, id);
+				meta.update(id, patch as Partial<PageMeta>);
+			},
+			set: <N extends keyof TMap & string>(
+				expectedType: N,
+				id: string,
+				value: TMap[N],
+			) => {
+				expectType(expectedType, id);
+				meta.set(id, value as unknown as PageMeta);
+			},
+			clear: <N extends keyof TMap & string>(
+				expectedType: N,
+				id: string,
+				keys: ReadonlyArray<keyof TMap[N] & string>,
+			) => {
+				expectType(expectedType, id);
+				meta.clear(id, keys as ReadonlyArray<string> as string[]);
+			},
+		};
+	}
+
 	// ── Accessors ─────────────────────────────────────────────────────────────
 
 	get displayName(): string {

package/src/MetaManager.ts

@@ -2,6 +2,14 @@
  * MetaManager — read/write PageMeta on tree entries.
  *
  * Extracted from `mcp/tools/meta.ts` and `cli/commands/meta.ts`.
+ *
+ * Optionally validates writes against a JSON-Schema-backed validator
+ * (e.g. `@abraca/schema`'s `SchemaRegistry`). The validator is supplied
+ * via {@link MetaManager.setSchema} as a structural value matching
+ * {@link SchemaValidatorLike}; the provider package never imports
+ * `@abraca/schema` directly so core stays schema-free
+ * (`feedback_schema_free_core` Rule 1). When no schema is set,
+ * `update`/`set` behave exactly as before (Rule 4).
  */
 import type { PageMeta } from "./DocTypes.ts";
 import { toPlain } from "./DocUtils.ts";
@@ -14,9 +22,74 @@ export interface DocumentMetaInfo {
 	meta: PageMeta;
 }
 
+/**
+ * Structural shape of a schema validator MetaManager can consult before
+ * writes. Compatible with `@abraca/schema`'s `SchemaRegistry`.
+ *
+ * Implementations MUST treat unknown doc-types as unconstrained
+ * (return `{ ok: true }`) — Rule 4: existing-app traffic for doc-types
+ * not in the validator's bundle is never rejected.
+ */
+export interface SchemaValidatorLike {
+	validateMeta(
+		docType: string,
+		meta: unknown,
+	): { ok: true; value?: unknown } | {
+		ok: false;
+		errors: ReadonlyArray<{
+			path: ReadonlyArray<PropertyKey>;
+			message: string;
+			code?: string;
+		}>;
+	};
+}
+
+export class MetaValidationError extends Error {
+	readonly docId: string;
+	readonly docType: string;
+	readonly errors: ReadonlyArray<{
+		path: ReadonlyArray<PropertyKey>;
+		message: string;
+		code?: string;
+	}>;
+
+	constructor(
+		docId: string,
+		docType: string,
+		errors: ReadonlyArray<{
+			path: ReadonlyArray<PropertyKey>;
+			message: string;
+			code?: string;
+		}>,
+	) {
+		const detail = errors
+			.map((e) => `${e.path.join(".") || "(root)"}: ${e.message}`)
+			.join("; ");
+		super(
+			`Meta validation failed for document ${docId} of type "${docType}": ${detail}`,
+		);
+		this.name = "MetaValidationError";
+		this.docId = docId;
+		this.docType = docType;
+		this.errors = errors;
+	}
+}
+
 export class MetaManager {
+	private schema: SchemaValidatorLike | null = null;
+
 	constructor(private dm: DocumentManager) {}
 
+	/**
+	 * Attach (or detach with `null`) a schema validator. When set, every
+	 * `update` / `set` validates the post-write meta against the entry's
+	 * declared `type` before writing to the doc-tree. Entries without a
+	 * `type` field pass through unconditionally.
+	 */
+	setSchema(schema: SchemaValidatorLike | null): void {
+		this.schema = schema;
+	}
+
 	/** Read metadata for a document. Returns null if not found. */
 	get(docId: string): DocumentMetaInfo | null {
 		const treeMap = this.dm.getTreeMap();
@@ -37,6 +110,9 @@ export class MetaManager {
 	/**
 	 * Merge fields into a document's metadata.
 	 * Existing keys not in the update are preserved.
+	 *
+	 * @throws {MetaValidationError} when a schema is attached and the
+	 *   merged meta fails validation for the entry's declared type.
 	 */
 	update(docId: string, meta: Partial<PageMeta>): void {
 		const treeMap = this.dm.getTreeMap();
@@ -46,9 +122,11 @@ export class MetaManager {
 		if (!raw) throw new Error(`Document ${docId} not found`);
 
 		const entry = toPlain(raw) as Record<string, unknown>;
+		const mergedMeta = { ...((entry.meta as PageMeta) ?? {}), ...meta };
+		this.validateOrThrow(docId, entry, mergedMeta);
 		treeMap.set(docId, {
 			...entry,
-			meta: { ...((entry.meta as PageMeta) ?? {}), ...meta },
+			meta: mergedMeta,
 			updatedAt: Date.now(),
 		});
 	}
@@ -56,6 +134,9 @@ export class MetaManager {
 	/**
 	 * Replace all metadata on a document.
 	 * This overwrites the entire meta object.
+	 *
+	 * @throws {MetaValidationError} when a schema is attached and the
+	 *   replacement meta fails validation for the entry's declared type.
 	 */
 	set(docId: string, meta: PageMeta): void {
 		const treeMap = this.dm.getTreeMap();
@@ -65,6 +146,7 @@ export class MetaManager {
 		if (!raw) throw new Error(`Document ${docId} not found`);
 
 		const entry = toPlain(raw) as Record<string, unknown>;
+		this.validateOrThrow(docId, entry, meta);
 		treeMap.set(docId, {
 			...entry,
 			meta,
@@ -91,10 +173,25 @@ export class MetaManager {
 		for (const key of keys) {
 			delete updated[key];
 		}
+		this.validateOrThrow(docId, entry, updated as PageMeta);
 		treeMap.set(docId, {
 			...entry,
 			meta: updated,
 			updatedAt: Date.now(),
 		});
 	}
+
+	private validateOrThrow(
+		docId: string,
+		entry: Record<string, unknown>,
+		meta: PageMeta,
+	): void {
+		if (!this.schema) return;
+		const docType = entry.type as string | undefined;
+		if (!docType) return;
+		const result = this.schema.validateMeta(docType, meta);
+		if (!result.ok) {
+			throw new MetaValidationError(docId, docType, result.errors);
+		}
+	}
 }

package/src/QueryClient.ts

@@ -0,0 +1,209 @@
+import EventEmitter from "./EventEmitter.ts";
+
+/**
+ * V2 query layer — live subscription client.
+ *
+ * Mirrors the server in `crates/abracadabra/src/query_stream.rs`. Frames
+ * travel as `MSG_STATELESS` payloads with the literal `query:v1:` prefix
+ * followed by a JSON envelope.
+ *
+ * Each call to `subscribeQuery(...)` opens a long-lived subscription:
+ *   1. The client sends `req` with a fresh correlation id.
+ *   2. The server replies `ack` with an initial snapshot
+ *      (`DocumentMeta[]`).
+ *   3. The server emits `delta` frames as the doc-tree projection
+ *      drifts under the predicate.
+ *   4. The client sends `cancel` to tear it down (or relies on the
+ *      WebSocket close path to free server state).
+ *
+ * The shape of the `query` field mirrors the REST `POST /docs/query`
+ * body — `type`, `parentId`, `labelContains`, `where`, `limit`.
+ */
+
+export const QUERY_PREFIX = "query:v1:";
+
+export type QueryKind = "req" | "ack" | "delta" | "cancel" | "err";
+
+/** Mirrors `crate::query_stream::QuerySpec`. */
+export interface QuerySpec {
+	/** Match `documents.kind` exactly. */
+	type?: string;
+	/** Narrow to children of this doc. */
+	parentId?: string;
+	/** Case-insensitive substring on `documents.label`. */
+	labelContains?: string;
+	/** Maximum rows returned (default 50, hard cap 500 server-side). */
+	limit?: number;
+	/** Predicate AST. See `@abraca/schema/src/query.ts` for the shape. */
+	where?: unknown;
+}
+
+export interface DocumentMetaWire {
+	id: string;
+	parent_id?: string | null;
+	label?: string | null;
+	kind?: string | null;
+	doc_type?: string | null;
+	public_access?: string | null;
+	description?: string | null;
+	owner_id?: string | null;
+}
+
+export interface QueryFrame {
+	kind: QueryKind;
+	id: string;
+	query?: QuerySpec;
+	initial?: DocumentMetaWire[];
+	added?: DocumentMetaWire[];
+	updated?: DocumentMetaWire[];
+	removed?: string[];
+	error?: { code: string; message: string };
+}
+
+export class QueryError extends Error {
+	code: string;
+	constructor(code: string, message: string) {
+		super(message);
+		this.name = "QueryError";
+		this.code = code;
+	}
+}
+
+export interface QuerySubscriptionHandlers {
+	/** Fired once with the initial snapshot from the server's `ack`. */
+	onSnapshot?: (rows: DocumentMetaWire[]) => void;
+	/**
+	 * Fired on every `delta` after the initial ack. `added` are rows
+	 * newly matching the predicate; `removed` are doc_ids that no
+	 * longer match (or are no longer readable). v2 does not emit
+	 * `updated` — clients see updates as remove + add today; that
+	 * gap closes in v3 when row-level updates are tracked.
+	 */
+	onDelta?: (delta: {
+		added: DocumentMetaWire[];
+		removed: string[];
+	}) => void;
+	/** Fired on `err` frames from the server. */
+	onError?: (err: QueryError) => void;
+}
+
+export interface QuerySubscriptionHandle {
+	/** Correlation id assigned when the request was sent. */
+	readonly id: string;
+	/** Send a `cancel` to the server and stop dispatching to handlers. */
+	cancel(): void;
+}
+
+/**
+ * Minimal transport surface — matches `RpcTransport` so the provider
+ * can satisfy both without extra glue.
+ */
+export interface QueryTransport {
+	sendStateless(payload: string): void;
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	on(event: string, fn: Function): unknown;
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	off(event: string, fn?: Function): unknown;
+}
+
+interface ActiveSubscription {
+	id: string;
+	handlers: QuerySubscriptionHandlers;
+	cancelled: boolean;
+}
+
+export class QueryClient extends EventEmitter {
+	private readonly transport: QueryTransport;
+	private readonly subs = new Map<string, ActiveSubscription>();
+	private readonly onStatelessBound: (data: { payload: string }) => void;
+	private idCounter = 0;
+
+	constructor(transport: QueryTransport) {
+		super();
+		this.transport = transport;
+		this.onStatelessBound = (data) => this.receive(data.payload);
+		this.transport.on("stateless", this.onStatelessBound);
+	}
+
+	destroy(): void {
+		// Best-effort cancel of every open sub. The WebSocket close
+		// path also frees server state, so this is belt-and-suspenders.
+		for (const sub of this.subs.values()) {
+			if (!sub.cancelled) {
+				this.send({ kind: "cancel", id: sub.id });
+				sub.cancelled = true;
+			}
+		}
+		this.subs.clear();
+		this.transport.off("stateless", this.onStatelessBound);
+	}
+
+	subscribeQuery(
+		spec: QuerySpec,
+		handlers: QuerySubscriptionHandlers = {},
+	): QuerySubscriptionHandle {
+		const id = this.nextId();
+		const sub: ActiveSubscription = {
+			id,
+			handlers,
+			cancelled: false,
+		};
+		this.subs.set(id, sub);
+		this.send({ kind: "req", id, query: spec });
+		const self = this;
+		return {
+			id,
+			cancel(): void {
+				if (sub.cancelled) return;
+				sub.cancelled = true;
+				self.subs.delete(id);
+				self.send({ kind: "cancel", id });
+			},
+		};
+	}
+
+	private nextId(): string {
+		this.idCounter += 1;
+		return `q-${Date.now()}-${this.idCounter}`;
+	}
+
+	private send(frame: QueryFrame): void {
+		this.transport.sendStateless(`${QUERY_PREFIX}${JSON.stringify(frame)}`);
+	}
+
+	private receive(payload: string): void {
+		if (!payload.startsWith(QUERY_PREFIX)) return;
+		const rest = payload.slice(QUERY_PREFIX.length);
+		let frame: QueryFrame;
+		try {
+			frame = JSON.parse(rest) as QueryFrame;
+		} catch {
+			return;
+		}
+		const sub = this.subs.get(frame.id);
+		if (!sub || sub.cancelled) return;
+		switch (frame.kind) {
+			case "ack":
+				sub.handlers.onSnapshot?.(frame.initial ?? []);
+				break;
+			case "delta":
+				sub.handlers.onDelta?.({
+					added: frame.added ?? [],
+					removed: frame.removed ?? [],
+				});
+				break;
+			case "err":
+				if (frame.error) {
+					sub.handlers.onError?.(
+						new QueryError(frame.error.code, frame.error.message),
+					);
+				}
+				// Server treats `err` as terminal — drop the sub.
+				this.subs.delete(frame.id);
+				break;
+			default:
+				// `req` / `cancel` are client→server only. Ignore.
+				break;
+		}
+	}
+}

package/src/SchemaTypes.ts

@@ -0,0 +1,179 @@
+/**
+ * Phase 2 Day 1 — typed projection types for the provider.
+ *
+ * The provider package never imports `@abraca/schema` directly (Rule 1 —
+ * core stays schema-free). Instead, it declares a structural witness that
+ * any registry — including `@abraca/schema`'s `SchemaRegistry<TMap>` — can
+ * satisfy.
+ *
+ * Consumers parameterise typed accessors with the registry value:
+ *
+ *     const board = dm.tree.getTyped(kanbanSchema, "kanban", id);
+ *     // board.meta.kanbanColumnWidth is typed as the kanban enum | undefined
+ *
+ * The phantom `__metaMap` carries the per-doc-type meta map so the
+ * generics below can extract it without a runtime dependency.
+ */
+import type { PageMeta, TreeEntry } from "./DocTypes.ts";
+
+/**
+ * Structural shape of a typed schema registry. The `TMap` parameter is the
+ * meta-type map keyed by doc-type name (e.g. `{ "kanban": KanbanMeta, ... }`).
+ * `@abraca/schema`'s `SchemaRegistry<TMap>` satisfies this shape.
+ */
+export interface SchemaRegistryLike<
+	TMap extends Record<string, unknown> = Record<string, unknown>,
+> {
+	readonly types: ReadonlyMap<string, unknown>;
+	readonly __metaMap?: TMap;
+}
+
+/** Extract the doc-type names from a registry. */
+export type SchemaDocTypeName<S> =
+	S extends SchemaRegistryLike<infer M> ? keyof M & string : never;
+
+/** Extract the meta type for a given doc-type name from a registry. */
+export type SchemaMetaOf<S, N extends string> =
+	S extends SchemaRegistryLike<infer M>
+		? N extends keyof M
+			? M[N]
+			: never
+		: never;
+
+/**
+ * A tree entry projected against a typed registry. The `meta` field is
+ * narrowed to `TMap[N] | undefined` so consumers get full type inference
+ * without an explicit cast.
+ *
+ * Note: `meta` is optional even when the registry mandates fields — the
+ * tree may contain entries written before the schema was authored, and
+ * Rule 4 means we don't reject them at read time.
+ */
+export interface TypedTreeEntry<
+	TMap extends Record<string, unknown>,
+	N extends keyof TMap & string,
+> {
+	readonly id: string;
+	readonly type: N;
+	readonly label: string;
+	readonly parentId: string | null;
+	readonly order: number;
+	readonly meta: TMap[N] | undefined;
+	readonly createdAt: number | undefined;
+	readonly updatedAt: number | undefined;
+}
+
+/**
+ * A typed surface bound to a schema. Returned by
+ * `DocumentManager.docs(schema)` so the schema doesn't have to be repeated
+ * at every call site.
+ *
+ * Read methods (`get`, `getEntry`, `narrow`) project the existing
+ * untyped tree without performing schema validation. Write methods
+ * (`update`, `set`, `clear`) delegate to `MetaManager` and are subject
+ * to whatever validator was attached via `MetaManager.setSchema` —
+ * they do NOT auto-attach the registry passed to `dm.docs()`.
+ */
+export interface TypedDocsClient<TMap extends Record<string, unknown>> {
+	/**
+	 * Fetch a tree entry projected as the requested doc-type. Returns
+	 * `null` when the entry doesn't exist OR when its `type` field doesn't
+	 * match `expectedType`.
+	 */
+	get<N extends keyof TMap & string>(
+		expectedType: N,
+		id: string,
+	): TypedTreeEntry<TMap, N> | null;
+	/**
+	 * Fetch the raw, untyped entry (no type-narrowing applied). Useful when
+	 * the caller wants the underlying record without the projection.
+	 */
+	getEntry(id: string): TreeEntry | null;
+	/**
+	 * Discriminator helper: narrows an arbitrary `TreeEntry` to the
+	 * requested doc-type, returning a typed projection or `null` on mismatch.
+	 * No runtime read — pure type-guard helper.
+	 */
+	narrow<N extends keyof TMap & string>(
+		expectedType: N,
+		entry: TreeEntry | null | undefined,
+	): TypedTreeEntry<TMap, N> | null;
+	/**
+	 * Merge typed meta into a document's metadata. Throws
+	 * `TypedDocTypeMismatchError` when the stored entry's `type` doesn't
+	 * match `expectedType`; throws `MetaValidationError` when a validator
+	 * is attached and the merged meta fails validation.
+	 */
+	update<N extends keyof TMap & string>(
+		expectedType: N,
+		id: string,
+		meta: Partial<TMap[N]>,
+	): void;
+	/**
+	 * Replace all metadata on a document with a fully-typed payload.
+	 * Same throw semantics as `update`.
+	 */
+	set<N extends keyof TMap & string>(
+		expectedType: N,
+		id: string,
+		meta: TMap[N],
+	): void;
+	/**
+	 * Delete specific metadata keys. Constrained to the typed key-set of
+	 * `TMap[N]` so typos surface at compile time.
+	 */
+	clear<N extends keyof TMap & string>(
+		expectedType: N,
+		id: string,
+		keys: ReadonlyArray<keyof TMap[N] & string>,
+	): void;
+}
+
+/**
+ * Thrown by typed write methods on `TypedDocsClient` when the stored
+ * entry's `type` doesn't match the caller's `expectedType`. Distinct from
+ * `MetaValidationError` (which signals schema-content mismatches).
+ */
+export class TypedDocTypeMismatchError extends Error {
+	readonly docId: string;
+	readonly expectedType: string;
+	readonly actualType: string | undefined;
+	constructor(docId: string, expectedType: string, actualType: string | undefined) {
+		super(
+			`Typed write on document ${docId} expected type "${expectedType}" but stored type is ${
+				actualType === undefined ? "(none)" : `"${actualType}"`
+			}`,
+		);
+		this.name = "TypedDocTypeMismatchError";
+		this.docId = docId;
+		this.expectedType = expectedType;
+		this.actualType = actualType;
+	}
+}
+
+// ── Internal: shared projection helper ──────────────────────────────────────
+
+/**
+ * Project a raw `TreeEntry` to a `TypedTreeEntry<TMap, N>` if its `type`
+ * matches; otherwise return `null`. Used by both `TreeManager.getTyped`
+ * and `TypedDocsClient.{get,narrow}` to keep semantics consistent.
+ */
+export function projectTreeEntry<
+	TMap extends Record<string, unknown>,
+	N extends keyof TMap & string,
+>(entry: TreeEntry | null | undefined, expectedType: N):
+	TypedTreeEntry<TMap, N> | null
+{
+	if (!entry) return null;
+	if (entry.type !== expectedType) return null;
+	return {
+		id: entry.id,
+		type: expectedType,
+		label: entry.label,
+		parentId: entry.parentId,
+		order: entry.order,
+		meta: entry.meta as (TMap[N] & PageMeta) | undefined,
+		createdAt: entry.createdAt,
+		updatedAt: entry.updatedAt,
+	};
+}