lib0 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/delta/transformer/conform.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Makes the projected (side-B) delta conform to `$schema`, **recursively**: drops attributes, attribute
+ * values, child nodes, and text the schema does not recognize, and descends into kept delta-valued
+ * attributes and kept child nodes with a nested `conform` (a fresh instance per kept child/attr, kept in
+ * step with the content — modelled on `children` + `inline`). A child is kept iff its node-name matches
+ * one of the schema's child `$Delta`s; a non-delta child iff it validates against `$children`; text iff
+ * the schema allows text. Everything else is dropped, so the output is guaranteed to satisfy `$schema`.
+ *
+ * Content that needs no per-position handling (text, scalars, and nodes matched by a `$deltaAny`/`$any`
+ * schema) is coalesced into pass-through runs, so a `$deltaAny` schema is a true zero-overhead identity
+ * and an incremental edit costs O(change), not O(document).
+ *
+ * `applyA` (A → B) does the full recursive filtering. `applyB` (B → A) is a lightweight reverse: it
+ * validates each B-side op against `$schema` — throwing on any op that would break conformance — and
+ * otherwise passes the change through to A verbatim (a conformant B-edit is already valid on A). Full
+ * drop-aware B→A position remapping is deferred (see {@link ConformTransformer#applyB}).
+ * Marks are best-effort — marks on kept children/attrs ride through the position map; marks anchored to
+ * dropped content are dropped.
+ *
+ * @template {delta.DeltaConf} SchemaConf
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, SchemaConf>}
+ */
+export class Conform<SchemaConf extends delta.DeltaConf, IN extends delta.DeltaConf = any> extends Template<IN, SchemaConf> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d input delta schema
+     * @param {import('../../schema.js').Schema<delta.Delta<SchemaConf>>} $schema the schema the output must match
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, $schema: import("../../schema.js").Schema<delta.Delta<SchemaConf>>);
+    $schema: s.Schema<delta.Delta<SchemaConf>>;
+    config: Config;
+}
+/**
+ * Stateful, recursive transformer produced by {@link Conform}. See {@link Conform} for semantics.
+ *
+ * The A→B layout lives in {@link ConformTransformer#cmap} (the *child* map), a delta reused as a
+ * coalesced positional map (like `children`'s `childTs`): a `retain(n)` run = pass-through positions, an
+ * `insert([t])` = a child routed through nested conform `t`, a `delete(n)` run = dropped positions
+ * (width 0 on B). It is rebuilt only on a structural change, carrying the nested transformers by
+ * reference so their state survives; a change with only retains/modifies is routed in place.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class ConformTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     * @param {Config} config the schema-derived read-only config (computed once, see {@link configOf})
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, config: Config);
+    config: Config;
+    /** @type {delta.DeltaBuilderAny} the coalesced child layout map */
+    cmap: delta.DeltaBuilderAny;
+    /** @type {Map<string|number, ConformTransformer>} nested conforms for delta-valued attributes */
+    transformAttrs: Map<string | number, ConformTransformer>;
+}
+export function conform<IN extends delta.DeltaConf, SchemaConf extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>, $schema: import("../../schema.js").Schema<delta.Delta<SchemaConf>>): Conform<SchemaConf, IN>;
+/**
+ * The expanded matcher for a children / attr-value schema.
+ */
+export type Allowed = {
+    byName: Map<string, delta.$Delta<any>>;
+    wild: delta.$Delta<any> | null;
+    passAny: boolean;
+    $scalar: import("../../schema.js").Schema<any>;
+};
+/**
+ * The read-only, schema-derived configuration of a conform transformer. Computed once per schema (see
+ * {@link configOf}) and shared by every transformer instance built from that schema — many instances are
+ * created for the children of one schema, so this avoids re-expanding the schema each time.
+ */
+export type Config = {
+    passthrough: boolean;
+    hasText: boolean;
+    childAllowed: Allowed;
+    attrsLoose: boolean;
+    attrAllowed: Map<string | number, Allowed>;
+};
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+import * as s from '../../schema.js';
+import { Transformer } from './core.js';
+//# sourceMappingURL=conform.d.ts.map

