@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/transform/replace_step.d.ts

@@ -0,0 +1,109 @@
+import { Slice } from "../model/replace.js";
+import { AnySchema } from "../model/schema.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { Mappable, StepMap } from "./map.js";
+import { Step, StepJSON, StepResult } from "./step.js";
+import * as Option from "effect/Option";
+/**
+ * Replace a part of the document with a slice of new content.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+export declare class ReplaceStep<Sc extends AnySchema = AnySchema> extends Step<Sc> {
+  /** The start position of the replaced range. */
+  readonly from: number;
+  /** The end position of the replaced range. */
+  readonly to: number;
+  /** The slice to insert. */
+  readonly slice: Slice<Sc>;
+  /** @internal */
+  readonly structure: boolean;
+  /**
+   * The given `slice` should fit the 'gap' between `from` and `to`—the
+   * depths must line up, and the surrounding nodes must be able to be
+   * joined with the open sides of the slice. When `structure` is true,
+   * the step will fail if the content between from and to is not just
+   * a sequence of closing and then opening tokens (this is to guard
+   * against rebased replace steps overwriting something they weren't
+   * supposed to).
+   */
+  constructor(
+  /** The start position of the replaced range. */
+  from: number,
+  /** The end position of the replaced range. */
+  to: number,
+  /** The slice to insert. */
+  slice: Slice<Sc>,
+  /** @internal */
+  structure?: boolean);
+  apply(doc: Node<Sc>): StepResult<Sc>;
+  getMap(): StepMap;
+  invert(doc: Node<Sc>): Step<Sc>;
+  map(mapping: Mappable): Option.Option<Step<Sc>>;
+  merge(other: Step<Sc>): Option.Option<Step<Sc>>;
+  toJSON(): StepJSON;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(schema: Sc, json: any): ReplaceStep<Sc>;
+  /**
+   * By default, for backwards compatibility, an inserting step mapped
+   * over an insertion at that same position fill move after the
+   * inserted content. In a collaborative editing situation, that can
+   * make redone insertions appear in unexpected places. You can set
+   * this to -1 to make such mapping keep the step before the insertion
+   * instead.
+   */
+  static MAP_BIAS: -1 | 1;
+}
+/**
+ * Replace a part of the document with a slice of content, but preserve
+ * a range of the replaced content by moving it into the slice.
+ *
+ * @since 0.1.0
+ * @category steps
+ */
+export declare class ReplaceAroundStep<Sc extends AnySchema = AnySchema> extends Step<Sc> {
+  /** The start position of the replaced range. */
+  readonly from: number;
+  /** The end position of the replaced range. */
+  readonly to: number;
+  /** The start of preserved range. */
+  readonly gapFrom: number;
+  /** The end of preserved range. */
+  readonly gapTo: number;
+  /** The slice to insert. */
+  readonly slice: Slice<Sc>;
+  /** The position in the slice where the preserved range should be inserted. */
+  readonly insert: number;
+  /** @internal */
+  readonly structure: boolean;
+  /**
+   * Create a replace-around step with the given range and gap.
+   * `insert` should be the point in the slice into which the content of
+   * the gap should be moved. `structure` has the same meaning as it has
+   * in the `ReplaceStep` class.
+   */
+  constructor(
+  /** The start position of the replaced range. */
+  from: number,
+  /** The end position of the replaced range. */
+  to: number,
+  /** The start of preserved range. */
+  gapFrom: number,
+  /** The end of preserved range. */
+  gapTo: number,
+  /** The slice to insert. */
+  slice: Slice<Sc>,
+  /** The position in the slice where the preserved range should be inserted. */
+  insert: number,
+  /** @internal */
+  structure?: boolean);
+  apply(doc: Node<Sc>): StepResult<Sc>;
+  getMap(): StepMap;
+  invert(doc: Node<Sc>): Step<Sc>;
+  map(mapping: Mappable): Option.Option<Step<Sc>>;
+  toJSON(): StepJSON;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(schema: Sc, json: any): ReplaceAroundStep<Sc>;
+}

