pleached 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eral Almansouri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# pleached
+
+> **pleach** _(verb)_: to interlace living branches so that separate trees grow
+> together into one.
+
+Schema-first, CRDT-native state for TypeScript. Declare the shape of your
+state once — including how every part of it merges under concurrent edits —
+and get back a fully typed live tree you can mutate directly, subscribe to
+surgically, validate into a refined value, and back with interchangeable
+storage engines: an in-memory backend for single-user state, Yjs for
+real-time collaboration, others via a small SPI.
+
+> **Status: pre-implementation.** The full type surface and a red test suite
+> covering every design promise are in place; the runtime is being
+> implemented against them. See [docs/DESIGN.md](docs/DESIGN.md) for the
+> complete design.
+
+## Install
+
+```sh
+npm install pleached
+```
+
+React and Yjs are optional peer dependencies — install them only if you use
+the corresponding subpath:
+
+```sh
+npm install react   # for pleached/react
+npm install yjs     # for pleached/yjs
+```
+
+## Modules
+
+| Subpath          | Contents                                                                           |
+| ---------------- | ---------------------------------------------------------------------------------- |
+| `pleached`       | `s` (schema builders), `createStore`, `local()`, `resolve`, type inference surface |
+| `pleached/yjs`   | `yjs()` backend factory (peer: `yjs`)                                              |
+| `pleached/react` | `useSnapshot`, `useStore`, capability hooks (peer: `react`)                        |
+| `pleached/spi`   | `Backend`, `Session`, driver interfaces — the backend contract                     |
+
+## Quick look
+
+```ts
+import { s, createStore, local } from "pleached";
+
+const Todo = s.object({
+  title: s.scalar(s.string),
+  done: s.scalar(s.boolean),
+});
+
+const store = createStore(s.map(Todo), local());
+```
+
+See the [design document](docs/DESIGN.md) for the full walkthrough, the
+backend SPI, and decided tradeoffs. The design doc refers to the library by
+its working name `pleach`; it is published as `pleached` (npm rejects the
+bare name as too similar to `preact`).
+
+## Development
+
+```sh
+pnpm install
+pnpm check        # format + lint + typecheck
+pnpm test         # run the test suite
+pnpm build        # bundle to dist/ with type declarations
+```
+
+## Releasing
+
+Publishing to npm is automated via GitHub Actions: bump `version` in
+`package.json`, push a tag `v<version>`, and the release workflow builds and
+publishes.
+
+Auth: the first-ever publish uses the `NPM_TOKEN` repository secret. After
+that, configure a trusted publisher on npmjs.com (package Settings →
+Trusted Publisher: this repo + `release.yml`) and delete the secret — the
+workflow then authenticates via OIDC, no token needed.
+
+## License
+
+[MIT](LICENSE)

package/dist/capabilities-ALpw-aBj.d.mts

@@ -0,0 +1,28 @@
+import { M as Unsubscribe } from "./spi-CzHSw4BF.mjs";
+
+//#region src/capabilities.d.ts
+/** Undo/redo over this store's subtree, with transaction-boundary capture. */
+interface UndoApi {
+  undo(): void;
+  redo(): void;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  /** Closes the current capture group so the next edit starts a new undo step. */
+  stopCapturing(): void;
+  subscribe(listener: () => void): Unsubscribe;
+}
+/** Ephemeral per-peer state — cursors, names, focus. Never merged, never persisted. */
+interface PresenceApi<TState> {
+  self(): TState | undefined;
+  setSelf(state: TState): void;
+  updateSelf(patch: Partial<TState>): void;
+  peers(): ReadonlyMap<number, TState>;
+  subscribe(listener: () => void): Unsubscribe;
+}
+/** Connection status, fed by the app's provider wiring. */
+interface SyncApi {
+  status(): "synced" | "syncing" | "offline";
+  subscribe(listener: () => void): Unsubscribe;
+}
+//#endregion
+export { SyncApi as n, UndoApi as r, PresenceApi as t };

package/dist/index.d.mts

@@ -0,0 +1,40 @@
+import { $ as UnionValueCases, A as UnionNode, B as NodeOf, C as Node, D as PartialCases, E as Origin, F as Infer, G as ShapeInput, H as SchemaBuilders, I as InputOf, J as Simplify, K as ShapeKinds, L as Kind, M as Unsubscribe, N as resolve, O as ScalarNode, P as AnySchema, Q as UnionValue, R as KindRegistry, S as MapNode, T as ObjectNode, U as SchemaMembers, V as Schema, W as Shape, X as UnionKinds, Y as UnionInput, Z as UnionSchema, _ as CaseResult, b as ListNode, et as ValueOf, g as AnyNode, j as UnionNodeCases, k as TextNode, n as AnyDriver, nt as s, o as DriverSlot, q as ShapeValue, rt as $, tt as VariantShapes, v as Change, w as NodeOps, x as LoadOptions, y as CounterNode, z as KindsOf } from "./spi-CzHSw4BF.mjs";
+import { n as SyncApi, r as UndoApi, t as PresenceApi } from "./capabilities-ALpw-aBj.mjs";
+import { a as StoreOf, c as LocalOptions, i as Store, l as local, n as BackendSupports, o as createStore, r as CreateStoreOptions, s as LocalBackend, t as AnyStore } from "./store-NWV8hqvw.mjs";
+
+//#region src/internal.d.ts
+/**
+ * Raised by every runtime entry point while pleach is interfaces-only.
+ * The test suite is written against the designed behavior and is expected
+ * to fail with this error until the implementation lands.
+ */
+declare class NotImplementedError extends Error {
+  constructor(what: string);
+}
+//#endregion
+//#region src/kind.d.ts
+/** The composition context handed to a kind when it materializes. */
+interface KindContext {
+  /** Stable per-client identity, for per-actor structures (counters). */
+  readonly actorId: string;
+  /** This node's position — materialize primitive drivers from it. */
+  readonly slot: DriverSlot;
+  /** A backend-native driver override for this kind, when the backend offers one. */
+  native(kind: Kind): AnyDriver | undefined;
+  /** Bubbles a change notification for this node's subtree. */
+  emit(change: Change): void;
+}
+/** The runtime half of a custom kind. */
+interface KindSpec<TNode extends AnyNode> {
+  materialize(context: KindContext): TNode;
+}
+interface KindDefinition<TKind extends Kind, TNode extends AnyNode> extends KindSpec<TNode> {
+  readonly kind: TKind;
+}
+/**
+ * Defines a custom kind by composing primitive drivers into a node facade.
+ * Pair with a `KindRegistry` module augmentation for the type half.
+ */
+declare function defineKind<TKind extends Kind, TNode extends AnyNode>(kind: TKind, spec: KindSpec<TNode>): KindDefinition<TKind, TNode>;
+//#endregion
+export { $, type AnyNode, type AnySchema, type AnyStore, type BackendSupports, type CaseResult, type Change, type CounterNode, type CreateStoreOptions, type Infer, type InputOf, type Kind, type KindContext, type KindDefinition, type KindRegistry, type KindSpec, type KindsOf, type ListNode, type LoadOptions, type LocalBackend, type LocalOptions, type MapNode, type Node, type NodeOf, type NodeOps, NotImplementedError, type ObjectNode, type Origin, type PartialCases, type PresenceApi, type ScalarNode, type Schema, type SchemaBuilders, type SchemaMembers, type Shape, type ShapeInput, type ShapeKinds, type ShapeValue, type Simplify, type Store, type StoreOf, type SyncApi, type TextNode, type UndoApi, type UnionInput, type UnionKinds, type UnionNode, type UnionNodeCases, type UnionSchema, type UnionValue, type UnionValueCases, type Unsubscribe, type ValueOf, type VariantShapes, createStore, defineKind, local, resolve, s };

