@thomasfosterau/prosekit-utilities 0.0.0-stage → 0.1.0

package/dist/drizzle.d.ts

@@ -0,0 +1,76 @@
+import * as Schema from "effect/Schema";
+import { AnyPgColumn } from "drizzle-orm/pg-core";
+import { SQL } from "drizzle-orm";
+/**
+ * Builds a typed JSONB Drizzle custom column backed by an Effect Schema
+ * codec.
+ *
+ * Values are stored as PostgreSQL `jsonb`. The schema validates on read
+ * (`fromDriver`) only — `toDriver` runs `Schema.encodeSync` over the raw
+ * value's `Schema.fromJsonString(Schema.Unknown)` wire form, exactly as the
+ * apps' `inlineDocument` / `blockDocument` columns do, and does **not** run
+ * `schema` itself on the way out. That is deliberate, not an oversight: the
+ * write path is validated upstream, at the API edge and by whatever schema
+ * governs the value before it reaches this column, and the read path is
+ * where a jsonb row earns the strict, derived schema back. Read validation
+ * is what closes SEC-XSS-001 on both directions in practice — a hostile row
+ * written by any means other than the validated path is refused on the way
+ * back out.
+ *
+ * The runtime driver is expected to be node-pg (`pg`), which already parses
+ * `jsonb` columns for you, so `fromDriver`'s `!Predicate.isString(value)`
+ * branch is the common case and the `Predicate.isString` branch (parse a
+ * JSON string driver value, then validate) exists for a driver that instead
+ * hands back raw text.
+ *
+ * `null` passes through untouched — Drizzle applies the schema only to
+ * non-null values, so a nullable column needs no `.nullable()` wrapping here.
+ */
+export declare const jsonbSchemaColumn: <A>(schema: Schema.Codec<A, A>) => (name: string) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+  dataType: "custom";
+  data: A;
+  driverParam: string;
+}>;
+/**
+ * The one piece of `DocumentSchema` (from
+ * `@thomasfosterau/prosekit-utilities/prosekit`) this module needs. The
+ * dependency is written structurally, not as an import of that module,
+ * because the `./prosekit` family is authored in parallel and the `./drizzle`
+ * entry must not import ProseKit at the value or type level (see the root
+ * `AGENTS.md`'s "keep ProseKit off the root entry" rule — the same reasoning
+ * applies one level over: this entry stays free of the `./prosekit` module
+ * graph too, so a consumer can depend on `./drizzle` without pulling in
+ * ProseKit transitively).
+ */
+interface HasDocumentSchema<A> {
+  readonly Document: Schema.Codec<A, A>;
+}
+/**
+ * Builds a `jsonb` document column from a `DocumentSchema` (the value
+ * `defineDocumentSchema` returns from `@thomasfosterau/prosekit-utilities/prosekit`).
+ *
+ * `jsonbSchemaColumn(schema.Document)` — the strict, ProseKit-derived schema,
+ * so a row is held to the full document grammar on read (see
+ * {@link jsonbSchemaColumn}'s doc comment for why the write path is not
+ * re-validated here).
+ */
+export declare const documentColumn: <A>(schema: HasDocumentSchema<A>) => (name: string) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+  dataType: "custom";
+  data: A;
+  driverParam: string;
+}>;
+/**
+ * A SQL fragment yielding a jsonb document's `text` leaves joined by single
+ * spaces — the database twin of `extractDocumentText` (the root entry), for a
+ * generated or materialised search column.
+ *
+ * `jsonb_path_query_array(column, 'strict $.** ? (@.type == "text").text')`
+ * collects every `text` leaf's `.text` value, in document order, as a jsonb
+ * array; `jsonb_array_elements_text` unnests it to `text` rows;
+ * `array_to_string(array(...), ' ')` joins them with the same `' '`
+ * separator `extractDocumentText`'s default uses — so a row's generated or
+ * materialised text column agrees with what the JS function would compute
+ * over the same document.
+ */
+export declare const documentTextSql: (column: AnyPgColumn | SQL) => SQL<string>;
+export type { HasDocumentSchema };

package/dist/drizzle.js