package/dist/delta/transformer/core.d.ts

@@ -0,0 +1,189 @@
+export function $tresult<A extends import("../delta.js").DeltaConf, B extends import("../delta.js").DeltaConf>($a: s.Schema<import("../delta.js").Delta<A>>, $b: s.Schema<import("../delta.js").Delta<B>>): s.Schema<TransformResult<A, B>>;
+export function createTransformResult<DeltaA extends import("../delta.js").DeltaBuilderAny = delta.DeltaBuilderAny, DeltaB extends import("../delta.js").DeltaBuilderAny = delta.DeltaBuilderAny>(a: DeltaA | null, b: DeltaB | null): TransformResult<any, any>;
+/**
+ * A stateful, schema-bound mapper between changes of side A and side B, materialized from a
+ * {@link Template} via `init()`.
+ *
+ * ## Deltas are manipulated in place
+ *
+ * `apply`/`applyA`/`applyB` **mutate their input deltas directly** — they rebase nodes and splice op
+ * lists in place, and some transformers `apply(other, { move: true })` the input into an accumulator —
+ * rather than editing only through the copy-on-write `apply`/`rebase` surface. This is a deliberate
+ * exception to the general rule (a delta is normally edited only via `apply`/`rebase`, which re-clone
+ * frozen content on first touch); it keeps the transform allocation-free, but it means a transformer is
+ * an *owning* consumer of the delta it is given. **Callers must pass a privately-owned, fully-mutable
+ * delta** — never a shared or `done` (frozen) one. A caller holding a shared read delta must
+ * {@link import('../delta.js').cloneDeep deep-clone} it first (this is exactly what a
+ * {@link import('../rdt.js').Binding} does before routing a change through its transformer).
+ *
+ * @template {import('../delta.js').DeltaConf} A
+ * @template {import('../delta.js').DeltaConf} B
+ */
+export class Transformer<A extends import("../delta.js").DeltaConf, B extends import("../delta.js").DeltaConf> {
+    /**
+     * @param {s.Schema<import('../delta.js').Delta<A>>} $in input delta schema
+     * @param {s.Schema<import('../delta.js').Delta<B>>} $out output delta schema (computed by the factory)
+     */
+    constructor($in: s.Schema<import("../delta.js").Delta<A>>, $out: s.Schema<import("../delta.js").Delta<B>>);
+    /**
+     * @type {s.Schema<import('../delta.js').Delta<A>>}
+     */
+    $in: s.Schema<import("../delta.js").Delta<A>>;
+    /**
+     * @type {s.Schema<import('../delta.js').Delta<B>>}
+     */
+    $out: s.Schema<import("../delta.js").Delta<B>>;
+    /**
+     * @param {TransformResult<A, B>} tin
+     * @return {TransformResult<A,B>}
+     */
+    apply(tin: TransformResult<A, B>): TransformResult<A, B>;
+    /**
+     * @param {import('../delta.js').DeltaBuilder<A>} t
+     * @return {TransformResult<A,B>}
+     */
+    applyA(t: import("../delta.js").DeltaBuilder<A>): TransformResult<A, B>;
+    /**
+     * @param {import('../delta.js').DeltaBuilder<B>} t
+     * @return {TransformResult<A,B>}
+     */
+    applyB(t: import("../delta.js").DeltaBuilder<B>): TransformResult<A, B>;
+    $type: s.Schema<Transformer<any, any>>;
+}
+/**
+ * Recognize a {@link Transformer} by its `$type` tag. Every value is either a `Transformer` or a
+ * {@link Template}, never both, so the two roles can each own a single prototype `$type`.
+ *
+ * @type {s.Schema<Transformer<any,any>>}
+ */
+export const $transformer: s.Schema<Transformer<any, any>>;
+export function transformerWith<A extends import("../delta.js").DeltaConf, B extends import("../delta.js").DeltaConf>(_a: s.Schema<import("../delta.js").Delta<A>> | A, _b: s.Schema<import("../delta.js").Delta<B>> | A): s.Schema<Transformer<A, B>>;
+/**
+ * A function from an input delta schema to a {@link Template} — the schema-deferred form of a
+ * transformer factory. Used for `pipe` stages, recursive composition, and `bind`.
+ *
+ * @template {import('../delta.js').DeltaConf} In
+ * @template {import('../delta.js').DeltaConf} Out
+ * @typedef {($in: s.Schema<import('../delta.js').Delta<In>>) => Template<In, Out>} TemplateFactory
+ */
+/**
+ * Force a factory's computed output conf to display fully-resolved (flatten `Omit<…> & {…}` / bare
+ * alias artifacts) while staying a valid `DeltaConf` for use as a `Transformer`/`Delta` type
+ * argument — conf-aware and depth-limited (nested `Delta<…>` stay intact). Implemented as an
+ * overwrite-with-nothing, reusing {@link import('../delta.js').DeltaConfOverwrite}'s
+ * prettify+coerce recipe. Apply to every factory's `OUT` typedef whose result is not already
+ * produced by `DeltaConfOverwrite`.
+ *
+ * @template {import('../delta.js').DeltaConf} Conf
+ * @typedef {import('../delta.js').DeltaConfOverwrite<Conf, {}>} ResolveOut
+ */
+/**
+ * The reusable, schema-bound form of a transformer: built by a factory (`attr($d, …)`), it holds the
+ * input/output delta schemas (`$in`/`$out`) and materializes a fresh stateful {@link Transformer} via
+ * the parameterless `init()`. Concrete templates `extend Template`.
+ *
+ * Templates are {@link fingerprintTrait.Fingerprintable}: this is what lets them be embedded as values
+ * (holes) in a `delta.create(...)` projection spec without collapsing the spec's type.
+ *
+ * @template {import('../delta.js').DeltaConf} [IN=any]
+ * @template {import('../delta.js').DeltaConf} [OUT=any]
+ */
+export class Template<IN extends import("../delta.js").DeltaConf = any, OUT extends import("../delta.js").DeltaConf = any> {
+    /**
+     * @param {s.Schema<import('../delta.js').Delta<IN>>} $in input delta schema
+     * @param {s.Schema<import('../delta.js').Delta<OUT>>} $out output delta schema (computed by the factory)
+     */
+    constructor($in: s.Schema<import("../delta.js").Delta<IN>>, $out: s.Schema<import("../delta.js").Delta<OUT>>);
+    /**
+     * @type {s.Schema<import('../delta.js').Delta<IN>>}
+     */
+    $in: s.Schema<import("../delta.js").Delta<IN>>;
+    /**
+     * @type {s.Schema<import('../delta.js').Delta<OUT>>}
+     */
+    $out: s.Schema<import("../delta.js").Delta<OUT>>;
+    /**
+     * Stable, mangle-safe identifier folded into this template's fingerprint. Subclasses with
+     * configuration override it so that e.g. `attr('a')` and `attr('b')` fingerprint differently
+     * (do NOT use `constructor.name` — class names do not survive mangling).
+     *
+     * @return {string}
+     */
+    get name(): string;
+    /**
+     * Instantiate a fresh stateful {@link Transformer} bound to this template's schema.
+     *
+     * @return {Transformer<IN, OUT>}
+     */
+    init(): Transformer<IN, OUT>;
+    $type: s.Schema<Template>;
+    /**
+     * @return {string}
+     */
+    [fingerprintTrait.FingerprintTraitSymbol](): string;
+}
+export function transform<IN extends import("../delta.js").DeltaConf, T extends Template<IN, any>>($d: s.Schema<import("../delta.js").Delta<IN>>, fn: ($d: s.Schema<import("../delta.js").Delta<IN>>) => T): T;
+export function withAttrs($in: s.Schema<import("../delta.js").DeltaAny>, newAttrsShape: {
+    [k: string | number]: s.Schema<any>;
+}): s.Schema<import("../delta.js").DeltaAny>;
+export function withName($in: s.Schema<import("../delta.js").DeltaAny>, name: string): s.Schema<import("../delta.js").DeltaAny>;
+export function attrsShapeOf($in: s.Schema<import("../delta.js").DeltaAny>): {
+    [k: string | number]: s.Schema<any>;
+} | null;
+/**
+ * Recognize a {@link Template} by its `$type` tag. Used to detect transformer "holes" embedded in a
+ * `project` spec.
+ *
+ * @type {s.Schema<Template>}
+ */
+export const $template: s.Schema<Template>;
+export type TransformResultAny = TransformResult<any, any>;
+/**
+ * A function from an input delta schema to a {@link Template} — the schema-deferred form of a
+ * transformer factory. Used for `pipe` stages, recursive composition, and `bind`.
+ */
+export type TemplateFactory<In extends import("../delta.js").DeltaConf, Out extends import("../delta.js").DeltaConf> = ($in: s.Schema<import("../delta.js").Delta<In>>) => Template<In, Out>;
+/**
+ * Force a factory's computed output conf to display fully-resolved (flatten `Omit<…> & {…}` / bare
+ * alias artifacts) while staying a valid `DeltaConf` for use as a `Transformer`/`Delta` type
+ * argument — conf-aware and depth-limited (nested `Delta<…>` stay intact). Implemented as an
+ * overwrite-with-nothing, reusing {@link import ('../delta.js').DeltaConfOverwrite}'s
+ * prettify+coerce recipe. Apply to every factory's `OUT` typedef whose result is not already
+ * produced by `DeltaConfOverwrite`.
+ */
+export type ResolveOut<Conf extends import("../delta.js").DeltaConf> = import("../delta.js").DeltaConfOverwrite<Conf, {}>;
+import * as s from '../../schema.js';
+/**
+ * @template {import('../delta.js').DeltaConf} [A={}]
+ * @template {import('../delta.js').DeltaConf} [B={}]
+ */
+declare class TransformResult<A extends import("../delta.js").DeltaConf = {}, B extends import("../delta.js").DeltaConf = {}> {
+    /**
+     * @param {import('../delta.js').DeltaBuilder<A>?} a
+     * @param {import('../delta.js').DeltaBuilder<B>?} b
+     */
+    constructor(a: import("../delta.js").DeltaBuilder<A> | null, b: import("../delta.js").DeltaBuilder<B> | null);
+    /**
+     * @type {import('../delta.js').DeltaBuilder<A>?}
+     */
+    a: import("../delta.js").DeltaBuilder<A> | null;
+    /**
+     * @type {import('../delta.js').DeltaBuilder<B>?}
+     */
+    b: import("../delta.js").DeltaBuilder<B> | null;
+    isEmpty(): boolean;
+    clear(): void;
+    /**
+     * @param {import('../delta.js').DeltaBuilder<A>?} a
+     */
+    applyA(a: import("../delta.js").DeltaBuilder<A> | null): this;
+    /**
+     * @param {import('../delta.js').DeltaBuilder<B>?} b
+     */
+    applyB(b: import("../delta.js").DeltaBuilder<B> | null): this;
+    reverse(): TransformResult<B, A>;
+}
+import * as delta from '../delta.js';
+import * as fingerprintTrait from '../../trait/fingerprint.js';
+export {};
+//# sourceMappingURL=core.d.ts.map