package/dist/index.mjs

@@ -0,0 +1,89 @@
+import { n as todo, t as NotImplementedError } from "./internal-CnZZ5Mhp.mjs";
+//#region src/symbol.ts
+/**
+* Shared symbol namespace for hidden operations and metadata.
+*
+* Structural node operations (snapshot, load, subscribe) and schema internals
+* live behind this symbol so they can never collide with author-chosen names —
+* an object node is free to have a child named `snapshot`.
+*/
+const $ = Symbol("pleach");
+//#endregion
+//#region src/node.ts
+/**
+* Resolves a dynamic path to a descendant node, or `undefined` when any
+* segment is missing. The untyped escape hatch for callers that only know
+* paths at runtime (visual builders); typed code traverses node properties
+* instead.
+*/
+function resolve(node, segments) {
+	return todo("resolve");
+}
+//#endregion
+//#region src/schema.ts
+const s = {
+	text: () => todo("s.text"),
+	scalar: () => todo("s.scalar"),
+	opaque: () => todo("s.opaque"),
+	list: () => todo("s.list"),
+	object: () => todo("s.object"),
+	map: () => todo("s.map"),
+	union: () => todo("s.union"),
+	counter: () => todo("s.counter")
+};
+//#endregion
+//#region src/store.ts
+/**
+* Materializes a schema into a live store on a backend (the in-memory local
+* backend when none is given). The returned store carries the backend's
+* capabilities as typed members — `yjs({ undo: true })` yields `store.undo`.
+*/
+function createStore(schema, options) {
+	return todo("createStore");
+}
+//#endregion
+//#region src/local.ts
+/**
+* The local backend — in-memory state for single-user stores, and the
+* default when `createStore` receives no backend.
+*
+* Local is the *reference semantics* implementation: where behavior is
+* ambiguous, the local backend's behavior is the spec. It is not a sync
+* engine — no op queue, no persistence, no merging of two local sessions.
+*
+* Local also implements the undo capability (`local({ undo: true })`) as an
+* inverse-operation log with transaction-boundary capture: two independent
+* capability implementations keep the abstraction honest, and single-user
+* stores want undo anyway.
+*/
+/** Creates an in-memory backend. `actorId` is random per session. */
+function local(options) {
+	return todo("local");
+}
+//#endregion
+//#region src/kind.ts
+/**
+* Kind extensibility — composing new kinds from the primitive drivers.
+*
+* The backend SPI stays small and closed (five primitives); kinds above the
+* primitives are composed in core and can be composed in userland exactly
+* the same way. pleach's own `union` (scalar tag + object variants) and
+* `counter` (map of per-actor sums) are proof cases: they need zero
+* backend-specific code.
+*
+* A custom kind is two halves: a module augmentation registering the kind
+* name on {@link KindRegistry}, and a runtime definition composing primitive
+* drivers into a node facade.
+*
+* @experimental The least-settled corner of the design — expect this
+* surface to move before implementation lands.
+*/
+/**
+* Defines a custom kind by composing primitive drivers into a node facade.
+* Pair with a `KindRegistry` module augmentation for the type half.
+*/
+function defineKind(kind, spec) {
+	return todo("defineKind");
+}
+//#endregion
+export { $, NotImplementedError, createStore, defineKind, local, resolve, s };

package/dist/internal-CnZZ5Mhp.mjs

@@ -0,0 +1,18 @@
+//#region src/internal.ts
+/**
+* Raised by every runtime entry point while pleach is interfaces-only.
+* The test suite is written against the designed behavior and is expected
+* to fail with this error until the implementation lands.
+*/
+var NotImplementedError = class extends Error {
+	constructor(what) {
+		super(`pleach: ${what} is not implemented yet`);
+		this.name = "NotImplementedError";
+	}
+};
+/** Stub body for designed-but-unimplemented runtime surface. */
+function todo(what) {
+	throw new NotImplementedError(what);
+}
+//#endregion
+export { todo as n, NotImplementedError as t };

package/dist/react.d.mts

@@ -0,0 +1,56 @@
+import { C as Node, I as InputOf, P as AnySchema, g as AnyNode } from "./spi-CzHSw4BF.mjs";
+import { n as SyncApi, r as UndoApi, t as PresenceApi } from "./capabilities-ALpw-aBj.mjs";
+import { i as Store, t as AnyStore } from "./store-NWV8hqvw.mjs";
+import { ReactNode } from "react";
+
+//#region src/react.d.ts
+/** The snapshot (editable input) shape of a node. */
+type SnapshotOf<TNode extends AnyNode> = TNode extends Node<infer TInput> ? TInput : never;
+/** The snapshot shape of a store's whole tree. */
+type StoreSnapshotOf<TStore extends AnyStore> = TStore extends Store<infer TSchema> ? InputOf<TSchema> : never;
+/**
+ * Subscribes to a node's subtree and returns its snapshot — the workhorse.
+ * With a selector, re-renders only when the selected value changes.
+ */
+declare function useSnapshot<TNode extends AnyNode>(node: TNode): SnapshotOf<TNode> | undefined;
+declare function useSnapshot<TNode extends AnyNode, TSelected>(node: TNode, selector: (snapshot: SnapshotOf<TNode> | undefined) => TSelected, equals?: (a: TSelected, b: TSelected) => boolean): TSelected;
+/** Store-level selector subscription, zustand-shaped. */
+declare function useStore<TStore extends AnyStore, TSelected>(store: TStore, selector: (snapshot: StoreSnapshotOf<TStore> | undefined) => TSelected, equals?: (a: TSelected, b: TSelected) => boolean): TSelected;
+/** Undo state and actions; only accepts stores whose backend provides undo. */
+declare function useUndo(store: AnyStore & {
+  undo: UndoApi;
+}): {
+  undo(): void;
+  redo(): void;
+  canUndo: boolean;
+  canRedo: boolean;
+};
+/** Presence state; only accepts stores whose backend provides presence. */
+declare function usePresence<TState>(store: AnyStore & {
+  presence: PresenceApi<TState>;
+}): {
+  self: TState | undefined;
+  peers: ReadonlyMap<number, TState>;
+  setSelf(state: TState): void;
+  updateSelf(patch: Partial<TState>): void;
+};
+/** Live sync status; only accepts stores whose backend provides sync. */
+declare function useSyncStatus(store: AnyStore & {
+  sync: SyncApi;
+}): "synced" | "syncing" | "offline";
+/**
+ * Optional context plumbing for component libraries. Members are standalone
+ * function values (component and hook), not `this`-bound methods — they are
+ * meant to be destructured.
+ */
+interface StoreContextBinding<TSchema extends AnySchema> {
+  readonly StoreProvider: (props: {
+    readonly store: Store<TSchema>;
+    readonly children?: ReactNode;
+  }) => ReactNode;
+  /** Throws outside a matching `StoreProvider`. */
+  readonly useStoreContext: () => Store<TSchema>;
+}
+declare function createStoreContext<TSchema extends AnySchema>(): StoreContextBinding<TSchema>;
+//#endregion
+export { SnapshotOf, StoreContextBinding, StoreSnapshotOf, createStoreContext, usePresence, useSnapshot, useStore, useSyncStatus, useUndo };

