edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/text/index/state.d.ts

@@ -5,10 +5,9 @@
  * indexes, the counters and flags) are read through `ix` at every use.
  * What one part alone keeps stays in that part.
  */
-import type { EngineApi, EngineDoc, EngineTransaction } from '../../engine-api.js';
+import type { EngineDoc, EngineTransaction } from '../../engine-api.js';
 import { type BlockId, type BlockRec, type ChildSlot, type ResolvedPlacement } from '../../placement/model.js';
 import type { IdSetLike } from '../../structs.js';
-import type { TextEngine } from '../model.js';
 import type { LiveRow, RowItem } from '../rows.js';
 import type { ContentRun, DisplayRoles, Folded } from '../runs.js';
 import type { Cached } from './shared.js';
@@ -76,36 +75,7 @@ export type SelfChecks = {
     checkPublished: (pub: Published) => void;
 };
 /** Build the empty state of `doc`'s index. */
-export declare const indexState: (Y: EngineApi, T: TextEngine, doc: EngineDoc) => {
-    Y: Pick<typeof import("../../vendor/yjs/dts/index.js"), import("../../engine.js").EngineSymbol>;
-    T: {
-        newNode: (name: string) => import("../../engine-api.js").EngineNode;
-        resolveAnchor: (doc: EngineDoc, text: import("../../engine-api.js").EngineNode, anchor: import("../model.js").Anchor) => number | null;
-        anchorAt: (text: import("../../engine-api.js").EngineNode, index: number, assoc: number) => import("../model.js").Anchor;
-        openRangeCursor: (text: import("../../engine-api.js").EngineNode) => import("../model.js").RangeCursor;
-        itemsOfRange: (text: import("../../engine-api.js").EngineNode, i0: number, i1: number) => import("../model.js").RangeItem[];
-        readSegs: (segs: readonly import("../model.js").Seg[], stats?: import("../model.js").RangeReadStats) => import("../model.js").RangeItem[];
-        computeOwnership: (doc: EngineDoc, given: ReadonlyMap<import("../model.js").BlockId, import("../model.js").TextBlockRec>) => import("../model.js").Ownership;
-        flatten: (b: import("../model.js").BlockId, blocks: unknown, own: import("../model.js").Ownership) => import("../model.js").Seg[];
-        ownedLength: (segs: readonly import("../model.js").Seg[]) => number;
-        contentItemsOf: (b: import("../model.js").BlockId, blocks: unknown, own: import("../model.js").Ownership) => import("../model.js").RangeItem[];
-        blockTextOf: (b: import("../model.js").BlockId, blocks: unknown, own: import("../model.js").Ownership) => string;
-        insertIntoText: (doc: EngineDoc, blocks: unknown, own: import("../model.js").Ownership, b: import("../model.js").BlockId, offset: number, payload: string | import("../../engine-api.js").EngineNode, marks?: Record<string, unknown>) => void;
-        deleteRange: (doc: EngineDoc, blocks: unknown, own: import("../model.js").Ownership, b: import("../model.js").BlockId, offset: number, length: number) => void;
-        formatRangeIn: (doc: EngineDoc, blocks: unknown, own: import("../model.js").Ownership, b: import("../model.js").BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
-        purgeStreams: (streams: readonly import("../model.js").Stream[]) => void;
-        findAtom: (own: import("../model.js").Ownership, b: import("../model.js").BlockId, inlineId: string) => {
-            text: import("../../engine-api.js").EngineNode;
-            at: number;
-            node: import("../../engine-api.js").EngineNode;
-        } | null;
-        splitAt: (blocks: ReadonlyMap<import("../model.js").BlockId, import("../model.js").TextBlockRec>, own: import("../model.js").Ownership, b: import("../model.js").BlockId, offset: number, newId: import("../model.js").BlockId, n: number) => import("../model.js").MergeClaim[];
-        claimInto: (blocks: ReadonlyMap<import("../model.js").BlockId, import("../model.js").TextBlockRec>, own: Pick<import("../model.js").Ownership, "streamOf">, from: import("../model.js").BlockId, into: import("../model.js").BlockId) => void;
-        ownText: (doc: EngineDoc, rec: import("../model.js").TextBlockRec) => {
-            from: unknown;
-            to: number;
-        };
-    };
+export declare const indexState: (doc: EngineDoc) => {
     doc: EngineDoc;
     registry: import("../../engine-api.js").EngineNode;
     /** The document's own data (`crdt/data.ts`): outside the registry, reported apart. */
@@ -217,7 +187,7 @@ export declare const indexState: (Y: EngineApi, T: TextEngine, doc: EngineDoc) =
     frames: Set<Folded>;
     candidates: Set<string>;
     reporting: boolean;
-    /** The self-checks, once built (`checks.ts`). */
+    /** The self-checks, once built (`checksOf`). */
     checks: SelfChecks | null;
 };
 export type IndexState = ReturnType<typeof indexState>;

package/dist/crdt/text/index/state.js

@@ -1,13 +1,11 @@
 import { REGISTRY_KEY } from '../../placement/model.js';
 import { DOC_DATA_ROOT } from '../../schema.js';
 /** Build the empty state of `doc`'s index. */
-export const indexState = (Y, T, doc) => {
+export const indexState = (doc) => {
     // The children index starts as the one without the layout rules (no layout yet).
     const kids0 = new Map();
     const slots0 = new Map();
     return {
-        Y,
-        T,
         doc,
         registry: doc.get(REGISTRY_KEY),
         /** The document's own data (`crdt/data.ts`): outside the registry, reported apart. */
@@ -114,7 +112,7 @@ export const indexState = (Y, T, doc) => {
         frames: new Set(),
         candidates: new Set(),
         reporting: false,
-        /** The self-checks, once built (`checks.ts`). */
+        /** The self-checks, once built (`checksOf`). */
         checks: null
     };
 };

package/dist/crdt/text/model.d.ts

@@ -29,7 +29,10 @@
  *
  * The item guards are `text/items.ts`, the range reads `text/ranges.ts` and
  * the stream table `text/streams.ts` (re-exported here); this module declares
- * the text model's types and binds its reads and writes to an engine.
+ * the text model's types and its reads and writes, each a function edytor's
+ * modules import (the public binding's `text` lists them, `bindText`). The
+ * from-scratch ownership (`computeOwnership`) is the oracle the index is
+ * checked against: only the public binding and the tests reach it.
  */
 import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
 import { type IdSetOf } from '../structs.js';
@@ -239,7 +242,84 @@ export type Ownership = {
     /** `b`'s effective claims (`merge.claim.anchor`), when the context computed them. */
     claimsOf?: (b: BlockId) => readonly Claim[];
 };
-export declare const bindText: (Y: EngineApi) => {
+/** Construct a detached v14 node, viewed through the structural interface. */
+export declare const newNode: (name: string) => EngineNode;
+/** Anchor → live index in `text`, or `null` when its item is not integrated here. */
+export declare const resolveAnchor: (doc: EngineDoc, text: EngineNode, anchor: Anchor) => number | null;
+/**
+ * Live index → anchor bound on the `assoc` side: `assoc < 0` binds the unit
+ * before `index` (an insert at `index` lands right of it; `i: null` at the
+ * text start), `assoc >= 0` the unit at `index` (`i: null` at the text end).
+ */
+export declare const anchorAt: (text: EngineNode, index: number, assoc: number) => Anchor;
+/** A bounded read cursor on `text` (live-content space). */
+export declare const openRangeCursor: (text: EngineNode) => RangeCursor;
+export declare const itemsOfRange: (text: EngineNode, i0: number, i1: number) => RangeItem[];
+/** The items of `segs`, one cursor per backing text. */
+export declare const readSegs: (segs: readonly Seg[], stats?: RangeReadStats) => RangeItem[];
+export declare const computeOwnership: (doc: EngineDoc, given: ReadonlyMap<BlockId, TextBlockRec>) => Ownership;
+/** `b`'s display pieces (`[]` when hidden or streamless and claimless). */
+export declare const flatten: (b: BlockId, blocks: unknown, own: Ownership) => Seg[];
+export declare const contentItemsOf: (b: BlockId, blocks: unknown, own: Ownership) => RangeItem[];
+export declare const blockTextOf: (b: BlockId, blocks: unknown, own: Ownership) => string;
+/**
+ * Insert at a display offset, beside the boundary the engine walk and the
+ * left side choose. The display must be non-empty: a streamless block gets
+ * its own text first ({@link ownText}). The content goes in its gap
+ * (`insertInGap`, fork patch YP13: after the marks attached to the text before it,
+ * before those attached to the text after it); text then shows exactly
+ * `marks` (an operation for each mark its gap gave it otherwise).
+ */
+export declare const insertIntoText: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, payload: string | EngineNode, marks?: Record<string, unknown>) => void;
+/** The per-stream delete: each range lies inside one stream's pieces, so no boundary is ever removed. */
+export declare const deleteRange: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, length: number) => void;
+export declare const formatRangeIn: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
+/**
+ * Delete the content of streams `streams` (the room's purge of a
+ * block deleted past the horizon): every piece, so no boundary goes and
+ * each stream still delimits, writing no delete mark.
+ * Streams of one text are deleted from its end, so the indices the
+ * caller read stay valid.
+ */
+export declare const purgeStreams: (streams: readonly Stream[]) => void;
+/** The inline atom `inlineId` in `b`'s display: its text, engine index and node. */
+export declare const findAtom: (own: Ownership, b: BlockId, inlineId: string) => {
+    text: EngineNode;
+    at: number;
+    node: EngineNode;
+} | null;
+/**
+ * Split `b`'s display at `offset` for the new block `newId` (incarnation
+ * `n`): one boundary through fork patch YP7 at the end of the gap, and the claims that
+ * follow the split point — every claim of the stream's own block, then each
+ * holder's claims after the one that led down — returned for re-insertion
+ * on the new block and deleted from their holders. No text is copied.
+ */
+export declare const splitAt: (blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Ownership, b: BlockId, offset: number, newId: BlockId, n: number) => MergeClaim[];
+/**
+ * Append a merge claim `{m: from}` to `into`'s claims list, anchored to
+ * the end of `into`'s stream (`merge.claim.anchor`): its last unit (its
+ * opening boundary when empty; none at an own text's start) and the item
+ * after it.
+ */
+export declare const claimInto: (blocks: ReadonlyMap<BlockId, TextBlockRec>, own: Pick<Ownership, "streamOf">, from: BlockId, into: BlockId) => void;
+/**
+ * Give streamless block `rec` its own text and re-mint its nonce, so a late
+ * copy of its old boundary is inert. Both writes carry a writer id
+ * derived from the block's node and its dead incarnation, so replicas that
+ * type into the block concurrently write the SAME items and both typings
+ * land in one text (the seed writer's mechanism). Returns the nonce
+ * change (the caller moves the block's attribution record with it).
+ */
+export declare const ownText: (doc: EngineDoc, rec: TextBlockRec) => {
+    from: unknown;
+    to: number;
+};
+/**
+ * The text engine as one object (the public binding's `text`): the reads
+ * and writes above. Edytor's own modules import them directly.
+ */
+export declare const bindText: (_Y: EngineApi) => {
     newNode: (name: string) => EngineNode;
     resolveAnchor: (doc: EngineDoc, text: EngineNode, anchor: Anchor) => number | null;
     anchorAt: (text: EngineNode, index: number, assoc: number) => Anchor;