@canvist/headless 0.0.0-stage → 0.2.0

package/dist/scene.js

@@ -0,0 +1,153 @@
+/**
+ * canvist canvas scenes on a server: load scene JSON or Yjs state, run
+ * canvas commands and inspector edits, and export SVG and PNG with the
+ * renderer the canvas draws with.
+ *
+ * Scenes live in their own WebAssembly module, so the document entry point
+ * stays small.
+ *
+ * ```ts
+ * import { createSceneEngine } from "@canvist/headless/scene";
+ *
+ * const engine = await createSceneEngine();
+ * using doc = engine.fromJson({
+ * 	type: "canvist-scene",
+ * 	version: 1,
+ * 	nodes: [{
+ * 		type: "page",
+ * 		children: [{
+ * 			type: "rectangle",
+ * 			props: { size: [120, 80], fills: [{ type: "solid", color: "#3b2cf5" }] },
+ * 		}],
+ * 	}],
+ * });
+ * const png = doc.exportPng({ scale: 2 });
+ * ```
+ *
+ * @module
+ */
+import init, { WasmSceneDoc, WasmSceneEngine, } from "../wasm-scene/canvist_headless_scene.js";
+import { bundled } from "./load.js";
+export { isCanvistError } from "./engine.js";
+const BUNDLED = new URL("../wasm-scene/canvist_headless_scene_bg.wasm", import.meta.url);
+let loading;
+/**
+ * Load the scene WebAssembly module once. Later calls return the first
+ * call's promise. Without a source, Node, Deno, and Bun read the bundled
+ * file; runtimes without a file system pass the module they imported.
+ */
+export function loadScene(source) {
+    loading ??= (async () => {
+        await init({ module_or_path: source ?? await bundled(BUNDLED) });
+    })();
+    return loading;
+}
+/** Load the scene module and create an engine with every built-in canvas extension. */
+export async function createSceneEngine(options = {}) {
+    await loadScene(options.wasm);
+    return new SceneEngine(options.client ?? 1);
+}
+/** A set of canvas extensions that creates scenes. Create one with {@link createSceneEngine}. */
+export class SceneEngine {
+    #wasm;
+    #client;
+    /** @internal Use {@link createSceneEngine}, which loads the module first. */
+    constructor(client) {
+        this.#client = client;
+        this.#wasm = new WasmSceneEngine(client);
+    }
+    /** Tools, commands, node types, and inspector sections, as Rust reports them. */
+    metadata() {
+        return JSON.parse(this.#wasm.metadata());
+    }
+    /** A scene with one empty page. */
+    create() {
+        return new SceneDoc(this.#wasm.create(), this.#client);
+    }
+    /** A scene from scene JSON, nested or flat. */
+    fromJson(json) {
+        return new SceneDoc(this.#wasm.fromJson(JSON.stringify(json)), this.#client);
+    }
+    /** A scene joined from a peer's v1 Yjs state. It is shared, so it produces updates. */
+    fromYjs(state) {
+        return new SceneDoc(this.#wasm.fromYjs(state), this.#client);
+    }
+    /** Release the engine's memory now rather than when it is collected. */
+    [Symbol.dispose]() {
+        this.#wasm.free();
+    }
+}
+/** One scene. Every edit is one undo step. */
+export class SceneDoc {
+    #wasm;
+    #client;
+    /** @internal Scenes come from a {@link SceneEngine}. */
+    constructor(wasm, client) {
+        this.#wasm = wasm;
+        this.#client = client;
+    }
+    /** The scene in the canonical flat form. */
+    toJson() {
+        return JSON.parse(this.#wasm.toJson());
+    }
+    /** Run canvas command `name` (see {@link SceneEngine.metadata}) against the selection. */
+    run(name, args = {}) {
+        this.#wasm.run(name, JSON.stringify(args));
+    }
+    /** Select nodes by id, for commands and inspector fields. */
+    select(ids) {
+        this.#wasm.select([...ids]);
+    }
+    /** The selected nodes' ids. */
+    selection() {
+        return this.#wasm.selection();
+    }
+    /** The inspector for the selection: sections of fields and their values. */
+    inspect() {
+        return JSON.parse(this.#wasm.inspect());
+    }
+    /** Set inspector field `key` on every selected node. */
+    setField(key, value) {
+        this.#wasm.setField(key, JSON.stringify(value));
+    }
+    /** Undo the latest change; returns whether there was one. */
+    undo() {
+        return this.#wasm.undo();
+    }
+    /**
+     * Provide an image asset's pixels, `width` by `height` RGBA8. Exports
+     * draw an image without pixels as a grey placeholder; SVG exports
+     * reference provided images by asset id.
+     */
+    addImage(asset, width, height, rgba) {
+        this.#wasm.addImage(asset, width, height, rgba);
+    }
+    /** The scene, or the nodes `options` names, as an SVG document. */
+    exportSvg(options = {}) {
+        return this.#wasm.exportSvg(JSON.stringify(options));
+    }
+    /** The scene, or the nodes `options` names, as a PNG image. */
+    exportPng(options = {}) {
+        return this.#wasm.exportPng(JSON.stringify(options));
+    }
+    /** Share the scene as Yjs client `clientId` (the engine's client by default). */
+    share(clientId = this.#client) {
+        this.#wasm.share(clientId);
+    }
+    /** The whole shared scene as one v1 Yjs update. */
+    encodeState() {
+        return this.#wasm.encodeState();
+    }
+    /** Merge a peer's v1 update; returns whether the scene changed. */
+    applyUpdate(update) {
+        return this.#wasm.applyUpdate(update);
+    }
+    /** The v1 updates this scene produced since the last call. */
+    takeUpdates() {
+        return this.#wasm.takeUpdates();
+    }
+    /** Release the scene's memory now rather than when it is collected. */
+    [Symbol.dispose]() {
+        this.#wasm.free();
+    }
+}

package/dist/ssr.d.ts

@@ -0,0 +1,66 @@
+import { type WasmSource } from "./load.ts";
+import type { Content, Extensions, StarterKit, ThemeOptions } from "./types.ts";
+export { type CanvistError, isCanvistError } from "./engine.ts";
+export type { WasmSource } from "./load.ts";
+export type { Content, StarterKit, ThemeOptions } from "./types.ts";
+/**
+ * Load the rendering WebAssembly module once. Later calls return the first
+ * call's promise. Without a source, Node, Deno, and Bun read the bundled
+ * file; runtimes without a file system pass the module they imported.
+ */
+export declare function loadRenderer(source?: WasmSource): Promise<void>;
+/** Options for {@link createRenderer}. */
+export interface RendererOptions<E extends Extensions> {
+    /** The extensions documents use, TipTap's StarterKit by default. Pass the editor's. */
+    readonly extensions?: E;
+    /** The theme. Pass the browser editor's `theme`, or the HTML won't line up with it. */
+    readonly theme?: ThemeOptions;
+    /**
+     * TrueType or OpenType font files to measure SVG text with: the files
+     * the page's `@font-face` rules load. HTML is laid out by the browser
+     * and needs none.
+     */
+    readonly fonts?: readonly (ArrayBuffer | ArrayBufferView)[];
+    /** Where the rendering module comes from; see {@link loadRenderer}. */
+    readonly wasm?: WasmSource;
+}
+/** How wide to render. */
+export interface RenderOptions {
+    /**
+     * The content width in CSS pixels. It must equal the width of the
+     * element the browser editor hydrates in.
+     */
+    readonly width: number;
+}
+/** Server-rendered HTML and the stylesheet it needs. */
+export interface RenderedHtml {
+    /** A `<div class="cv-doc">` fragment. Put it inside the element `createEditor` hydrates. */
+    readonly html: string;
+    /** The stylesheet, scoped under `.cv-doc`. */
+    readonly css: string;
+}
+/** Load the rendering module and create a renderer. */
+export declare function createRenderer<const E extends Extensions = StarterKit>(options?: RendererOptions<E>): Promise<Renderer<E>>;
+/**
+ * Renders documents to HTML, CSS, and SVG. It caches text measurements,
+ * so keep one per server and reuse it. Create one with
+ * {@link createRenderer}.
+ */
+export declare class Renderer<E extends Extensions = StarterKit> {
+    #private;
+    /** @internal Use {@link createRenderer}, which loads the module first. */
+    constructor(extensions: E, theme: ThemeOptions);
+    /**
+     * Register a TrueType or OpenType font for SVG text, and return the
+     * family names it added, such as `["Inter"]`.
+     */
+    registerFont(data: ArrayBuffer | ArrayBufferView): string[];
+    /** `content` as semantic HTML and its stylesheet. */
+    html(content: Content<E>, options: RenderOptions): RenderedHtml;
+    /** `content` as a complete HTML page with no body margin, ready to serve. */
+    page(content: Content<E>, options: RenderOptions): string;
+    /** The whole of `content` as an SVG image. */
+    svg(content: Content<E>, options: RenderOptions): string;
+    /** Release the renderer's memory now rather than when it is collected. */
+    [Symbol.dispose](): void;
+}

package/dist/ssr.js

@@ -0,0 +1,98 @@
+/**
+ * Server-side rendering for canvist documents: semantic HTML and a
+ * stylesheet laid out exactly as `@canvist/web` paints the document, so a
+ * page can show the text before any JavaScript runs and the live editor
+ * can take its place without moving a pixel. SVG images of the whole
+ * document, for previews and thumbnails, come from the same layout.
+ *
+ * Rendering lives in its own WebAssembly module, so the document entry
+ * point stays small. It measures text with its own copy of each font,
+ * never the system's: the bundled Atkinson Hyperlegible stands in for
+ * every family until you register yours.
+ *
+ * ```ts
+ * import { createRenderer } from "@canvist/headless/ssr";
+ *
+ * const renderer = await createRenderer({ theme: { scheme: "dark" } });
+ * const { html, css } = renderer.html(
+ * 	{ format: "markdown", input: "# Release notes" },
+ * 	{ width: 640 },
+ * );
+ * ```
+ *
+ * @module
+ */
+import init, { WasmRenderer } from "../wasm-ssr/canvist_headless_ssr.js";
+import { starterKit } from "./extensions.generated.js";
+import { bundled } from "./load.js";
+export { isCanvistError } from "./engine.js";
+const BUNDLED = new URL("../wasm-ssr/canvist_headless_ssr_bg.wasm", import.meta.url);
+let loading;
+/**
+ * Load the rendering WebAssembly module once. Later calls return the first
+ * call's promise. Without a source, Node, Deno, and Bun read the bundled
+ * file; runtimes without a file system pass the module they imported.
+ */
+export function loadRenderer(source) {
+    loading ??= (async () => {
+        await init({ module_or_path: source ?? await bundled(BUNDLED) });
+    })();
+    return loading;
+}
+/** Load the rendering module and create a renderer. */
+export async function createRenderer(options = {}) {
+    await loadRenderer(options.wasm);
+    const renderer = new Renderer((options.extensions ?? starterKit), options.theme ?? {});
+    for (const font of options.fonts ?? []) {
+        renderer.registerFont(font);
+    }
+    return renderer;
+}
+/**
+ * Renders documents to HTML, CSS, and SVG. It caches text measurements,
+ * so keep one per server and reuse it. Create one with
+ * {@link createRenderer}.
+ */
+export class Renderer {
+    #wasm;
+    /** @internal Use {@link createRenderer}, which loads the module first. */
+    constructor(extensions, theme) {
+        this.#wasm = new WasmRenderer(extensions.map((extension) => extension.name), JSON.stringify(theme));
+    }
+    /**
+     * Register a TrueType or OpenType font for SVG text, and return the
+     * family names it added, such as `["Inter"]`.
+     */
+    registerFont(data) {
+        return this.#wasm.registerFont(bytesOf(data));
+    }
+    /** `content` as semantic HTML and its stylesheet. */
+    html(content, options) {
+        const [html = "", css = ""] = this.#wasm.html(...encoded(content), options.width);
+        return { html, css };
+    }
+    /** `content` as a complete HTML page with no body margin, ready to serve. */
+    page(content, options) {
+        const { html, css } = this.html(content, options);
+        return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><style>${css}</style></head><body style="margin:0">${html}</body></html>`;
+    }
+    /** The whole of `content` as an SVG image. */
+    svg(content, options) {
+        return this.#wasm.svg(...encoded(content), options.width);
+    }
+    /** Release the renderer's memory now rather than when it is collected. */
+    [Symbol.dispose]() {
+        this.#wasm.free();
+    }
+}
+/** `content` as the `[format, input]` pair the module reads. */
+function encoded(content) {
+    return "format" in content
+        ? [content.format, content.input]
+        : ["json", JSON.stringify(content)];
+}
+function bytesOf(data) {
+    return data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}

package/dist/types.d.ts

@@ -0,0 +1,232 @@
+/**
+ * Types derived from extension metadata.
+ *
+ * Every extension descriptor is the metadata `canvist_core` produces,
+ * kept as a literal type. The types here read it, so a document's commands,
+ * queries, argument types, and JSON node names follow from the extensions
+ * an engine registers, with nothing written by hand per extension.
+ * Descriptions are comments in `extensions.generated.ts`, so they never
+ * ship in a browser bundle; `engine.metadata()` returns them as data.
+ *
+ * @module
+ */
+import type { core, starterKit } from "./extensions.generated.ts";
+/** The type of an argument, attribute, or query result. */
+export type ValueSpec = {
+    readonly type: "bool";
+} | {
+    readonly type: "int";
+    readonly min?: number;
+    readonly max?: number;
+} | {
+    readonly type: "float";
+} | {
+    readonly type: "string";
+    readonly enum?: readonly string[];
+} | {
+    readonly type: "nullable";
+    readonly of: ValueSpec;
+} | {
+    readonly type: "list";
+    readonly of: ValueSpec;
+} | {
+    readonly type: "record";
+    readonly fields: readonly FieldSpec[];
+};
+/** A named, typed value. A `default` makes an argument optional. */
+export interface FieldSpec {
+    readonly name: string;
+    /** What it means: in `engine.metadata()`, not in the generated descriptors. */
+    readonly doc?: string;
+    readonly type: ValueSpec;
+    readonly default?: unknown;
+}
+/** A block, mark, or inline embed an extension adds to the schema. */
+export interface NodeSpec {
+    readonly kind: "block" | "mark" | "embed";
+    readonly name: string;
+    readonly attrs: readonly FieldSpec[];
+}
+/** A command an extension registers. */
+export interface CommandSpec {
+    readonly name: string;
+    /** What it does: in `engine.metadata()`, not in the generated descriptors. */
+    readonly doc?: string;
+    readonly args: readonly FieldSpec[];
+}
+/** A query an extension registers. */
+export interface QuerySpec {
+    readonly name: string;
+    /** What it answers: in `engine.metadata()`, not in the generated descriptors. */
+    readonly doc?: string;
+    readonly args: readonly FieldSpec[];
+    readonly returns: ValueSpec;
+}
+/** What one extension adds: its metadata. */
+export interface ExtensionDescriptor {
+    readonly name: string;
+    readonly nodes: readonly NodeSpec[];
+    readonly commands: readonly CommandSpec[];
+    readonly queries: readonly QuerySpec[];
+}
+/** A list of extensions. */
+export type Extensions = readonly ExtensionDescriptor[];
+/** Integer ranges this short become unions of their members. */
+type MaxRangeLength = 64;
+/** `Min | Min + 1 | ... | Max`, or `number` for long or open ranges. */
+type IntRange<Min extends number, Max extends number, Counter extends readonly unknown[] = [], Started extends boolean = false> = Counter["length"] extends MaxRangeLength ? number : Counter["length"] extends Max ? Counter["length"] : Started extends true ? Counter["length"] | IntRange<Min, Max, [...Counter, unknown], true> : Counter["length"] extends Min ? Counter["length"] | IntRange<Min, Max, [...Counter, unknown], true> : IntRange<Min, Max, [...Counter, unknown], false>;
+/** The TypeScript type of a value with spec `S`. */
+export type ValueOf<S> = S extends {
+    readonly type: "bool";
+} ? boolean : S extends {
+    readonly type: "int";
+    readonly min: infer Min extends number;
+    readonly max: infer Max extends number;
+} ? IntRange<Min, Max> : S extends {
+    readonly type: "int";
+} | {
+    readonly type: "float";
+} ? number : S extends {
+    readonly type: "string";
+    readonly enum: readonly (infer Option)[];
+} ? Option : S extends {
+    readonly type: "string";
+} ? string : S extends {
+    readonly type: "nullable";
+    readonly of: infer Inner;
+} ? ValueOf<Inner> | null : S extends {
+    readonly type: "list";
+    readonly of: infer Inner;
+} ? readonly ValueOf<Inner>[] : S extends {
+    readonly type: "record";
+    readonly fields: infer Fields extends readonly FieldSpec[];
+} ? ArgsOf<Fields> : never;
+type Simplify<T> = {
+    [Key in keyof T]: T[Key];
+} & {};
+/** The object of named arguments `Fields` describe. */
+export type ArgsOf<Fields extends readonly FieldSpec[]> = Simplify<{
+    [Field in Fields[number] as Field extends {
+        readonly default: unknown;
+    } ? never : Field["name"]]: ValueOf<Field["type"]>;
+} & {
+    [Field in Fields[number] as Field extends {
+        readonly default: unknown;
+    } ? Field["name"] : never]?: ValueOf<Field["type"]>;
+}>;
+/** The parameters of a command or query: none, optional, or required. */
+export type ParamsOf<Fields extends readonly FieldSpec[]> = Fields extends readonly [] ? [] : Exclude<Fields[number], {
+    readonly default: unknown;
+}> extends never ? [args?: ArgsOf<Fields>] : [args: ArgsOf<Fields>];
+type CommandsIn<E extends Extensions> = E[number]["commands"][number];
+type QueriesIn<E extends Extensions> = E[number]["queries"][number];
+type NodesIn<E extends Extensions> = E[number]["nodes"][number];
+/** Every command the extensions `E` register, by name. Each returns whether it applied. */
+export type Commands<E extends Extensions> = {
+    readonly [Command in CommandsIn<E> as Command["name"]]: (...args: ParamsOf<Command["args"]>) => boolean;
+};
+/** Every query the extensions `E` register, by name. */
+export type Queries<E extends Extensions> = {
+    readonly [Query in QueriesIn<E> as Query["name"]]: (...args: ParamsOf<Query["args"]>) => ValueOf<Query["returns"]>;
+};
+/** The name of a command the extensions `E` register. */
+export type CommandName<E extends Extensions> = CommandsIn<E>["name"];
+/** The name of a query the extensions `E` register. */
+export type QueryName<E extends Extensions> = QueriesIn<E>["name"];
+/** The parameters of the command named `N`. */
+export type CommandParams<E extends Extensions, N extends CommandName<E>> = N extends CommandName<E> ? Commands<E>[N] extends (...args: infer Params) => boolean ? Params : never : never;
+/** The parameters of the query named `N`. */
+export type QueryParams<E extends Extensions, N extends QueryName<E>> = N extends QueryName<E> ? Queries<E>[N] extends (...args: infer Params) => unknown ? Params : never : never;
+/** The answer of the query named `N`. */
+export type QueryResult<E extends Extensions, N extends QueryName<E>> = Queries<E>[N] extends (...args: never) => infer Result ? Result : never;
+/** The names of the blocks, marks, or embeds `E` add. */
+export type NodeName<E extends Extensions, Kind extends NodeSpec["kind"]> = Extract<NodesIn<E>, {
+    readonly kind: Kind;
+}>["name"];
+type AttrsJson<Node extends NodeSpec> = Simplify<{
+    readonly [Field in Node["attrs"][number] as Field["name"]]?: ValueOf<Field["type"]>;
+} & {
+    readonly id?: string;
+}>;
+/** A mark in ProseMirror JSON, for the marks `E` add. */
+export type MarkJson<E extends Extensions> = {
+    [Node in Extract<NodesIn<E>, {
+        readonly kind: "mark";
+    }> as Node["name"]]: {
+        readonly type: Node["name"];
+        readonly attrs?: AttrsJson<Node>;
+    };
+}[NodeName<E, "mark">];
+/** Inline content in ProseMirror JSON: text, or the embeds `E` add. */
+export type InlineJson<E extends Extensions> = {
+    readonly type: "text";
+    readonly text: string;
+    readonly marks?: readonly MarkJson<E>[];
+} | {
+    [Node in Extract<NodesIn<E>, {
+        readonly kind: "embed";
+    }> as Node["name"]]: {
+        readonly type: Node["name"];
+        readonly attrs?: AttrsJson<Node>;
+        readonly marks?: readonly MarkJson<E>[];
+    };
+}[NodeName<E, "embed">];
+/** A block in ProseMirror JSON, for the blocks `E` add. */
+export type BlockJson<E extends Extensions> = {
+    [Node in Extract<NodesIn<E>, {
+        readonly kind: "block";
+    }> as Node["name"]]: {
+        readonly type: Node["name"];
+        readonly attrs?: AttrsJson<Node>;
+        readonly content?: readonly (BlockJson<E> | InlineJson<E>)[];
+    };
+}[NodeName<E, "block">];
+/** A ProseMirror or TipTap document using only what `E` adds. */
+export interface DocJson<E extends Extensions> {
+    readonly type: "doc";
+    readonly content?: readonly BlockJson<E>[];
+}
+/** A format documents are read from and written to. */
+export type Format = "json" | "html" | "markdown" | "text";
+/** The extensions every engine has, plus the ones it was created with. */
+export type Registered<E extends Extensions> = readonly [...typeof core, ...E];
+/** The extensions of TipTap's StarterKit. */
+export type StarterKit = typeof starterKit;
+/** A document to start from: text in a format, or ProseMirror JSON. */
+export type Content<E extends Extensions> = {
+    readonly format: Format;
+    readonly input: string;
+} | DocJson<Registered<E>>;
+/**
+ * The StarterKit theme's options. The browser editor (`@canvist/web`) and
+ * the server renderer (`@canvist/headless/ssr`) take the same ones, and
+ * must be given the same values for server-rendered HTML to hydrate
+ * without moving.
+ */
+export interface ThemeOptions {
+    /** Light or dark colours. Default `"light"`. */
+    readonly scheme?: "light" | "dark";
+    /** The CSS `font-family` list for body text and headings. */
+    readonly bodyFamily?: string;
+    /** The CSS `font-family` list for code. */
+    readonly codeFamily?: string;
+    /** The body font size in pixels. Default 16. */
+    readonly size?: number;
+    /** The body line height as a multiple of the font size. Default 1.5. */
+    readonly lineHeight?: number;
+    /** CSS `letter-spacing` of body text, in pixels. Default 0. */
+    readonly letterSpacing?: number;
+}
+/** A point in a text block: a path from the root and a UTF-16 offset. */
+export interface Position {
+    readonly path: readonly number[];
+    readonly offset: number;
+}
+/** A text selection, or a caret when the anchor and head are equal. */
+export interface Range {
+    readonly anchor: Position;
+    readonly head: Position;
+}
+/** The stable name of each kind of failure, shared with Rust and Dart. */
+export type ErrorCode = "config" | "parse" | "schema" | "unknownName" | "invalidArgs" | "invalidPosition" | "invalidKey" | "editor" | "snapshot" | "notShared" | "alreadyShared" | "collab" | "render";
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,90 @@
 {
-  "name": "@canvist/headless",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@canvist/headless",
+	"version": "0.2.0",
+	"description": "canvist's document model and editing engine with no DOM: ProseMirror JSON, HTML, and Markdown conversion, typed commands, Yjs collaboration, and server-side rendering for Node, Deno, Bun, and Workers.",
+	"license": "Unlicense",
+	"homepage": "https://github.com/canvist/canvist/tree/main/packages/canvist-headless#readme",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/canvist/canvist.git",
+		"directory": "packages/canvist-headless"
+	},
+	"bugs": {
+		"url": "https://github.com/canvist/canvist/issues",
+		"email": "support@canvist.dev"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/mod.d.ts",
+			"default": "./dist/mod.js"
+		},
+		"./extensions": {
+			"types": "./dist/extensions.generated.d.ts",
+			"default": "./dist/extensions.generated.js"
+		},
+		"./extras": {
+			"types": "./dist/extras.generated.d.ts",
+			"default": "./dist/extras.generated.js"
+		},
+		"./full": {
+			"types": "./dist/full.d.ts",
+			"default": "./dist/full.js"
+		},
+		"./native": {
+			"types": "./dist/native.d.ts",
+			"default": "./dist/native.js"
+		},
+		"./scene": {
+			"types": "./dist/scene.d.ts",
+			"default": "./dist/scene.js"
+		},
+		"./ssr": {
+			"types": "./dist/ssr.d.ts",
+			"default": "./dist/ssr.js"
+		},
+		"./wasm/canvist_headless_wasm_bg.wasm": "./wasm/canvist_headless_wasm_bg.wasm",
+		"./wasm-full/canvist_headless_full_bg.wasm": "./wasm-full/canvist_headless_full_bg.wasm",
+		"./wasm-scene/canvist_headless_scene_bg.wasm": "./wasm-scene/canvist_headless_scene_bg.wasm",
+		"./wasm-ssr/canvist_headless_ssr_bg.wasm": "./wasm-ssr/canvist_headless_ssr_bg.wasm"
+	},
+	"files": [
+		"dist",
+		"wasm/*.js",
+		"wasm/*.d.ts",
+		"wasm/*.wasm",
+		"wasm-full/*.js",
+		"wasm-full/*.d.ts",
+		"wasm-full/*.wasm",
+		"wasm-scene/*.js",
+		"wasm-scene/*.d.ts",
+		"wasm-scene/*.wasm",
+		"wasm-ssr/*.js",
+		"wasm-ssr/*.d.ts",
+		"wasm-ssr/*.wasm"
+	],
+	"engines": {
+		"node": ">=22"
+	},
+	"scripts": {
+		"build:wasm": "npm run build:wasm:document && npm run build:wasm:full && npm run build:wasm:scene && npm run build:wasm:ssr",
+		"build:wasm:document": "cd ../.. && wasm-pack build crates/canvist_headless_wasm --target web --profile wasm-release --out-dir ../../packages/canvist-headless/wasm --no-pack && rm packages/canvist-headless/wasm/.gitignore",
+		"build:wasm:full": "cd ../.. && wasm-pack build crates/canvist_headless_wasm --target web --profile wasm-release --out-dir ../../packages/canvist-headless/wasm-full --out-name canvist_headless_full --no-pack -- --features full && rm packages/canvist-headless/wasm-full/.gitignore",
+		"build:wasm:scene": "cd ../.. && wasm-pack build crates/canvist_headless_wasm --target web --profile wasm-release --out-dir ../../packages/canvist-headless/wasm-scene --out-name canvist_headless_scene --no-pack -- --features scene && rm packages/canvist-headless/wasm-scene/.gitignore",
+		"build:wasm:ssr": "cd ../.. && wasm-pack build crates/canvist_headless_wasm --target web --profile wasm-release --out-dir ../../packages/canvist-headless/wasm-ssr --out-name canvist_headless_ssr --no-pack -- --features ssr && rm packages/canvist-headless/wasm-ssr/.gitignore",
+		"generate": "node scripts/generate.ts",
+		"check:generated": "node scripts/generate.ts --check",
+		"check:types": "tsc --noEmit",
+		"test": "node --test tests/*.test.ts",
+		"bench": "node bench/overhead.ts",
+		"build": "tsc -p tsconfig.build.json",
+		"prepack": "npm run build"
+	},
+	"devDependencies": {
+		"@types/node": "^24.0.0",
+		"typescript": "^7.0.2",
+		"y-protocols": "^1.0.7",
+		"yjs": "^13.6.33",
+		"lib0": "^0.2.115"
+	}
+}