package/dist/react.mjs

@@ -0,0 +1,26 @@
+import { n as todo } from "./internal-CnZZ5Mhp.mjs";
+//#region src/react.ts
+function useSnapshot(..._args) {
+	return todo("useSnapshot");
+}
+/** Store-level selector subscription, zustand-shaped. */
+function useStore(store, selector, equals) {
+	return todo("useStore");
+}
+/** Undo state and actions; only accepts stores whose backend provides undo. */
+function useUndo(store) {
+	return todo("useUndo");
+}
+/** Presence state; only accepts stores whose backend provides presence. */
+function usePresence(store) {
+	return todo("usePresence");
+}
+/** Live sync status; only accepts stores whose backend provides sync. */
+function useSyncStatus(store) {
+	return todo("useSyncStatus");
+}
+function createStoreContext() {
+	return todo("createStoreContext");
+}
+//#endregion
+export { createStoreContext, usePresence, useSnapshot, useStore, useSyncStatus, useUndo };

package/dist/spi-CzHSw4BF.d.mts

@@ -0,0 +1,505 @@
+import { ArkErrors, Type, type } from "arktype";
+
+//#region src/symbol.d.ts
+/**
+ * Shared symbol namespace for hidden operations and metadata.
+ *
+ * Structural node operations (snapshot, load, subscribe) and schema internals
+ * live behind this symbol so they can never collide with author-chosen names —
+ * an object node is free to have a child named `snapshot`.
+ */
+declare const $: unique symbol;
+//#endregion
+//#region src/schema.d.ts
+/**
+ * @private
+ * Flattens an intersection into a single object type for readable hovers.
+ */
+type Simplify<TObject> = { [TKey in keyof TObject]: TObject[TKey] } & {};
+/**
+ * The open registry of kind names. Custom kinds register themselves via
+ * module augmentation:
+ *
+ * ```ts
+ * declare module "pleach" {
+ *   interface KindRegistry { richtext: true }
+ * }
+ * ```
+ */
+interface KindRegistry {
+  scalar: true;
+  text: true;
+  list: true;
+  object: true;
+  map: true;
+  union: true;
+  counter: true;
+  opaque: true;
+}
+/**
+ * The concurrent-editing semantics of one part of a state tree. An ArkType
+ * validator alone cannot distinguish a last-write-wins string register from
+ * collaboratively editable text — the kind carries that distinction.
+ */
+type Kind = Extract<keyof KindRegistry, string>;
+/**
+ * The description of a piece of state: data shape, validation, and merge
+ * semantics.
+ *
+ * Declared as a function intersection rather than an interface call
+ * signature because the latter defeats generic inference at consumer call
+ * sites (proven in the formeddable prior art).
+ *
+ * - `TInput` — the editable (pre-validation) shape mutation works with.
+ * - `TValue` — the validated (post-morph) shape `validate` produces.
+ * - `TKind` — this schema's own kind.
+ * - `TNode` — the live node type this schema materializes.
+ * - `TKinds` — the union of kinds this subtree *requires of a backend*.
+ *   Composed kinds decompose: a union contributes `"scalar" | "object"`, a
+ *   counter contributes `"map"`, opaque contributes `"scalar"`. This is what
+ *   `createStore` checks against a backend's `supportedKinds` at compile
+ *   time.
+ */
+type Schema<TInput = unknown, TValue = TInput, TKind extends Kind = Kind, TNode extends Node<TInput> = Node<TInput>, TKinds extends Kind = Kind> = ((input: unknown) => TValue | ArkErrors) & SchemaMembers<TInput, TValue, TKind, TNode, TKinds>;
+/** The members every {@link Schema} carries alongside its call signature. */
+interface SchemaMembers<TInput, TValue, TKind extends Kind, TNode extends Node<TInput>, TKinds extends Kind> {
+  /** The concurrent-editing semantics of this part of the tree. */
+  readonly kind: TKind;
+  /**
+   * Pipes this schema's value into another ArkType schema, mirroring
+   * ArkType's `Type.to`. The schema must accept the current value as input;
+   * the result keeps this schema's editable input and node and takes its
+   * value from the piped schema's output. `s.text().to("string.numeric.parse")`
+   * is edited as collaborative text and validates to a number.
+   */
+  to<const TSchema>(schema: type.validate<TSchema> & ([TValue] extends [type.infer.In<TSchema>] ? unknown : "schema must accept this schema's value as input")): Schema<TInput, type.infer.Out<TSchema>, TKind, TNode, TKinds>;
+  /**
+   * Pipes this schema's value through a transform, mirroring ArkType's
+   * `Type.pipe` — the escape hatch for conversions a schema string can't
+   * express.
+   */
+  pipe<TNext>(morph: (value: TValue) => TNext): Schema<TInput, TNext, TKind, TNode, TKinds>;
+  /**
+   * Bakes in an initial input, applied on materialization when no loaded
+   * value exists.
+   */
+  default(input: TInput): Schema<TInput, TValue, TKind, TNode, TKinds>;
+  /** Hidden internals: the compiled ArkType plus phantom inference slots. */
+  readonly [$]: {
+    /** The compiled ArkType backing this schema's validation. */readonly arkType: Type; /** Phantom; never present at runtime. */
+    readonly input: TInput; /** Phantom; never present at runtime. */
+    readonly value: TValue; /** Phantom; never present at runtime. */
+    readonly node: TNode; /** Phantom; never present at runtime. */
+    readonly kinds: TKinds;
+  };
+}
+/**
+ * A schema with all generics erased — the existential bucket used where
+ * schemas of unrelated shapes must mix.
+ */
+type AnySchema = Schema<unknown, unknown, Kind, AnyNode, Kind>;
+/** The editable (pre-validation) value shape of a schema. */
+type InputOf<TSchema extends AnySchema> = TSchema[typeof $]["input"];
+/** The validated (post-morph) value shape of a schema. */
+type ValueOf<TSchema extends AnySchema> = TSchema[typeof $]["value"];
+/** The live node type a schema materializes. */
+type NodeOf<TSchema extends AnySchema> = TSchema[typeof $]["node"];
+/**
+ * The union of kinds a schema's subtree requires a backend to support.
+ * Composed kinds appear as the primitives they decompose into.
+ */
+type KindsOf<TSchema extends AnySchema> = TSchema[typeof $]["kinds"];
+/** The `{ input; value }` bundle, in the style of alge's `Infer`. */
+type Infer<TSchema extends AnySchema> = {
+  input: InputOf<TSchema>;
+  value: ValueOf<TSchema>;
+};
+/** A fixed record of named child schemas — the argument to `s.object`. */
+type Shape = Record<string, AnySchema>;
+/** The editable value shape of an object schema's children. */
+type ShapeInput<TShape extends Shape> = Simplify<{ -readonly [TKey in keyof TShape]: InputOf<TShape[TKey]> }>;
+/** The validated value shape of an object schema's children. */
+type ShapeValue<TShape extends Shape> = Simplify<{ -readonly [TKey in keyof TShape]: ValueOf<TShape[TKey]> }>;
+/** The kinds required by any child of a shape. */
+type ShapeKinds<TShape extends Shape> = KindsOf<TShape[keyof TShape]>;
+/** The variants record accepted by `s.union` — plain shapes, not schemas. */
+type VariantShapes = Record<string, Shape>;
+/** The flat, discriminated editable shape of a union — alge-style. */
+type UnionInput<TTag extends string, TVariants extends VariantShapes> = { [TKey in keyof TVariants & string]: Simplify<Record<TTag, TKey> & ShapeInput<TVariants[TKey]>> }[keyof TVariants & string];
+/** The flat, discriminated validated shape of a union. */
+type UnionValue<TTag extends string, TVariants extends VariantShapes> = { [TKey in keyof TVariants & string]: Simplify<Record<TTag, TKey> & ShapeValue<TVariants[TKey]>> }[keyof TVariants & string];
+/** The kinds a union requires: its own decomposition plus its fields'. */
+type UnionKinds<TVariants extends VariantShapes> = "scalar" | "object" | { [TKey in keyof TVariants]: ShapeKinds<TVariants[TKey]> }[keyof TVariants];
+/** Exhaustive per-tag handlers over flat variant values. */
+type UnionValueCases<TTag extends string, TVariants extends VariantShapes> = { readonly [TKey in keyof TVariants & string]: (value: Simplify<Record<TTag, TKey> & ShapeInput<TVariants[TKey]>>) => unknown };
+/**
+ * The variant names whose shape declares a field colliding with the tag key.
+ */
+type CollidingVariants<TTag extends string, TVariants extends VariantShapes> = { [TKey in keyof TVariants]: TTag extends keyof TVariants[TKey] ? TKey : never }[keyof TVariants];
+type ValidateTag<TTag extends string, TVariants extends VariantShapes> = [CollidingVariants<TTag, TVariants>] extends [never] ? unknown : `variant '${CollidingVariants<TTag, TVariants> & string}' declares a field named '${TTag}'`;
+/**
+ * A union schema: a {@link Schema} that additionally hosts exhaustive
+ * matching over flat (snapshot) values. Matching over live nodes lives on
+ * {@link UnionNode}.
+ */
+type UnionSchema<TTag extends string, TVariants extends VariantShapes> = Schema<UnionInput<TTag, TVariants>, UnionValue<TTag, TVariants>, "union", UnionNode<TTag, TVariants>, UnionKinds<TVariants>> & {
+  /**
+   * Exhaustive match over a flat union value. All tags are required unless
+   * `_` is present; the result type is the union of the cases' returns.
+   */
+  match<TCases extends UnionValueCases<TTag, TVariants> | PartialCases<UnionValueCases<TTag, TVariants>>>(value: UnionInput<TTag, TVariants>, cases: TCases): CaseResult<TCases>;
+};
+/**
+ * Builders for state schemas — `import { s } from "pleach"`.
+ *
+ * Each builder pairs an ArkType validator with the concurrent-editing
+ * semantics of that part of the state tree; composite builders assemble
+ * their validator from their children so validation has a single source of
+ * truth. ArkType accepts any Standard Schema (`s.scalar(z.string())` works),
+ * so zod/valibot users enter for free.
+ */
+interface SchemaBuilders {
+  /**
+   * Collaboratively editable text. Prefer this for free-form text controls;
+   * use `s.scalar("string")` when last-write-wins is enough (selects, radio
+   * values, generated identifiers).
+   */
+  text(): Schema<string, string, "text", TextNode, "text">;
+  /**
+   * A whole-value register validated by an ArkType schema. Morphs split the
+   * input and value types: `s.scalar("string.numeric.parse")` is edited as a
+   * string and validates to a number.
+   */
+  scalar<const TSchema>(schema: type.validate<TSchema>): Schema<type.infer.In<TSchema>, type.infer.Out<TSchema>, "scalar", ScalarNode<type.infer.In<TSchema>>, "scalar">;
+  /**
+   * A register for structured values that are replaced atomically — file
+   * references, geo points, rich values picked whole from a dialog. The kind
+   * tells collaborative backends never to merge concurrent edits inside the
+   * value.
+   */
+  opaque<const TSchema>(schema: type.validate<TSchema>): Schema<type.infer.In<TSchema>, type.infer.Out<TSchema>, "opaque", ScalarNode<type.infer.In<TSchema>>, "scalar">;
+  /** An ordered collection of nested state, edited per position. */
+  list<const TItem extends AnySchema>(item: TItem): Schema<Array<InputOf<TItem>>, Array<ValueOf<TItem>>, "list", ListNode<TItem>, "list" | KindsOf<TItem>>;
+  /**
+   * A fixed shape of named children, each edited independently and exposed
+   * as a property of the object node.
+   */
+  object<const TShape extends Shape>(shape: TShape): Schema<ShapeInput<TShape>, ShapeValue<TShape>, "object", ObjectNode<TShape>, "object" | ShapeKinds<TShape>>;
+  /**
+   * A dynamic string-keyed collection — records keyed by id. Concurrent sets
+   * on the same key last-write-win; distinct keys merge.
+   */
+  map<const TValue extends AnySchema>(value: TValue): Schema<Record<string, InputOf<TValue>>, Record<string, ValueOf<TValue>>, "map", MapNode<TValue>, "map" | KindsOf<TValue>>;
+  /**
+   * A discriminated ADT. The tag is an LWW register; each variant's fields
+   * live in an independent subtree retained across tag switches. Variants
+   * are plain shape records so the snapshot stays flat and the tag key can
+   * be checked against variant field names — declaring a field named like
+   * the tag is a compile error.
+   */
+  union<const TTag extends string, const TVariants extends VariantShapes>(tag: TTag & ValidateTag<TTag, TVariants>, variants: TVariants): UnionSchema<TTag, TVariants>;
+  /**
+   * A number whose concurrent increments merge additively — a PN-counter,
+   * composed from a map of per-actor sums. Backends never see this kind.
+   */
+  counter(): Schema<number, number, "counter", CounterNode, "map">;
+}
+declare const s: SchemaBuilders;
+//#endregion
+//#region src/node.d.ts
+/**
+ * The provenance of a change. Beyond the four built-in origins, any token
+ * passed to `store.transact(fn, { origin })` flows through unchanged.
+ */
+type Origin = "local" | "remote" | "undo" | "load" | (string & {}) | object;
+/** Delivered to every subscriber when a subtree changes. */
+interface Change {
+  readonly origin: Origin;
+  /** Convenience: whether this client caused the change. */
+  readonly local: boolean;
+}
+type Unsubscribe = () => void;
+interface LoadOptions {
+  /** Suppresses change notification, for batch loads that notify once at the end. */
+  readonly silent?: boolean;
+}
+/** The structural operations behind `$`, shared by every node kind. */
+interface NodeOps<TInput> {
+  /** Resolves one path segment to a child node, if this kind has children. */
+  child(segment: string | number): AnyNode | undefined;
+  /**
+   * Whether this subtree holds a value. Distinguishes "never touched"
+   * (absent from snapshots) from explicit empty values such as a cleared
+   * list.
+   */
+  hasValue(): boolean;
+  /** Replaces this subtree's contents from a plain value. Origin: `"load"`. */
+  load(value: unknown, options?: LoadOptions): void;
+  /**
+   * An immutable, structurally shared plain-data view of this subtree, or
+   * `undefined` when no value is present. Unchanged subtrees keep reference
+   * identity between snapshots.
+   */
+  snapshot(): TInput | undefined;
+  /** Subscribes to changes anywhere in this subtree. Returns an unsubscriber. */
+  subscribe(listener: (change: Change) => void): Unsubscribe;
+}
+/**
+ * A live, mutable piece of state. Kind-specific API is public; structural
+ * operations live behind the `$` symbol.
+ */
+interface Node<TInput = unknown> {
+  readonly [$]: NodeOps<TInput>;
+}
+/**
+ * A node with its input type erased — the existential bucket used where
+ * nodes of unrelated shapes must mix.
+ */
+type AnyNode = Node<unknown>;
+/**
+ * A whole-value register. `set` replaces the value; concurrent writers
+ * last-write-win.
+ */
+interface ScalarNode<TInput> extends Node<TInput> {
+  set(value: TInput): void;
+}
+/**
+ * Collaboratively editable text, stored as a character sequence with
+ * per-position inserts and deletes rather than as a register.
+ */
+interface TextNode extends Node<string> {
+  /** Replaces the whole text — a register-style write. */
+  set(value: string): void;
+  /** Inserts `text` at character position `index`. */
+  insert(index: number, text: string): void;
+  /** Deletes `count` characters starting at character position `index`. */
+  delete(index: number, count: number): void;
+  /**
+   * Diffs `next` against the current value and emits the minimal
+   * insert/delete pair. The default choice for controlled inputs — it turns
+   * "the input now contains X" into collaboration-friendly per-position
+   * edits instead of a whole-value write.
+   */
+  apply(next: string): void;
+}
+/**
+ * An ordered collection of nested state. All edits are per position — there
+ * is deliberately no way to replace the whole array and no arbitrary move.
+ */
+interface ListNode<TItem extends AnySchema> extends Node<Array<InputOf<TItem>>> {
+  readonly length: number;
+  /** The item node at `index`, or `undefined` when out of bounds. */
+  at(index: number): NodeOf<TItem> | undefined;
+  /** The item node at `index`; throws when out of bounds. */
+  get(index: number): NodeOf<TItem>;
+  /** Appends a new item and returns its node. */
+  push(initialValue?: InputOf<TItem>): NodeOf<TItem>;
+  /** Inserts a new item at `index` and returns its node. */
+  insert(index: number, initialValue?: InputOf<TItem>): NodeOf<TItem>;
+  /** Deletes `count` items (default one) starting at `index`. */
+  delete(index: number, count?: number): void;
+  /** Empties the list. The list remains present, snapshotting as `[]`. */
+  clear(): void;
+  /**
+   * Iterates `[index, node, key]` tuples. The key is a backend-stable item
+   * identity for the lifetime of an item regardless of reordering — use it
+   * for React list keys.
+   */
+  entries(): IterableIterator<[index: number, node: NodeOf<TItem>, key: string]>;
+  map<TResult>(fn: (node: NodeOf<TItem>, index: number) => TResult): TResult[];
+  [Symbol.iterator](): IterableIterator<NodeOf<TItem>>;
+}
+/**
+ * A fixed shape of named children, each edited independently. Child nodes
+ * are exposed as properties — `node.address.city` — and are the node's only
+ * string keys, so author-chosen names can never collide with internals.
+ */
+type ObjectNode<TShape extends Shape> = { readonly [TKey in keyof TShape]: NodeOf<TShape[TKey]> } & Node<ShapeInput<TShape>>;
+/**
+ * A dynamic string-keyed collection — the primitive for "records keyed by
+ * id". Concurrent sets on the same key last-write-win; distinct keys merge;
+ * add and delete are per key. Entries are reached through `get`, never as
+ * properties: the property-access sugar belongs to `ObjectNode` alone.
+ */
+interface MapNode<TValue extends AnySchema> extends Node<Record<string, InputOf<TValue>>> {
+  readonly size: number;
+  has(key: string): boolean;
+  get(key: string): NodeOf<TValue> | undefined;
+  /** Creates (or replaces) the entry at `key` and returns its node. */
+  set(key: string, initialValue?: InputOf<TValue>): NodeOf<TValue>;
+  delete(key: string): void;
+  clear(): void;
+  keys(): IterableIterator<string>;
+  entries(): IterableIterator<[key: string, node: NodeOf<TValue>]>;
+  [Symbol.iterator](): IterableIterator<[key: string, node: NodeOf<TValue>]>;
+}
+/**
+ * A number whose concurrent increments merge additively instead of
+ * last-write-wins — two peers who each add 1 yield 2, not 1. Composed from a
+ * map of per-actor sums; backends never see this kind.
+ */
+interface CounterNode extends Node<number> {
+  readonly value: number;
+  increment(by?: number): void;
+  decrement(by?: number): void;
+}
+/** Exhaustive per-tag handlers over variant nodes. */
+type UnionNodeCases<TVariants extends VariantShapes> = { readonly [TKey in keyof TVariants]: (variant: ObjectNode<TVariants[TKey]>) => unknown };
+/** Partial handlers with a required fallback (which also covers the empty state). */
+type PartialCases<TCases> = Partial<TCases> & {
+  readonly _: () => unknown;
+};
+/** The union of a case record's return types. */
+type CaseResult<TCases> = { [TKey in keyof TCases]: TCases[TKey] extends ((...args: never[]) => infer TResult) ? TResult : never }[keyof TCases];
+/**
+ * A discriminated ADT node. The tag is an LWW scalar register; each
+ * variant's fields live in an independent subtree that is retained across
+ * tag switches (snapshots and validation expose only the active variant).
+ *
+ * Variant fields are deliberately not flattened onto this node — the union
+ * node needs public methods, and method names must never mix with
+ * author-chosen field names. Access goes through `variant`, `as`, or `match`.
+ */
+interface UnionNode<TTag extends string, TVariants extends VariantShapes> extends Node<UnionInput<TTag, TVariants>> {
+  /** The active variant's tag; `undefined` when the union holds no value yet. */
+  readonly tag: (keyof TVariants & string) | undefined;
+  /** The active variant's object node; `undefined` when no value yet. */
+  readonly variant: { [TKey in keyof TVariants]: ObjectNode<TVariants[TKey]> }[keyof TVariants] | undefined;
+  /** Type guard: narrows both `tag` and `variant` in one check. */
+  is<TKey extends keyof TVariants & string>(tag: TKey): this is UnionNode<TTag, TVariants> & {
+    readonly tag: TKey;
+    readonly variant: ObjectNode<TVariants[TKey]>;
+  };
+  /** Narrowed access without a guard; `undefined` when another variant is active. */
+  as<TKey extends keyof TVariants & string>(tag: TKey): ObjectNode<TVariants[TKey]> | undefined;
+  /**
+   * Switches variants — an LWW tag write — and returns the (retained or
+   * fresh) variant node.
+   */
+  set<TKey extends keyof TVariants & string>(tag: TKey, initialValue?: Simplify<ShapeInput<TVariants[TKey]>>): ObjectNode<TVariants[TKey]>;
+  /**
+   * Exhaustive match over variant nodes. All tags are required unless `_` is
+   * present; `_` also covers the empty (no-value) state, which otherwise
+   * throws. The result type is the union of the cases' return types.
+   */
+  match<TCases extends UnionNodeCases<TVariants> | PartialCases<UnionNodeCases<TVariants>>>(cases: TCases): CaseResult<TCases>;
+}
+/**
+ * Resolves a dynamic path to a descendant node, or `undefined` when any
+ * segment is missing. The untyped escape hatch for callers that only know
+ * paths at runtime (visual builders); typed code traverses node properties
+ * instead.
+ */
+declare function resolve(node: AnyNode, segments: ReadonlyArray<string | number>): AnyNode | undefined;
+//#endregion
+//#region src/spi.d.ts
+/** The closed set of driver primitives every backend must provide. */
+type PrimitiveKind = "scalar" | "text" | "list" | "object" | "map";
+/** A capability record with no capabilities. */
+type NoCapabilities = Record<never, never>;
+/** Delivered by every driver's `observe`. */
+interface DriverChange {
+  readonly origin: Origin;
+}
+/** A whole-value register cell. */
+interface ScalarDriver {
+  get(): unknown;
+  has(): boolean;
+  set(value: unknown): void;
+  clear(): void;
+  observe(callback: (change: DriverChange) => void): Unsubscribe;
+}
+/** A character sequence with per-position edits. */
+interface TextDriver {
+  get(): string | undefined;
+  has(): boolean;
+  insert(index: number, text: string): void;
+  delete(index: number, count: number): void;
+  set(value: string): void;
+  clear(): void;
+  observe(callback: (change: DriverChange) => void): Unsubscribe;
+}
+/** An ordered container of child slots with per-position edits. */
+interface ListDriver {
+  readonly length: number;
+  /**
+   * A backend-stable identity for the item at `index` — stable for the
+   * lifetime of the item regardless of reordering (yjs: item IDs; local: a
+   * counter). Surfaces as the React list key.
+   */
+  key(index: number): string;
+  /** Allocates a child slot at `index`. */
+  insert(index: number): DriverSlot;
+  delete(index: number, count: number): void;
+  child(index: number): DriverSlot | undefined;
+  clear(): void;
+  observe(callback: (change: DriverChange) => void): Unsubscribe;
+}
+/** A fixed-key container; children are allocated lazily per key. */
+interface ObjectDriver {
+  child(key: string): DriverSlot;
+  observe(callback: (change: DriverChange) => void): Unsubscribe;
+}
+/** An open-key container with per-key adds and deletes. */
+interface MapDriver {
+  keys(): IterableIterator<string>;
+  has(key: string): boolean;
+  /** Creates (or replaces) the entry at `key` and returns its slot. */
+  set(key: string): DriverSlot;
+  delete(key: string): void;
+  child(key: string): DriverSlot | undefined;
+  observe(callback: (change: DriverChange) => void): Unsubscribe;
+}
+type AnyDriver = ScalarDriver | TextDriver | ListDriver | ObjectDriver | MapDriver;
+/**
+ * A place where a child driver of any primitive kind can be materialized —
+ * one position in a container, reified.
+ *
+ * The slot is the handshake between the two layers: the backend knows
+ * *where* children live (it owns the containers), core knows *what* lives
+ * there (it owns the schema). Calling one of these methods materializes the
+ * driver for this position — creating storage if the position is empty,
+ * adopting what's there if it already holds data (a loaded doc, a remote
+ * peer's insert). One slot, one call, one child.
+ */
+interface DriverSlot {
+  scalar(): ScalarDriver;
+  text(): TextDriver;
+  list(): ListDriver;
+  object(): ObjectDriver;
+  map(): MapDriver;
+}
+/** A document-level connection opened by a backend for one store. */
+interface Session<TCaps extends object = NoCapabilities> {
+  /** Stable per-client identity (yjs: `doc.clientID`; local: random). */
+  readonly actorId: string;
+  /** The root container driver. */
+  readonly root: ObjectDriver;
+  /** Batches writes into one change, tagged with `origin`. */
+  transact<TResult>(fn: () => TResult, origin: Origin): TResult;
+  /**
+   * An optional backend-native driver for a registered non-primitive kind
+   * (e.g. a future yjs richtext). Preferred over composition when offered.
+   */
+  native?(kind: Kind, slot: DriverSlot): AnyDriver | undefined;
+  /** Grafted onto the store, typed — see `CapabilitiesOf`. */
+  readonly capabilities: TCaps;
+  destroy(): void;
+}
+/**
+ * Where state actually lives. Instances come from factories — `local()`,
+ * `yjs({...})` — and are handed to `createStore`.
+ */
+interface Backend<TKinds extends Kind = PrimitiveKind, TCaps extends object = NoCapabilities> {
+  /** The primitives (plus any native kind overrides) this backend materializes. */
+  readonly supportedKinds: readonly TKinds[];
+  open(schema: AnySchema): Session<TCaps>;
+}
+/** A backend with its generics erased. */
+type AnyBackend = Backend<Kind, object>;
+/** The kinds a backend can materialize, recovered from its type. */
+type SupportedKindsOf<TBackend extends AnyBackend> = TBackend extends Backend<infer TKinds, infer _TCaps> ? TKinds : never;
+/** The capability record a backend grafts onto its stores. */
+type CapabilitiesOf<TBackend extends AnyBackend> = TBackend extends Backend<infer _TKinds, infer TCaps> ? TCaps : NoCapabilities;
+//#endregion
+export { UnionValueCases as $, UnionNode as A, NodeOf as B, Node as C, PartialCases as D, Origin as E, Infer as F, ShapeInput as G, SchemaBuilders as H, InputOf as I, Simplify as J, ShapeKinds as K, Kind as L, Unsubscribe as M, resolve as N, ScalarNode as O, AnySchema as P, UnionValue as Q, KindRegistry as R, MapNode as S, ObjectNode as T, SchemaMembers as U, Schema as V, Shape as W, UnionKinds as X, UnionInput as Y, UnionSchema as Z, CaseResult as _, DriverChange as a, ListNode as b, MapDriver as c, PrimitiveKind as d, ValueOf as et, ScalarDriver as f, AnyNode as g, TextDriver as h, CapabilitiesOf as i, UnionNodeCases as j, TextNode as k, NoCapabilities as l, SupportedKindsOf as m, AnyDriver as n, s as nt, DriverSlot as o, Session as p, ShapeValue as q, Backend as r, $ as rt, ListDriver as s, AnyBackend as t, VariantShapes as tt, ObjectDriver as u, Change as v, NodeOps as w, LoadOptions as x, CounterNode as y, KindsOf as z };