@@ -0,0 +1,95 @@
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import { customType } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+// src/drizzle/jsonb-column.ts
+/**
+* A typed `jsonb` Drizzle custom column backed by an Effect Schema.
+*
+* Generalises the apps' `customType` body (Gardeneria's
+* `packages/database/src/columns.ts`, byte-identical to Website's) over an
+* arbitrary codec `A`, so a consumer supplies its own document (or any other
+* JSON-shaped) schema instead of the library naming one.
+*
+* @module
+*/
+/**
+* The JSON text boundary, expressed as a schema rather than the `JSON`
+* global: encoding runs `Schema.fromJsonString(Schema.Unknown)` forward
+* (`JSON.stringify`) and decoding runs it as a total operation whose `None`
+* replaces the `catch` a hand-rolled `JSON.parse` would need.
+*/
+const JsonText = /* @__PURE__ */ Schema.fromJsonString(Schema.Unknown);
+const encodeJson = /* @__PURE__ */ Schema.encodeSync(JsonText);
+const decodeJson = /* @__PURE__ */ Schema.decodeUnknownOption(JsonText);
+/**
+* Builds a typed JSONB Drizzle custom column backed by an Effect Schema
+* codec.
+*
+* Values are stored as PostgreSQL `jsonb`. The schema validates on read
+* (`fromDriver`) only — `toDriver` runs `Schema.encodeSync` over the raw
+* value's `Schema.fromJsonString(Schema.Unknown)` wire form, exactly as the
+* apps' `inlineDocument` / `blockDocument` columns do, and does **not** run
+* `schema` itself on the way out. That is deliberate, not an oversight: the
+* write path is validated upstream, at the API edge and by whatever schema
+* governs the value before it reaches this column, and the read path is
+* where a jsonb row earns the strict, derived schema back. Read validation
+* is what closes SEC-XSS-001 on both directions in practice — a hostile row
+* written by any means other than the validated path is refused on the way
+* back out.
+*
+* The runtime driver is expected to be node-pg (`pg`), which already parses
+* `jsonb` columns for you, so `fromDriver`'s `!Predicate.isString(value)`
+* branch is the common case and the `Predicate.isString` branch (parse a
+* JSON string driver value, then validate) exists for a driver that instead
+* hands back raw text.
+*
+* `null` passes through untouched — Drizzle applies the schema only to
+* non-null values, so a nullable column needs no `.nullable()` wrapping here.
+*/
+const jsonbSchemaColumn = (schema) => (name) => {
+	const parse = Schema.decodeUnknownSync(schema);
+	return customType({
+		dataType() {
+			return "jsonb";
+		},
+		toDriver(value) {
+			return encodeJson(value);
+		},
+		fromDriver(value) {
+			if (!Predicate.isString(value)) return parse(value);
+			return Option.match(decodeJson(value), {
+				onNone: () => parse(value),
+				onSome: (parsed) => parse(parsed)
+			});
+		}
+	})(name);
+};
+// src/drizzle/document-column.ts
+/**
+* Builds a `jsonb` document column from a `DocumentSchema` (the value
+* `defineDocumentSchema` returns from `@thomasfosterau/prosekit-utilities/prosekit`).
+*
+* `jsonbSchemaColumn(schema.Document)` — the strict, ProseKit-derived schema,
+* so a row is held to the full document grammar on read (see
+* {@link jsonbSchemaColumn}'s doc comment for why the write path is not
+* re-validated here).
+*/
+const documentColumn = (schema) => jsonbSchemaColumn(schema.Document);
+// src/drizzle/document-text-sql.ts
+/**
+* A SQL fragment yielding a jsonb document's `text` leaves joined by single
+* spaces — the database twin of `extractDocumentText` (the root entry), for a
+* generated or materialised search column.
+*
+* `jsonb_path_query_array(column, 'strict $.** ? (@.type == "text").text')`
+* collects every `text` leaf's `.text` value, in document order, as a jsonb
+* array; `jsonb_array_elements_text` unnests it to `text` rows;
+* `array_to_string(array(...), ' ')` joins them with the same `' '`
+* separator `extractDocumentText`'s default uses — so a row's generated or
+* materialised text column agrees with what the JS function would compute
+* over the same document.
+*/
+const documentTextSql = (column) => sql`array_to_string(array(SELECT jsonb_array_elements_text(jsonb_path_query_array(${column}, 'strict $.** ? (@.type == "text").text'))), ' ')`;
+export { documentColumn, documentTextSql, jsonbSchemaColumn };

package/dist/envelope-DQS7tt8f.js