package/dist/transform/replace_step.js

@@ -0,0 +1,175 @@
+import { JSONError } from "../model/errors.js";
+import { Slice } from "../model/replace.js";
+import { StepMap } from "./map.js";
+import { Step, StepResult } from "./step.js";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+// src/transform/replace_step.ts
+/**
+* Replace steps.
+*
+* @since 0.1.0
+*/
+/**
+* Replace a part of the document with a slice of new content.
+*
+* @since 0.1.0
+* @category steps
+*/
+var ReplaceStep = class ReplaceStep extends Step {
+	/**
+	* The given `slice` should fit the 'gap' between `from` and `to`—the
+	* depths must line up, and the surrounding nodes must be able to be
+	* joined with the open sides of the slice. When `structure` is true,
+	* the step will fail if the content between from and to is not just
+	* a sequence of closing and then opening tokens (this is to guard
+	* against rebased replace steps overwriting something they weren't
+	* supposed to).
+	*/
+	constructor(from, to, slice, structure = false) {
+		super();
+		this.from = from;
+		this.to = to;
+		this.slice = slice;
+		this.structure = structure;
+	}
+	apply(doc) {
+		if (this.structure && contentBetween(doc, this.from, this.to)) return StepResult.fail("Structure replace would overwrite content");
+		return StepResult.fromReplace(doc, this.from, this.to, this.slice);
+	}
+	getMap() {
+		return new StepMap([
+			this.from,
+			this.to - this.from,
+			this.slice.size
+		]);
+	}
+	invert(doc) {
+		return new ReplaceStep(this.from, this.from + this.slice.size, doc.sliceUnsafe(this.from, this.to));
+	}
+	map(mapping) {
+		const to = mapping.mapResult(this.to, -1);
+		const from = this.from === this.to && ReplaceStep.MAP_BIAS < 0 ? to : mapping.mapResult(this.from, 1);
+		if (from.deletedAcross && to.deletedAcross) return Option.none();
+		return Option.some(new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure));
+	}
+	merge(other) {
+		if (!(other instanceof ReplaceStep) || other.structure || this.structure) return Option.none();
+		if (this.from + this.slice.size === other.from && !this.slice.openEnd && !other.slice.openStart) {
+			const slice = this.slice.size + other.slice.size === 0 ? Slice.empty : new Slice(this.slice.content.append(other.slice.content), this.slice.openStart, other.slice.openEnd);
+			return Option.some(new ReplaceStep(this.from, this.to + (other.to - other.from), slice, this.structure));
+		} else if (other.to === this.from && !this.slice.openStart && !other.slice.openEnd) {
+			const slice = this.slice.size + other.slice.size === 0 ? Slice.empty : new Slice(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
+			return Option.some(new ReplaceStep(other.from, this.to, slice, this.structure));
+		}
+		return Option.none();
+	}
+	toJSON() {
+		return {
+			stepType: "replace",
+			from: this.from,
+			to: this.to,
+			...this.slice.size ? { slice: this.slice.toJSON() } : void 0,
+			...this.structure ? { structure: true } : void 0
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(schema, json) {
+		if (!Predicate.isNumber(json.from) || !Predicate.isNumber(json.to)) throw new JSONError({ message: "Invalid input for ReplaceStep.fromJSON" });
+		return new ReplaceStep(json.from, json.to, Slice.fromJSONUnsafe(schema, json.slice), !!json.structure);
+	}
+	static {
+		this.MAP_BIAS = 1;
+	}
+};
+Step.jsonID("replace", ReplaceStep);
+/**
+* Replace a part of the document with a slice of content, but preserve
+* a range of the replaced content by moving it into the slice.
+*
+* @since 0.1.0
+* @category steps
+*/
+var ReplaceAroundStep = class ReplaceAroundStep extends Step {
+	/**
+	* Create a replace-around step with the given range and gap.
+	* `insert` should be the point in the slice into which the content of
+	* the gap should be moved. `structure` has the same meaning as it has
+	* in the `ReplaceStep` class.
+	*/
+	constructor(from, to, gapFrom, gapTo, slice, insert, structure = false) {
+		super();
+		this.from = from;
+		this.to = to;
+		this.gapFrom = gapFrom;
+		this.gapTo = gapTo;
+		this.slice = slice;
+		this.insert = insert;
+		this.structure = structure;
+	}
+	apply(doc) {
+		if (this.structure && (contentBetween(doc, this.from, this.gapFrom) || contentBetween(doc, this.gapTo, this.to))) return StepResult.fail("Structure gap-replace would overwrite content");
+		const gap = doc.sliceUnsafe(this.gapFrom, this.gapTo);
+		if (gap.openStart || gap.openEnd) return StepResult.fail("Gap is not a flat range");
+		const inserted = this.slice.insertAt(this.insert, gap.content);
+		if (!inserted) return StepResult.fail("Content does not fit in gap");
+		return StepResult.fromReplace(doc, this.from, this.to, inserted);
+	}
+	getMap() {
+		return new StepMap([
+			this.from,
+			this.gapFrom - this.from,
+			this.insert,
+			this.gapTo,
+			this.to - this.gapTo,
+			this.slice.size - this.insert
+		]);
+	}
+	invert(doc) {
+		const gap = this.gapTo - this.gapFrom;
+		return new ReplaceAroundStep(this.from, this.from + this.slice.size + gap, this.from + this.insert, this.from + this.insert + gap, doc.sliceUnsafe(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+	}
+	map(mapping) {
+		const from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+		const gapFrom = this.from === this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+		const gapTo = this.to === this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
+		if (from.deletedAcross && to.deletedAcross || gapFrom < from.pos || gapTo > to.pos || gapFrom > gapTo) return Option.none();
+		return Option.some(new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure));
+	}
+	toJSON() {
+		return {
+			stepType: "replaceAround",
+			from: this.from,
+			to: this.to,
+			gapFrom: this.gapFrom,
+			gapTo: this.gapTo,
+			insert: this.insert,
+			...this.slice.size ? { slice: this.slice.toJSON() } : void 0,
+			...this.structure ? { structure: true } : void 0
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(schema, json) {
+		if (!Predicate.isNumber(json.from) || !Predicate.isNumber(json.to) || !Predicate.isNumber(json.gapFrom) || !Predicate.isNumber(json.gapTo) || !Predicate.isNumber(json.insert)) throw new JSONError({ message: "Invalid input for ReplaceAroundStep.fromJSON" });
+		return new ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo, Slice.fromJSONUnsafe(schema, json.slice), json.insert, !!json.structure);
+	}
+};
+Step.jsonID("replaceAround", ReplaceAroundStep);
+function contentBetween(doc, from, to) {
+	const $from = doc.resolveUnsafe(from);
+	let dist = to - from, depth = $from.depth;
+	while (dist > 0 && depth > 0 && $from.indexAfter(depth) === $from.node(depth).childCount) {
+		depth--;
+		dist--;
+	}
+	if (dist > 0) {
+		let next = $from.node(depth).content.content[$from.indexAfter(depth)];
+		while (dist > 0) {
+			if (!next || next.isLeaf) return true;
+			next = next.content.content[0];
+			dist--;
+		}
+	}
+	return false;
+}
+export { ReplaceAroundStep, ReplaceStep };

package/dist/transform/step.d.ts

@@ -0,0 +1,157 @@
+import { ModelError } from "../model/errors.js";
+import { Slice } from "../model/replace.js";
+import { AnySchema } from "../model/schema.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { StepError } from "./errors.js";
+import { Mappable, StepMap } from "./map.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as S from "effect/Schema";
+/**
+ * The JSON representation of a step. It always includes the step
+ * type's JSON id (see `Step.jsonID`) under `stepType`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface StepJSON {
+  readonly stepType: string;
+  readonly [key: string]: unknown;
+}
+/**
+ * Something that can deserialize steps of a given type: usually the
+ * step class itself, via a static `fromJSONUnsafe` method that throws
+ * a `JSONError` (or another model error) for invalid input.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface StepDeserializer {
+  readonly fromJSONUnsafe: (schema: AnySchema, json: any) => Step<any>;
+}
+/**
+ * A step object represents an atomic change. It generally applies only
+ * to the document it was created for, since the positions stored in it
+ * will only make sense for that document.
+ *
+ * New steps are defined by creating classes that extend `Step`,
+ * overriding the `apply`, `invert`, `map`, `getMap` and `toJSON`
+ * methods (plus a static `fromJSONUnsafe`), and registering the class
+ * with a unique JSON-serialization identifier using `Step.jsonID`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare abstract class Step<Sc extends AnySchema = AnySchema> {
+  /**
+   * Applies this step to the given document, returning a result object
+   * that either indicates failure, if the step can not be applied to
+   * this document, or indicates success by containing a transformed
+   * document.
+   */
+  abstract apply(doc: Node<Sc>): StepResult<Sc>;
+  /**
+   * Like `apply`, but returns an Effect that fails with a `StepError`
+   * when the step can't be applied.
+   */
+  applyEffect(doc: Node<Sc>): Effect.Effect<Node<Sc>, StepError>;
+  /**
+   * Get the step map that represents the changes made by this step,
+   * and which can be used to transform between positions in the old
+   * and the new document.
+   */
+  getMap(): StepMap;
+  /**
+   * Create an inverted version of this step. Needs the document as it
+   * was before the step as argument.
+   */
+  abstract invert(doc: Node<Sc>): Step<Sc>;
+  /**
+   * Map this step through a mappable thing, returning either a version
+   * of that step with its positions adjusted, or `None` if the step was
+   * entirely deleted by the mapping.
+   */
+  abstract map(mapping: Mappable): Option.Option<Step<Sc>>;
+  /**
+   * Try to merge this step with another one, to be applied directly
+   * after it. Returns the merged step when possible, `None` if the
+   * steps can't be merged.
+   */
+  merge(_other: Step<Sc>): Option.Option<Step<Sc>>;
+  /**
+   * Create a JSON-serializeable representation of this step. When
+   * defining this for a custom subclass, make sure the result object
+   * includes the step type's JSON id under the `stepType` property.
+   */
+  abstract toJSON(): StepJSON;
+  /**
+   * Deserialize a step from its JSON representation. Will call through
+   * to the step class' own implementation.
+   */
+  static fromJSON<Sc extends AnySchema>(schema: Sc, json: unknown): Effect.Effect<Step<Sc>, ModelError>;
+  /** Like `fromJSON`, but throws a `JSONError` (or other model error) for invalid input. */
+  static fromJSONUnsafe<Sc extends AnySchema>(schema: Sc, json: any): Step<Sc>;
+  /**
+   * To be able to serialize steps to JSON, each step needs a string ID
+   * to attach to its JSON representation. Use this method to register
+   * an ID for your step classes. Try to pick something that's unlikely
+   * to clash with steps from other modules. Throws a `TransformError`
+   * when the ID is already in use.
+   */
+  static jsonID<C extends StepDeserializer>(id: string, stepClass: C): C;
+}
+/**
+ * The result of applying a step. Contains either a new document or a
+ * failure value.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class StepResult<Sc extends AnySchema = AnySchema> {
+  /** @internal */
+  readonly docOrNull: Node<Sc> | null;
+  /** @internal */
+  readonly failedOrNull: string | null;
+  /** @internal */
+  constructor(
+  /** @internal */
+  docOrNull: Node<Sc> | null,
+  /** @internal */
+  failedOrNull: string | null);
+  /** The transformed document, if successful. */
+  get doc(): Option.Option<Node<Sc>>;
+  /** The failure message, if unsuccessful. */
+  get failed(): Option.Option<string>;
+  /** Convert the result to an Effect that fails with a `StepError` for failed results. */
+  toEffect(): Effect.Effect<Node<Sc>, StepError>;
+  /** Get the resulting document, throwing a `StepError` for failed results. */
+  getUnsafe(): Node<Sc>;
+  /** Create a successful step result. */
+  static ok<Sc extends AnySchema>(doc: Node<Sc>): StepResult<Sc>;
+  /** Create a failed step result. */
+  static fail<Sc extends AnySchema = AnySchema>(message: string): StepResult<Sc>;
+  /**
+   * Call `Node.replace` with the given arguments. Create a successful
+   * result if it succeeds, and a failed one if it fails with a model
+   * error (such as a `ReplaceError`).
+   */
+  static fromReplace<Sc extends AnySchema>(doc: Node<Sc>, from: number, to: number, slice: Slice<Sc>): StepResult<Sc>;
+}
+/**
+ * Apply a step, converting model errors thrown by its `apply` method
+ * (for example for positions outside of the document) to failed
+ * results.
+ *
+ * @internal
+ */
+export declare const applyStep: <Sc extends AnySchema>(step: Step<Sc>, doc: Node<Sc>) => StepResult<Sc>;
+/**
+ * An Effect `Schema` that decodes the JSON representation of a step
+ * (using the `Step.jsonID` registry) into a `Step` for the given
+ * document schema, and encodes steps back to JSON.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const StepFromJSON: <Sc extends AnySchema>(schema: Sc) => S.Codec<Step<Sc>, StepJSON>;

package/dist/transform/step.js

@@ -0,0 +1,168 @@
+import { attempt } from "../internal/attempt.js";
+import { JSONError, isModelError } from "../model/errors.js";
+import { StepError, TransformError } from "./errors.js";
+import { StepMap } from "./map.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as S from "effect/Schema";
+import * as Result from "effect/Result";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as SchemaIssue from "effect/SchemaIssue";
+// src/transform/step.ts
+/**
+* Steps: atomic, invertible, serializable document changes.
+*
+* @since 0.1.0
+*/
+const stepsByID = Object.create(null);
+/**
+* A step object represents an atomic change. It generally applies only
+* to the document it was created for, since the positions stored in it
+* will only make sense for that document.
+*
+* New steps are defined by creating classes that extend `Step`,
+* overriding the `apply`, `invert`, `map`, `getMap` and `toJSON`
+* methods (plus a static `fromJSONUnsafe`), and registering the class
+* with a unique JSON-serialization identifier using `Step.jsonID`.
+*
+* @since 0.1.0
+* @category models
+*/
+var Step = class Step {
+	/**
+	* Like `apply`, but returns an Effect that fails with a `StepError`
+	* when the step can't be applied.
+	*/
+	applyEffect(doc) {
+		return Effect.suspend(() => applyStep(this, doc).toEffect());
+	}
+	/**
+	* Get the step map that represents the changes made by this step,
+	* and which can be used to transform between positions in the old
+	* and the new document.
+	*/
+	getMap() {
+		return StepMap.empty;
+	}
+	/**
+	* Try to merge this step with another one, to be applied directly
+	* after it. Returns the merged step when possible, `None` if the
+	* steps can't be merged.
+	*/
+	merge(_other) {
+		return Option.none();
+	}
+	/**
+	* Deserialize a step from its JSON representation. Will call through
+	* to the step class' own implementation.
+	*/
+	static fromJSON(schema, json) {
+		return attempt(() => Step.fromJSONUnsafe(schema, json), isModelError);
+	}
+	/** Like `fromJSON`, but throws a `JSONError` (or other model error) for invalid input. */
+	static fromJSONUnsafe(schema, json) {
+		const stepType = Predicate.isObjectOrArray(json) && "stepType" in json ? json.stepType : void 0;
+		if (!Predicate.isString(stepType) || stepType === "") throw new JSONError({ message: "Invalid input for Step.fromJSON" });
+		const type = stepsByID[stepType];
+		if (!type) throw new JSONError({ message: `No step type ${stepType} defined` });
+		return type.fromJSONUnsafe(schema, json);
+	}
+	/**
+	* To be able to serialize steps to JSON, each step needs a string ID
+	* to attach to its JSON representation. Use this method to register
+	* an ID for your step classes. Try to pick something that's unlikely
+	* to clash with steps from other modules. Throws a `TransformError`
+	* when the ID is already in use.
+	*/
+	static jsonID(id, stepClass) {
+		if (id in stepsByID) throw new TransformError({ message: "Duplicate use of step JSON ID " + id });
+		stepsByID[id] = stepClass;
+		const proto = "prototype" in stepClass ? stepClass.prototype : void 0;
+		if (proto) proto.jsonID = id;
+		return stepClass;
+	}
+};
+/**
+* The result of applying a step. Contains either a new document or a
+* failure value.
+*
+* @since 0.1.0
+* @category models
+*/
+var StepResult = class StepResult {
+	/** @internal */
+	constructor(docOrNull, failedOrNull) {
+		this.docOrNull = docOrNull;
+		this.failedOrNull = failedOrNull;
+	}
+	/** The transformed document, if successful. */
+	get doc() {
+		return Option.fromNullishOr(this.docOrNull);
+	}
+	/** The failure message, if unsuccessful. */
+	get failed() {
+		return Option.fromNullishOr(this.failedOrNull);
+	}
+	/** Convert the result to an Effect that fails with a `StepError` for failed results. */
+	toEffect() {
+		return this.failedOrNull !== null ? Effect.fail(new StepError({ message: this.failedOrNull })) : Effect.succeed(this.docOrNull);
+	}
+	/** Get the resulting document, throwing a `StepError` for failed results. */
+	getUnsafe() {
+		if (this.failedOrNull !== null) throw new StepError({ message: this.failedOrNull });
+		return this.docOrNull;
+	}
+	/** Create a successful step result. */
+	static ok(doc) {
+		return new StepResult(doc, null);
+	}
+	/** Create a failed step result. */
+	static fail(message) {
+		return new StepResult(null, message);
+	}
+	/**
+	* Call `Node.replace` with the given arguments. Create a successful
+	* result if it succeeds, and a failed one if it fails with a model
+	* error (such as a `ReplaceError`).
+	*/
+	static fromReplace(doc, from, to, slice) {
+		return failOnModelError(() => StepResult.ok(doc.replaceUnsafe(from, to, slice)));
+	}
+};
+/**
+* Apply a step, converting model errors thrown by its `apply` method
+* (for example for positions outside of the document) to failed
+* results.
+*
+* @internal
+*/
+const applyStep = (step, doc) => failOnModelError(() => step.apply(doc));
+/**
+* Run `f`, converting a model error it throws to a failed result and
+* rethrowing anything else unchanged.
+*/
+const failOnModelError = (f) => Result.getOrElse(Result.try(f), (e) => {
+	if (isModelError(e)) return StepResult.fail(e.message);
+	throw e;
+});
+const StepJSONSchema = S.declare((u) => Predicate.isObjectOrArray(u) && "stepType" in u && Predicate.isString(u.stepType), { title: "StepJSON" });
+/**
+* An Effect `Schema` that decodes the JSON representation of a step
+* (using the `Step.jsonID` registry) into a `Step` for the given
+* document schema, and encodes steps back to JSON.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const StepFromJSON = (schema) => {
+	const target = S.declare((u) => u instanceof Step, { title: "Step" });
+	return StepJSONSchema.pipe(S.decodeTo(target, {
+		decode: SchemaGetter.transformEffect((json) => Effect.try({
+			try: () => Step.fromJSONUnsafe(schema, json),
+			catch: (e) => new SchemaIssue.InvalidValue({ message: Predicate.isError(e) ? e.message : String(e) }, json)
+		})),
+		encode: SchemaGetter.transform((step) => step.toJSON())
+	}));
+};
+export { Step, StepFromJSON, StepResult, applyStep };