package/dist/spi.d.mts

@@ -0,0 +1,2 @@
+import { a as DriverChange, c as MapDriver, d as PrimitiveKind, f as ScalarDriver, h as TextDriver, i as CapabilitiesOf, l as NoCapabilities, m as SupportedKindsOf, n as AnyDriver, o as DriverSlot, p as Session, r as Backend, s as ListDriver, t as AnyBackend, u as ObjectDriver } from "./spi-CzHSw4BF.mjs";
+export { AnyBackend, AnyDriver, Backend, CapabilitiesOf, DriverChange, DriverSlot, ListDriver, MapDriver, NoCapabilities, ObjectDriver, PrimitiveKind, ScalarDriver, Session, SupportedKindsOf, TextDriver };

package/dist/spi.mjs

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

package/dist/store-NWV8hqvw.d.mts

@@ -0,0 +1,79 @@
+import { B as NodeOf, I as InputOf, M as Unsubscribe, P as AnySchema, d as PrimitiveKind, et as ValueOf, i as CapabilitiesOf, l as NoCapabilities, m as SupportedKindsOf, r as Backend, t as AnyBackend, v as Change, z as KindsOf } from "./spi-CzHSw4BF.mjs";
+import { r as UndoApi } from "./capabilities-ALpw-aBj.mjs";
+import { ArkErrors } from "arktype";
+
+//#region src/local.d.ts
+interface LocalOptions {
+  readonly undo?: boolean;
+}
+type LocalBackend<TOptions extends LocalOptions = LocalOptions> = Backend<PrimitiveKind, TOptions extends {
+  undo: true;
+} ? {
+  undo: UndoApi;
+} : NoCapabilities>;
+/** Creates an in-memory backend. `actorId` is random per session. */
+declare function local<const TOptions extends LocalOptions = LocalOptions>(options?: TOptions): LocalBackend<TOptions>;
+//#endregion
+//#region src/store.d.ts
+interface Store<TSchema extends AnySchema> {
+  readonly schema: TSchema;
+  /** The typed live tree. */
+  readonly root: NodeOf<TSchema>;
+  /**
+   * A cached, immutable snapshot of the whole tree, structurally shared:
+   * unchanged subtrees keep reference identity between calls.
+   */
+  get(): InputOf<TSchema> | undefined;
+  /**
+   * Validates the current snapshot — the same vocabulary as calling the
+   * schema: the (possibly morphed) value, or `ArkErrors`.
+   */
+  validate(): ValueOf<TSchema> | ArkErrors;
+  /** Document-level change feed. */
+  subscribe(listener: (change: Change) => void): Unsubscribe;
+  /**
+   * Selector subscription: fires when the selected value changes
+   * (`Object.is` by default).
+   */
+  subscribe<TSelected>(selector: (snapshot: InputOf<TSchema> | undefined) => TSelected, listener: (value: TSelected, previous: TSelected) => void, options?: {
+    readonly equals?: (a: TSelected, b: TSelected) => boolean;
+    readonly fireImmediately?: boolean;
+  }): Unsubscribe;
+  /**
+   * Batches writes into one notification, one undo step, and one tagged
+   * origin. Nested transactions flatten (inner adopts outer's origin).
+   * Every write outside an explicit transaction is an implicit single-op
+   * transaction with origin `"local"`.
+   */
+  transact<TResult>(fn: () => TResult, options?: {
+    readonly origin?: unknown;
+  }): TResult;
+  /** Replaces the tree from a plain value — one notification, origin `"load"`. */
+  load(value: InputOf<TSchema> | undefined): void;
+  /** Loads `undefined`; schema defaults reapply. */
+  reset(): void;
+  destroy(): void;
+  [Symbol.dispose](): void;
+}
+/** The store type a schema produces — `StoreOf<typeof Board>`. */
+type StoreOf<TSchema extends AnySchema> = Store<TSchema>;
+/** A store with its schema erased. */
+type AnyStore = Store<AnySchema>;
+/**
+ * Compile-time backend compatibility: resolves to `unknown` (accepting
+ * anything) when the backend supports every kind the schema requires, and to
+ * a string-literal error message otherwise — arktype-style.
+ */
+type BackendSupports<TSchema extends AnySchema, TBackend extends AnyBackend> = [Exclude<KindsOf<TSchema>, SupportedKindsOf<TBackend>>] extends [never] ? unknown : `backend does not support kind '${Exclude<KindsOf<TSchema>, SupportedKindsOf<TBackend>> & string}'`;
+interface CreateStoreOptions<TSchema extends AnySchema, TBackend extends AnyBackend> {
+  readonly backend?: TBackend & BackendSupports<TSchema, TBackend>;
+  readonly initial?: InputOf<TSchema>;
+}
+/**
+ * Materializes a schema into a live store on a backend (the in-memory local
+ * backend when none is given). The returned store carries the backend's
+ * capabilities as typed members — `yjs({ undo: true })` yields `store.undo`.
+ */
+declare function createStore<TSchema extends AnySchema, TBackend extends AnyBackend = LocalBackend>(schema: TSchema, options?: CreateStoreOptions<TSchema, TBackend>): Store<TSchema> & CapabilitiesOf<TBackend>;
+//#endregion
+export { StoreOf as a, LocalOptions as c, Store as i, local as l, BackendSupports as n, createStore as o, CreateStoreOptions as r, LocalBackend as s, AnyStore as t };