package/dist/delta/transformer/full-attributions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Stateful transformer holding the accumulated attribution overlay.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class FullAttributionsTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>);
+    /**
+     * Content-free overlay: the full accumulated attribution at every document position (instruction
+     * form). Mutated in place each change by `rebase` + `apply`.
+     *
+     * @type {delta.DeltaBuilderAny}
+     */
+    overlay: delta.DeltaBuilderAny;
+}
+/**
+ * Template for {@link FullAttributionsTransformer}. The transform touches only the `attribution`
+ * dimension (metadata, not part of the delta schema), so the output schema equals the input schema.
+ *
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, IN>}
+ */
+export class FullAttributions<IN extends delta.DeltaConf = any> extends Template<IN, IN> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>);
+}
+export function fullAttributions<IN extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>): FullAttributions<IN>;
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+//# sourceMappingURL=full-attributions.d.ts.map

package/dist/delta/transformer/id.d.ts

@@ -0,0 +1,2 @@
+export function id<IN extends import("../delta.js").DeltaConf>($d: import("../../schema.js").Schema<import("../delta.js").Delta<IN>>): import("./rename-attrs.js").RenameAttrs<{}, IN>;
+//# sourceMappingURL=id.d.ts.map

package/dist/delta/transformer/inline.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Stateful transformer that inlines child nodes whose name is in the configured `names` set. Side A
+ * is the structured representation (inline nodes present, e.g. `<p>some<>text</></p>`), side B is the
+ * inlined representation (inline nodes flattened, e.g. `<p>sometext</p>`).
+ *
+ * The state the user calls "offsets and inline node length" is the segment layout {@link Seg} stored
+ * in `segs`: a coalesced run-length view of the structured side where each inline node is one
+ * structured position expanding to `inlineLen` inlined positions, and every other position (root text
+ * and opaque non-inlined nodes) is a pass-through run. It is kept current incrementally - every mapped
+ * change is folded into `segs` by {@link applySegsChange} rather than re-derived from scratch.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class InlineTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     * @param {Array<string|null>} names the node names to inline (`null` selects anonymous nodes)
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, names: Array<string | null>);
+    /**
+     * @type {Array<string|null>}
+     */
+    names: Array<string | null>;
+    /**
+     * The segment layout of the structured side, maintained incrementally (see {@link applySegsChange}).
+     *
+     * @type {Array<Seg>}
+     */
+    segs: Array<Seg>;
+    /**
+     * Whether the structured side has ever contained a direct inline-node child. Monotonic: once a
+     * change introduces an inline node it stays set (even if that node is later deleted), which only
+     * costs a missed fast-path, never correctness.
+     *
+     * @type {boolean}
+     */
+    hasInline: boolean;
+}
+/**
+ * Template for {@link InlineTransformer}. Typed loosely: the inlined output shape depends on the
+ * runtime `names` and document content, so the OUT side is `any`.
+ *
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, any>}
+ */
+export class Inline<IN extends delta.DeltaConf = any> extends Template<IN, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     * @param {Array<string|null>} names the node names to inline (`null` selects anonymous nodes)
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, names: Array<string | null>);
+    names: (string | null)[];
+}
+export function inline<IN extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>, names: Array<string | null>): Inline<IN>;
+export function inlineNullNodes<IN extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>): Inline<IN>;
+/**
+ * The (unexported) delta {@link import ('../delta.js').createMark Mark} type, referenced here for the
+ * local mark-bucketing annotations.
+ */
+export type Mark = ReturnType<typeof delta.createMark>;
+import { Transformer } from './core.js';
+/**
+ * The (unexported) delta {@link import('../delta.js').createMark Mark} type, referenced here for the
+ * local mark-bucketing annotations.
+ *
+ * @typedef {ReturnType<typeof delta.createMark>} Mark
+ */
+/**
+ * One entry of the segment layout maintained by {@link InlineTransformer}. A segment is either a
+ * coalesced run of pass-through positions (root text + opaque non-inlined nodes - same length in both
+ * coordinate spaces) or a single inline node (1 structured position that expands to `inlineLen`
+ * inlined positions).
+ */
+declare class Seg {
+    /**
+     * @param {boolean} isInline whether this seg is an inline node (its children are spliced into the parent)
+     * @param {number} structLen
+     * @param {number} inlineLen
+     */
+    constructor(isInline: boolean, structLen: number, inlineLen: number);
+    isInline: boolean;
+    structLen: number;
+    inlineLen: number;
+}
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+export {};
+//# sourceMappingURL=inline.d.ts.map