@@ -0,0 +1,87 @@
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import * as String from "effect/String";
+// src/url-safety.ts
+/**
+* The safe-URL allow-list shared by every serialiser in this package.
+*
+* Link `href`s and image `src`s are passed through this allow-list before
+* being embedded, so a serialiser never emits a `javascript:` / `data:` /
+* `vbscript:` URI. Single-sourced here so the Markdown serialiser, the HTML
+* serialiser (the ProseKit entry point) and the allow-list write-seam check can never
+* drift apart — the SEC-XSS-001 defence-in-depth both apps this package was
+* extracted from rely on.
+*
+* @module
+*/
+/**
+* The schemes {@link isSafeHref} accepts when the caller names none.
+*
+* Deliberately short: these are the three a rich-text document has a reason
+* to link to. An application that needs `tel:` or a custom scheme passes it
+* in rather than widening the default for everyone.
+*/
+const DEFAULT_SAFE_SCHEMES = [
+	"http",
+	"https",
+	"mailto"
+];
+/** Normalises `https:` / `HTTPS` / `https` to the `https:` form `URL#protocol` reports. */
+const asProtocol = (scheme) => {
+	const lower = scheme.trim().toLowerCase();
+	return lower.endsWith(":") ? lower : `${lower}:`;
+};
+/**
+* Returns true when `href` is safe to embed as a link target or image
+* source.
+*
+* Allowed: any of `options.schemes` (default `http`, `https`, `mailto`),
+* root-relative paths (`/foo`, but not `//evil.example` or `/\evil.example`,
+* both of which resolve off-origin), and fragment links (`#bar`).
+*
+* The scheme is read off `new URL()` rather than compared as a string
+* prefix, which is what makes the obfuscated forms fail: the WHATWG parser
+* lowercases the scheme and strips leading and inner ASCII whitespace and
+* control characters before reporting it, so `JaVaScRiPt:`, `  javascript:`
+* and `java\tscript:` all normalise to `javascript:` and are rejected. A
+* `startsWith('javascript:')` test would pass all three.
+*/
+function isSafeHref(href, options) {
+	if (!Predicate.isString(href)) return false;
+	const trimmed = href.trim();
+	if (String.isEmpty(trimmed)) return false;
+	if (trimmed.startsWith("/") && !trimmed.startsWith("//") && !trimmed.startsWith("/\\")) return true;
+	if (trimmed.startsWith("#")) return true;
+	const parsed = Result.try(() => new URL(trimmed));
+	if (Result.isFailure(parsed)) return false;
+	const protocol = parsed.success.protocol.toLowerCase();
+	return (options?.schemes ?? DEFAULT_SAFE_SCHEMES).some((scheme) => asProtocol(scheme) === protocol);
+}
+// src/envelope.ts
+/**
+* Rewrites a document's root `type` to `doc`, ready for a ProseMirror
+* schema.
+*
+* Anything that is not already `doc` is treated as an envelope name — the
+* remap does not need to know which one, which is what lets one component
+* serve every shape an application declares.
+*/
+const toEditorDocument = (doc) => ({
+	...doc,
+	type: "doc"
+});
+/**
+* Rewrites an editor document's root `type` back to the envelope `name`,
+* ready to persist.
+*
+* Curried on the name so a component can bind it once
+* (`const toStored = fromEditorDocument(shape.name)`). A document with no
+* `content` at all becomes an empty one rather than an envelope missing its
+* required field.
+*/
+const fromEditorDocument = (name) => (doc) => ({
+	...doc,
+	type: name,
+	content: doc.content ?? []
+});
+export { isSafeHref as i, toEditorDocument as n, DEFAULT_SAFE_SCHEMES as r, fromEditorDocument as t };

package/dist/index-DlgceBHe.d.ts