package/dist/yjs.d.mts

@@ -0,0 +1,58 @@
+import { I as InputOf, J as Simplify, P as AnySchema, d as PrimitiveKind, l as NoCapabilities, r as Backend } from "./spi-CzHSw4BF.mjs";
+import { n as SyncApi, r as UndoApi, t as PresenceApi } from "./capabilities-ALpw-aBj.mjs";
+import { Doc } from "yjs";
+
+//#region src/yjs.d.ts
+/**
+ * The slice of a y-protocols `Awareness` instance the presence capability
+ * needs — typed structurally so pleach never depends on y-protocols.
+ */
+interface AwarenessLike {
+  readonly clientID: number;
+  getLocalState(): Record<string, unknown> | null;
+  setLocalState(state: Record<string, unknown> | null): void;
+  getStates(): Map<number, Record<string, unknown>>;
+  on(event: string, handler: (...args: never[]) => void): void;
+  off(event: string, handler: (...args: never[]) => void): void;
+}
+interface YjsUndoOptions {
+  /** Edits closer together than this merge into one undo step. */
+  readonly captureTimeout?: number;
+  /** Transaction origins the undo manager tracks; defaults to this store's. */
+  readonly trackedOrigins?: ReadonlySet<unknown>;
+}
+interface YjsOptions {
+  /** A `Y.Doc` the app has already wired to its providers. */
+  readonly doc: Doc;
+  /**
+   * The top-level key this store lives under (`doc.getMap(root)`), enabling
+   * several stores per doc. Defaults to `"pleach"`.
+   */
+  readonly root?: string;
+  readonly undo?: boolean | YjsUndoOptions;
+  readonly awareness?: AwarenessLike;
+  /**
+   * A pleach schema typing the presence state end to end. Presence is
+   * ephemeral — validated, never merged; kinds don't apply.
+   */
+  readonly presence?: AnySchema;
+}
+/** The capability record a given options literal produces. */
+type YjsCapabilities<TOptions extends YjsOptions> = Simplify<(TOptions extends {
+  undo: true | YjsUndoOptions;
+} ? {
+  undo: UndoApi;
+} : NoCapabilities) & (TOptions extends {
+  awareness: AwarenessLike;
+} ? {
+  presence: PresenceApi<TOptions extends {
+    presence: infer TPresence extends AnySchema;
+  } ? InputOf<TPresence> : Record<string, unknown>>;
+} : NoCapabilities) & {
+  sync: SyncApi;
+}>;
+type YjsBackend<TOptions extends YjsOptions> = Backend<PrimitiveKind, YjsCapabilities<TOptions>>;
+/** Creates a collaborative backend over a user-wired `Y.Doc`. */
+declare function yjs<const TOptions extends YjsOptions>(options: TOptions): YjsBackend<TOptions>;
+//#endregion
+export { AwarenessLike, YjsBackend, YjsCapabilities, YjsOptions, YjsUndoOptions, yjs };