package/dist/delta/transformer/pipe.d.ts

@@ -0,0 +1,182 @@
+/**
+ * The composite template produced by {@link pipe}: holds the threaded stage templates; `init()`
+ * materializes each into a {@link PipeTransformer}.
+ *
+ * @template {DeltaConf} [IN=any]
+ * @template {DeltaConf} [OUT=any]
+ * @extends {Template<IN, OUT>}
+ */
+export class Pipe<IN extends DeltaConf = any, OUT extends DeltaConf = any> extends Template<IN, OUT> {
+    /**
+     * @param {DSchema<IN>} $in
+     * @param {DSchema<OUT>} $out
+     * @param {Template<any,any>[]} stages the threaded stage templates (A→B order)
+     */
+    constructor($in: DSchema<IN>, $out: DSchema<OUT>, stages: Template<any, any>[]);
+    stages: Template<any, any>[];
+}
+/**
+ * @extends {Transformer<any,any>}
+ */
+export class PipeTransformer extends Transformer<any, any> {
+    /**
+     * @param {DSchema<any>} $in
+     * @param {DSchema<any>} $out
+     * @param {Transformer<any,any>[]} ts the per-stage transformers (materialized, A→B order)
+     */
+    constructor($in: DSchema<any>, $out: DSchema<any>, ts: Transformer<any, any>[]);
+    /**
+     * @type {Transformer<any,any>[]}
+     */
+    ts: Transformer<any, any>[];
+}
+/**
+ * Chain transformers, threading the input schema left→right so each stage is typed against the
+ * previous stage's output. `pipe($d, $d1 => …, $d2 => …)` infers the end-to-end output type
+ * automatically; each stage is a `($schema) => Template` factory. Returns a reusable {@link Pipe}
+ * template — call `.init()` for the transformer.
+ *
+ * Order is directional: an `applyA` change flows through the stages **left→right** (the leftmost maps
+ * the A-side first), an `applyB` change flows **right→left**. So list stages in A→B order — e.g.
+ * `pipe($d, $d1 => children($d1, …), $d2 => rename($d2, 'ul'))` maps an A-side change with `children`
+ * then `rename`. Reversing the order silently produces wrong results (there is no init-time check).
+ *
+ * The overloads cover up to a fixed arity; longer typed pipes nest
+ * (`pipe($d, …, $dk => pipe($dk, …more))`).
+ *
+ * @template {DeltaConf} In
+ * @template {DeltaConf} O1
+ * @overload
+ * @param {DSchema<In>} $in
+ * @param {(d: DSchema<In>) => Template<In, O1>} f1
+ * @returns {Pipe<In, O1>}
+ */
+export function pipe<In extends DeltaConf, O1 extends DeltaConf>($in: DSchema<In>, f1: (d: DSchema<In>) => Template<In, O1>): Pipe<In, O1>;
+/**
+ * @template {DeltaConf} In
+ * @template {DeltaConf} O1
+ * @template {DeltaConf} O2
+ * @overload
+ * @param {DSchema<In>} $in
+ * @param {(d: DSchema<In>) => Template<In, O1>} f1
+ * @param {(d: DSchema<O1>) => Template<O1, O2>} f2
+ * @returns {Pipe<In, O2>}
+ */
+export function pipe<In extends DeltaConf, O1 extends DeltaConf, O2 extends DeltaConf>($in: DSchema<In>, f1: (d: DSchema<In>) => Template<In, O1>, f2: (d: DSchema<O1>) => Template<O1, O2>): Pipe<In, O2>;
+/**
+ * @template {DeltaConf} In
+ * @template {DeltaConf} O1
+ * @template {DeltaConf} O2
+ * @template {DeltaConf} O3
+ * @overload
+ * @param {DSchema<In>} $in
+ * @param {(d: DSchema<In>) => Template<In, O1>} f1
+ * @param {(d: DSchema<O1>) => Template<O1, O2>} f2
+ * @param {(d: DSchema<O2>) => Template<O2, O3>} f3
+ * @returns {Pipe<In, O3>}
+ */
+export function pipe<In extends DeltaConf, O1 extends DeltaConf, O2 extends DeltaConf, O3 extends DeltaConf>($in: DSchema<In>, f1: (d: DSchema<In>) => Template<In, O1>, f2: (d: DSchema<O1>) => Template<O1, O2>, f3: (d: DSchema<O2>) => Template<O2, O3>): Pipe<In, O3>;
+/**
+ * @template {DeltaConf} In
+ * @template {DeltaConf} O1
+ * @template {DeltaConf} O2
+ * @template {DeltaConf} O3
+ * @template {DeltaConf} O4
+ * @overload
+ * @param {DSchema<In>} $in
+ * @param {(d: DSchema<In>) => Template<In, O1>} f1
+ * @param {(d: DSchema<O1>) => Template<O1, O2>} f2
+ * @param {(d: DSchema<O2>) => Template<O2, O3>} f3
+ * @param {(d: DSchema<O3>) => Template<O3, O4>} f4
+ * @returns {Pipe<In, O4>}
+ */
+export function pipe<In extends DeltaConf, O1 extends DeltaConf, O2 extends DeltaConf, O3 extends DeltaConf, O4 extends DeltaConf>($in: DSchema<In>, f1: (d: DSchema<In>) => Template<In, O1>, f2: (d: DSchema<O1>) => Template<O1, O2>, f3: (d: DSchema<O2>) => Template<O2, O3>, f4: (d: DSchema<O3>) => Template<O3, O4>): Pipe<In, O4>;
+/**
+ * @template {DeltaConf} In
+ * @template {DeltaConf} O1
+ * @template {DeltaConf} O2
+ * @template {DeltaConf} O3
+ * @template {DeltaConf} O4
+ * @template {DeltaConf} O5
+ * @overload
+ * @param {DSchema<In>} $in
+ * @param {(d: DSchema<In>) => Template<In, O1>} f1
+ * @param {(d: DSchema<O1>) => Template<O1, O2>} f2
+ * @param {(d: DSchema<O2>) => Template<O2, O3>} f3
+ * @param {(d: DSchema<O3>) => Template<O3, O4>} f4
+ * @param {(d: DSchema<O4>) => Template<O4, O5>} f5
+ * @returns {Pipe<In, O5>}
+ */
+export function pipe<In extends DeltaConf, O1 extends DeltaConf, O2 extends DeltaConf, O3 extends DeltaConf, O4 extends DeltaConf, O5 extends DeltaConf>($in: DSchema<In>, f1: (d: DSchema<In>) => Template<In, O1>, f2: (d: DSchema<O1>) => Template<O1, O2>, f3: (d: DSchema<O2>) => Template<O2, O3>, f4: (d: DSchema<O3>) => Template<O3, O4>, f5: (d: DSchema<O4>) => Template<O4, O5>): Pipe<In, O5>;
+/**
+ * @template {DeltaConf} In
+ * @template {DeltaConf} O1
+ * @template {DeltaConf} O2
+ * @template {DeltaConf} O3
+ * @template {DeltaConf} O4
+ * @template {DeltaConf} O5
+ * @template {DeltaConf} O6
+ * @overload
+ * @param {DSchema<In>} $in
+ * @param {(d: DSchema<In>) => Template<In, O1>} f1
+ * @param {(d: DSchema<O1>) => Template<O1, O2>} f2
+ * @param {(d: DSchema<O2>) => Template<O2, O3>} f3
+ * @param {(d: DSchema<O3>) => Template<O3, O4>} f4
+ * @param {(d: DSchema<O4>) => Template<O4, O5>} f5
+ * @param {(d: DSchema<O5>) => Template<O5, O6>} f6
+ * @returns {Pipe<In, O6>}
+ */
+export function pipe<In extends DeltaConf, O1 extends DeltaConf, O2 extends DeltaConf, O3 extends DeltaConf, O4 extends DeltaConf, O5 extends DeltaConf, O6 extends DeltaConf>($in: DSchema<In>, f1: (d: DSchema<In>) => Template<In, O1>, f2: (d: DSchema<O1>) => Template<O1, O2>, f3: (d: DSchema<O2>) => Template<O2, O3>, f4: (d: DSchema<O3>) => Template<O3, O4>, f5: (d: DSchema<O4>) => Template<O4, O5>, f6: (d: DSchema<O5>) => Template<O5, O6>): Pipe<In, O6>;
+/**
+ * @template {DeltaConf} In
+ * @template {DeltaConf} O1
+ * @template {DeltaConf} O2
+ * @template {DeltaConf} O3
+ * @template {DeltaConf} O4
+ * @template {DeltaConf} O5
+ * @template {DeltaConf} O6
+ * @template {DeltaConf} O7
+ * @overload
+ * @param {DSchema<In>} $in
+ * @param {(d: DSchema<In>) => Template<In, O1>} f1
+ * @param {(d: DSchema<O1>) => Template<O1, O2>} f2
+ * @param {(d: DSchema<O2>) => Template<O2, O3>} f3
+ * @param {(d: DSchema<O3>) => Template<O3, O4>} f4
+ * @param {(d: DSchema<O4>) => Template<O4, O5>} f5
+ * @param {(d: DSchema<O5>) => Template<O5, O6>} f6
+ * @param {(d: DSchema<O6>) => Template<O6, O7>} f7
+ * @returns {Pipe<In, O7>}
+ */
+export function pipe<In extends DeltaConf, O1 extends DeltaConf, O2 extends DeltaConf, O3 extends DeltaConf, O4 extends DeltaConf, O5 extends DeltaConf, O6 extends DeltaConf, O7 extends DeltaConf>($in: DSchema<In>, f1: (d: DSchema<In>) => Template<In, O1>, f2: (d: DSchema<O1>) => Template<O1, O2>, f3: (d: DSchema<O2>) => Template<O2, O3>, f4: (d: DSchema<O3>) => Template<O3, O4>, f5: (d: DSchema<O4>) => Template<O4, O5>, f6: (d: DSchema<O5>) => Template<O5, O6>, f7: (d: DSchema<O6>) => Template<O6, O7>): Pipe<In, O7>;
+/**
+ * @template {DeltaConf} In
+ * @template {DeltaConf} O1
+ * @template {DeltaConf} O2
+ * @template {DeltaConf} O3
+ * @template {DeltaConf} O4
+ * @template {DeltaConf} O5
+ * @template {DeltaConf} O6
+ * @template {DeltaConf} O7
+ * @template {DeltaConf} O8
+ * @overload
+ * @param {DSchema<In>} $in
+ * @param {(d: DSchema<In>) => Template<In, O1>} f1
+ * @param {(d: DSchema<O1>) => Template<O1, O2>} f2
+ * @param {(d: DSchema<O2>) => Template<O2, O3>} f3
+ * @param {(d: DSchema<O3>) => Template<O3, O4>} f4
+ * @param {(d: DSchema<O4>) => Template<O4, O5>} f5
+ * @param {(d: DSchema<O5>) => Template<O5, O6>} f6
+ * @param {(d: DSchema<O6>) => Template<O6, O7>} f7
+ * @param {(d: DSchema<O7>) => Template<O7, O8>} f8
+ * @returns {Pipe<In, O8>}
+ */
+export function pipe<In extends DeltaConf, O1 extends DeltaConf, O2 extends DeltaConf, O3 extends DeltaConf, O4 extends DeltaConf, O5 extends DeltaConf, O6 extends DeltaConf, O7 extends DeltaConf, O8 extends DeltaConf>($in: DSchema<In>, f1: (d: DSchema<In>) => Template<In, O1>, f2: (d: DSchema<O1>) => Template<O1, O2>, f3: (d: DSchema<O2>) => Template<O2, O3>, f4: (d: DSchema<O3>) => Template<O3, O4>, f5: (d: DSchema<O4>) => Template<O4, O5>, f6: (d: DSchema<O5>) => Template<O5, O6>, f7: (d: DSchema<O6>) => Template<O6, O7>, f8: (d: DSchema<O7>) => Template<O7, O8>): Pipe<In, O8>;
+export type DeltaConf = import("../delta.js").DeltaConf;
+/**
+ * A delta schema for a given conf — `Schema<Delta<C>>`. Local alias to keep the overload signatures
+ * readable; defined via inline `import()` so no value import is needed.
+ */
+export type DSchema<C extends DeltaConf> = import("../../schema.js").Schema<import("../delta.js").Delta<C>>;
+import { Template } from './core.js';
+import { Transformer } from './core.js';
+//# sourceMappingURL=pipe.d.ts.map