@@ -0,0 +1,266 @@
+import * as Option from "effect/Option";
+import * as Schema$1 from "effect/Schema";
+import { AttributeSpec, MarkType, NodeType, Schema } from "@prosekit/pm/model";
+declare namespace Options_d_exports {
+  export { AttributeOverlay, AttributeOwner, DeriveDocumentOptions, DeriveOptions, DerivedMarkJSON, DerivedNodeJSON, RequiredAttribute, attributeOverlay, isRequiredAttribute, required };
+}
+/** Identifies the node or mark type that owns an attribute being derived. */
+interface AttributeOwner {
+  /** Whether the attribute belongs to a node type or a mark type. */
+  readonly kind: 'node' | 'mark';
+  /** The owning type's name in the ProseMirror schema. */
+  readonly name: string;
+}
+declare const RequiredAttributeTypeId: unique symbol;
+/**
+ * Wraps an overlay schema so the derived attribute key is REQUIRED, overriding
+ * ProseMirror's own default-implies-optional rule (a `default` of any value,
+ * `null` included, normally makes the key omissible — see
+ * {@link import("./Attribute.ts").deriveAttribute}). Use this when the live
+ * ProseMirror node always serialises the attribute in practice (every
+ * `Node.toJSON()` call includes defaulted attrs, so a genuinely
+ * editor-produced document always has the key) and the generative contract
+ * should hold a machine-authored document to the same standard.
+ */
+interface RequiredAttribute {
+  readonly [RequiredAttributeTypeId]: true;
+  readonly schema: Schema$1.Top;
+}
+/** Wraps `schema` as a {@link RequiredAttribute}. */
+declare const required: (schema: Schema$1.Top) => RequiredAttribute;
+/** True when `value` is a {@link RequiredAttribute} produced by {@link required}. */
+declare const isRequiredAttribute: (value: unknown) => value is RequiredAttribute;
+/**
+ * A caller-supplied override for a single attribute's schema.
+ *
+ * Return `Option.some` of an Effect {@link Schema.Top} to replace the derived
+ * attribute schema (key optionality still follows ProseMirror's `default`), of
+ * a {@link required} wrapper to additionally force the key required, or
+ * `Option.none()` to fall back to the automatic derivation (validate hint →
+ * default `typeof` → `Schema.Unknown`). This is where the attribute value types
+ * ProseMirror cannot introspect are supplied by hand.
+ */
+type AttributeOverlay = (owner: AttributeOwner, attribute: string, spec: AttributeSpec) => Option.Option<Schema$1.Top | RequiredAttribute>;
+/** Options common to every derivation entry point. */
+interface DeriveOptions {
+  /**
+   * Overrides derived attribute schemas. Consulted before the automatic
+   * derivation for every node and mark attribute.
+   */
+  readonly attributes?: AttributeOverlay;
+  /**
+   * Whether to attach a `marks` field to nodes that admit marks. Defaults to
+   * `true`; set `false` to omit marks entirely (e.g. a plain-text contract).
+   */
+  readonly includeMarks?: boolean;
+  /**
+   * Emit `content: "block+"` and other required content models as a
+   * non-empty array (`Schema.NonEmptyArray`) rather than a possibly-empty
+   * `Schema.Array`. Defaults to `true` — it mirrors ProseMirror's own
+   * non-emptiness guarantee. Set `false` for a more lenient generative
+   * contract.
+   */
+  readonly nonEmptyRequiredContent?: boolean;
+}
+/** Options for {@link deriveDocumentSchema}. */
+interface DeriveDocumentOptions extends DeriveOptions {
+  /**
+   * Overrides the top node's `type` literal. ProseMirror's top node is
+   * usually named `doc`; an application that renames it at its own layer
+   * (e.g. `doc` → `blockDocument`) passes the app-layer name here so the
+   * derived envelope matches its persisted JSON.
+   */
+  readonly topTypeName?: string;
+}
+/** A derived ProseMirror mark, as its JSON shape. */
+interface DerivedMarkJSON {
+  readonly type: string;
+  readonly attrs?: Record<string, unknown>;
+}
+/** A derived ProseMirror node, as its recursive JSON shape. */
+interface DerivedNodeJSON {
+  readonly type: string;
+  readonly attrs?: Record<string, unknown>;
+  readonly content?: ReadonlyArray<DerivedNodeJSON>;
+  readonly marks?: ReadonlyArray<DerivedMarkJSON>;
+  readonly text?: string;
+}
+/**
+ * Builds an {@link AttributeOverlay} from a nested record keyed by owner name
+ * then attribute name. A convenience over writing the function by hand when the
+ * overrides are static:
+ *
+ * ```ts
+ * const overlay = attributeOverlay({
+ *   heading: { level: Schema.Literals([1, 2, 3, 4, 5, 6]) },
+ *   image: { src: Schema.NullOr(Schema.String) },
+ * });
+ * ```
+ *
+ * Keys match on the owning type's name regardless of whether it is a node or a
+ * mark; a node and a mark sharing a name (unusual) would share overrides.
+ */
+declare function attributeOverlay(overrides: Readonly<Record<string, Readonly<Record<string, Schema$1.Top | RequiredAttribute>>>>): AttributeOverlay;
+declare namespace Derive_d_exports {
+  export { DocumentSchemaSpec, deriveDocumentSchema, deriveDocumentSchemas, deriveMarkSchema, deriveNodeSchema };
+}
+/**
+ * Derives an Effect schema for a single ProseMirror mark type: a struct with a
+ * `type` literal and, when the mark declares attributes, an `attrs` field.
+ */
+declare function deriveMarkSchema(markType: MarkType, options?: DeriveOptions): Schema$1.Codec<DerivedMarkJSON>;
+/**
+ * Derives an Effect schema for a single ProseMirror node type, recursively
+ * modelling its content via the node's own schema. The result validates a JSON
+ * subtree rooted at this node.
+ */
+declare function deriveNodeSchema(nodeType: NodeType, options?: DeriveOptions): Schema$1.Codec<DerivedNodeJSON>;
+/**
+ * Derives an Effect schema for a whole document from a ProseMirror schema,
+ * rooted at its top node (`schema.topNodeType`, usually `doc`).
+ *
+ * Pass `topTypeName` to rename the top node's `type` literal — for an
+ * application that persists the top node under a different name than
+ * ProseMirror's internal `doc` (e.g. `blockDocument`).
+ */
+declare function deriveDocumentSchema(schema: Schema, options?: DeriveDocumentOptions): Schema$1.Codec<DerivedNodeJSON>;
+/** One entry in a {@link deriveDocumentSchemas} call. */
+interface DocumentSchemaSpec {
+  /** The compiled ProseMirror schema to derive a document schema from. */
+  readonly schema: Schema;
+  /** Overrides this document's top node `type` literal, as {@link DeriveDocumentOptions.topTypeName}. */
+  readonly topTypeName?: string;
+}
+/**
+ * Derives Effect schemas for two or more related ProseMirror document
+ * schemas in one call, sharing a single {@link Registry} — and so its
+ * mark/node memoization — across all of them.
+ *
+ * Use this instead of separate {@link deriveDocumentSchema} calls when the
+ * schemas are assembled from overlapping ProseKit extensions (e.g. two
+ * document types that both compose the same `defineAllMarks()` or
+ * `defineText()`): the marks and nodes the schemas have in common are then
+ * derived once rather than once per document. The results stay fully
+ * independent `Schema.Codec`s — this shares derivation machinery, not the
+ * documents' wire shapes.
+ *
+ * **Precondition:** sharing is by mark/node *name*, so this is only correct
+ * when every schema in the call defines same-named marks/nodes identically
+ * (the same extension composed into each schema, as opposed to two schemas
+ * that coincidentally both declare a differently-shaped type under the same
+ * name) **and admits the same set of marks** — an inline node's derived
+ * `marks` field is the schema's whole inline mark union, so a schema with an
+ * extra mark derives a different `text`. A mismatch would silently resolve
+ * to whichever schema's version was derived first, for every schema after
+ * it, with no error.
+ *
+ * All entries are built eagerly in this one call — pass already-compiled
+ * schemas. A caller that needs each document to stay independently lazy
+ * (e.g. never compiling schema B just because schema A was validated) should
+ * instead share a {@link import("./Registry.ts").RegistryCache} across
+ * separate `Registry` instances directly, one per schema, each built inside
+ * its own deferred call site — the pattern
+ * `@thomasfosterau/prosekit-utilities/prosekit`'s `defineDocumentSchema`
+ * implements.
+ *
+ * `options` applies to every schema in the call; use each entry's own
+ * `topTypeName` for a per-document top-node rename.
+ */
+declare function deriveDocumentSchemas<Specs extends Record<string, DocumentSchemaSpec>>(schemas: Specs, options?: DeriveOptions): { readonly [K in keyof Specs]: Schema$1.Codec<DerivedNodeJSON>; };
+declare namespace Attribute_d_exports {
+  export { DerivedAttribute, deriveAttribute, deriveAttrsStruct, parseValidateGrammar };
+}
+/** A single derived attribute: its value schema and whether the key is optional. */
+interface DerivedAttribute {
+  readonly schema: Schema$1.Top;
+  /** True when the attribute has a default and may be omitted from the JSON. */
+  readonly optional: boolean;
+}
+/**
+ * Parses ProseMirror's `validate` string grammar — a `|`-separated list of the
+ * primitive names `"string"`, `"number"`, `"boolean"`, `"null"`, and
+ * `"undefined"` — into an Effect schema.
+ *
+ * The `"undefined"` member is not represented as a value (there is no
+ * first-class `undefined` schema for a present key); it is reported via the
+ * returned `optional` flag so the caller can drop the key instead.
+ *
+ * An empty or all-unknown grammar yields `Schema.Unknown`.
+ */
+declare function parseValidateGrammar(validate: string): {
+  readonly schema: Schema$1.Top;
+  readonly optional: boolean;
+};
+/**
+ * Derives the schema and key-optionality for one node or mark attribute.
+ *
+ * @param owner  The node or mark type the attribute belongs to (for the overlay).
+ * @param name   The attribute name.
+ * @param spec   The ProseMirror attribute spec.
+ * @param overlay Optional caller override consulted first.
+ */
+declare function deriveAttribute(owner: AttributeOwner, name: string, spec: AttributeSpec, overlay?: AttributeOverlay): DerivedAttribute;
+/**
+ * Derives the `attrs` struct schema for a node or mark from its attribute
+ * specs, or `Option.none()` when the type declares no attributes.
+ *
+ * `attrs` is an `Option` because ProseMirror's own `NodeSpec`/`MarkSpec` leaves
+ * `attrs` absent for an attribute-less type — the caller converts that foreign
+ * `undefined` at the boundary (`Option.fromNullishOr(nodeType.spec.attrs)`).
+ */
+declare function deriveAttrsStruct(owner: AttributeOwner, attrs: Option.Option<Readonly<Record<string, AttributeSpec>>>, overlay?: AttributeOverlay): Option.Option<Schema$1.Top>;
+declare namespace Content_d_exports {
+  export { ContentCardinality, allowedContentTypes, contentCardinality };
+}
+/** How a node's content model constrains the number of children. */
+type ContentCardinality =
+/** Leaf/atom: no content expression, the node takes no children. */
+'none' |
+/** `*` / `?`: empty content is valid; the `content` key may be omitted. */
+'optional' |
+/** `+`: at least one child is required. */
+'required';
+/**
+ * Collects the distinct set of node types that may appear anywhere in a node
+ * type's content, by breadth-first walk of its content-match automaton.
+ *
+ * Order follows first-discovery, which for the typical single-group
+ * expression (`block+`, `inline*`) matches the schema's node declaration
+ * order.
+ */
+declare function allowedContentTypes(nodeType: NodeType): ReadonlyArray<NodeType>;
+/**
+ * Classifies a node type's content cardinality from its content-match
+ * automaton: `none` when it admits no children, `optional` when the empty
+ * fragment is a valid end (`*` / `?`), and `required` otherwise (`+`).
+ */
+declare function contentCardinality(nodeType: NodeType): ContentCardinality;
+/**
+ * The memoised mark/node maps a {@link Registry} reads and writes.
+ *
+ * Keys are type names. Share one cache only between schemas whose mark sets
+ * match and whose same-named types are defined identically; see the module
+ * doc for what goes wrong otherwise.
+ */
+interface RegistryCache {
+  readonly nodeCache: Map<string, Schema$1.Codec<DerivedNodeJSON>>;
+  readonly markCache: Map<string, Schema$1.Codec<DerivedMarkJSON>>;
+}
+/** A fresh, empty {@link RegistryCache} — private to one `Registry` unless explicitly shared. */
+declare function createRegistryCache(): RegistryCache;
+/** Builds and memoises the derived schemas for a single ProseMirror schema. */
+declare class Registry {
+  #private;
+  constructor(schema: Schema, options?: DeriveOptions, cache?: RegistryCache);
+  /** The derived schema for a mark type, built once and memoised by name. */
+  mark(markType: MarkType): Schema$1.Codec<DerivedMarkJSON>;
+  /** The derived schema for a node type, built once and memoised by name. */
+  node(nodeType: NodeType): Schema$1.Codec<DerivedNodeJSON>;
+  /**
+   * The derived schema for a node type with its `type` literal overridden —
+   * used for a renamed top node (e.g. `doc` → `blockDocument`). Not memoised,
+   * since the override makes it distinct from the canonical node schema.
+   */
+  nodeAs(nodeType: NodeType, typeName: string): Schema$1.Codec<DerivedNodeJSON>;
+}
+export { required as S, DerivedNodeJSON as _, Attribute_d_exports as a, attributeOverlay as b, deriveDocumentSchema as c, deriveNodeSchema as d, AttributeOverlay as f, DerivedMarkJSON as g, DeriveOptions as h, Content_d_exports as i, deriveDocumentSchemas as l, DeriveDocumentOptions as m, RegistryCache as n, Derive_d_exports as o, AttributeOwner as p, createRegistryCache as r, DocumentSchemaSpec as s, Registry as t, deriveMarkSchema as u, Options_d_exports as v, isRequiredAttribute as x, RequiredAttribute as y };