package/dist/yjs.mjs

@@ -0,0 +1,8 @@
+import { n as todo } from "./internal-CnZZ5Mhp.mjs";
+//#region src/yjs.ts
+/** Creates a collaborative backend over a user-wired `Y.Doc`. */
+function yjs(options) {
+	return todo("yjs");
+}
+//#endregion
+export { yjs };

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "pleached",
+  "version": "0.0.1",
+  "description": "Schema-first, CRDT-native state: declare shape and merge semantics once, swap storage backends freely.",
+  "keywords": [
+    "collaboration",
+    "crdt",
+    "react",
+    "schema",
+    "state",
+    "store",
+    "yjs"
+  ],
+  "homepage": "https://github.com/eralmansouri/pleach#readme",
+  "bugs": {
+    "url": "https://github.com/eralmansouri/pleach/issues"
+  },
+  "license": "MIT",
+  "author": "Eral Almansouri",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eralmansouri/pleach.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./react": {
+      "types": "./dist/react.d.mts",
+      "default": "./dist/react.mjs"
+    },
+    "./yjs": {
+      "types": "./dist/yjs.d.mts",
+      "default": "./dist/yjs.mjs"
+    },
+    "./spi": {
+      "types": "./dist/spi.d.mts",
+      "default": "./dist/spi.mjs"
+    }
+  },
+  "scripts": {
+    "build": "vp pack src/index.ts src/react.ts src/yjs.ts src/spi.ts --dts --clean --publint",
+    "check": "vp check",
+    "test": "vp test",
+    "test:watch": "vp test --watch"
+  },
+  "dependencies": {
+    "arktype": "^2.2.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^25.1.0",
+    "@types/react": "^19.2.4",
+    "@types/react-dom": "^19.2.3",
+    "jsdom": "^26.1.0",
+    "publint": "^0.3.21",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "typescript": "^6.0.2",
+    "vite-plus": "^0.2.2",
+    "yjs": "^13.6.20"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "yjs": ">=13.6.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "yjs": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@10.33.0"
+}