accordsync-core 0.3.0__py3-none-any.whl

accordsync_core/__init__.py

@@ -0,0 +1,90 @@
+"""Accord's merge core: hybrid logical clocks, operations and the four merge strategies."""
+
+from .canonical import canonical_json
+from .errors import AccordError, ClockSkewError
+from .hlc import MAX_COUNTER, MAX_SAFE_INTEGER, Hlc, assert_node, compare_hlc
+from .op import (
+    AddOp,
+    AssignOp,
+    IncOp,
+    JsonValue,
+    Op,
+    OpId,
+    OpKind,
+    ParsedOpId,
+    RemoveOp,
+    SetElement,
+    compare_op_ids,
+    parse_op_id,
+    record_type,
+)
+from .replica import ApplyResult, FieldRef, RecordSnapshot, Replica
+from .schema import (
+    KINDS,
+    RecordFields,
+    Schema,
+    Strategy,
+    StrategyName,
+    conflict,
+    counter,
+    define_schema,
+    fields_of,
+    lww,
+    set_,
+    strategy_for,
+)
+from .strategies import ABSENT, FieldSnapshot
+from .wire import WireOp, decode_op, encode_op
+from .writer import DEFAULT_MAX_SKEW_MS, LocalWriter
+
+PROTOCOL_VERSION = 1
+"""The Accord sync protocol this package speaks (docs/protocol.md in the Accord repository).
+A breaking change to the wire format bumps it."""
+
+__all__ = [
+    "ABSENT",
+    "DEFAULT_MAX_SKEW_MS",
+    "KINDS",
+    "MAX_COUNTER",
+    "MAX_SAFE_INTEGER",
+    "PROTOCOL_VERSION",
+    "AccordError",
+    "AddOp",
+    "ApplyResult",
+    "AssignOp",
+    "ClockSkewError",
+    "FieldRef",
+    "FieldSnapshot",
+    "Hlc",
+    "IncOp",
+    "JsonValue",
+    "LocalWriter",
+    "Op",
+    "OpId",
+    "OpKind",
+    "ParsedOpId",
+    "RecordFields",
+    "RecordSnapshot",
+    "RemoveOp",
+    "Replica",
+    "Schema",
+    "SetElement",
+    "Strategy",
+    "StrategyName",
+    "WireOp",
+    "assert_node",
+    "canonical_json",
+    "compare_hlc",
+    "compare_op_ids",
+    "conflict",
+    "counter",
+    "decode_op",
+    "define_schema",
+    "encode_op",
+    "fields_of",
+    "lww",
+    "parse_op_id",
+    "record_type",
+    "set_",
+    "strategy_for",
+]

accordsync_core/_text.py

@@ -0,0 +1,15 @@
+"""String helpers that make Python strings behave like JavaScript's UTF-16 strings."""
+
+
+def utf16_key(s: str) -> bytes:
+    """Sort key giving JavaScript's `a < b` order: by UTF-16 code unit, not by code point.
+
+    The two differ for characters above U+FFFF (surrogate pairs, 0xD800...) against U+E000-U+FFFF.
+    `surrogatepass` keeps lone surrogates, which JSON may carry and JavaScript strings may hold.
+    """
+    return s.encode("utf-16-be", "surrogatepass")
+
+
+def utf16_len(s: str) -> int:
+    """`s.length` in JavaScript: the number of UTF-16 code units."""
+    return len(utf16_key(s)) // 2

accordsync_core/canonical.py

@@ -0,0 +1,122 @@
+"""Canonical JSON, byte for byte what the TypeScript core's `canonicalJson` prints.
+
+That is `JSON.stringify` of objects built from code-unit-sorted keys, so this reproduces
+JavaScript rather than Python's `json` module:
+- keys that are array indices ("0".."4294967294", no leading zeros) come first in numeric order,
+  because JavaScript objects always order them that way; the others follow by UTF-16 code unit;
+- numbers print as JavaScript prints them: `1` not `1.0`, `0` for `-0.0`, `1e-7`, `1e+21`;
+- strings escape exactly like `JSON.stringify` (lone surrogates as `\\udXXX`, the rest raw).
+"""
+
+import math
+import re
+from collections.abc import Iterable, Mapping
+from decimal import Decimal
+
+from ._text import utf16_key
+
+MAX_ARRAY_INDEX = 4294967294
+_ARRAY_INDEX = re.compile(r"0|[1-9][0-9]*")
+_SHORT_ESCAPES = {'"': '\\"', "\\": "\\\\", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r"}
+_SHORT_ESCAPES["\t"] = "\\t"
+
+
+def canonical_json(value: object) -> str:
+    out: list[str] = []
+    _write(out, value)
+    return "".join(out)
+
+
+def _write(out: list[str], value: object) -> None:
+    # `bool` first: it is a subclass of `int`.
+    if value is None:
+        out.append("null")
+    elif type(value) is bool:
+        out.append("true" if value else "false")
+    elif isinstance(value, int | float):
+        out.append(js_number(value))
+    elif isinstance(value, str):
+        out.append(js_string(value))
+    elif isinstance(value, list | tuple):
+        out.append("[")
+        for i, v in enumerate(value):
+            if i:
+                out.append(",")
+            _write(out, v)
+        out.append("]")
+    elif isinstance(value, Mapping):
+        out.append("{")
+        for i, k in enumerate(js_key_order(value.keys())):
+            if i:
+                out.append(",")
+            out.append(js_string(k))
+            out.append(":")
+            _write(out, value[k])
+        out.append("}")
+    else:
+        raise TypeError(f"canonical_json: not a JSON value: {type(value).__name__}")
+
+
+def js_key_order(keys: Iterable[object]) -> list[str]:
+    """The order JavaScript gives the keys of an object built from code-unit-sorted entries."""
+    indices: list[str] = []
+    others: list[str] = []
+    for k in keys:
+        if not isinstance(k, str):
+            raise TypeError(f"canonical_json: object keys must be strings, got {k!r}")
+        if _ARRAY_INDEX.fullmatch(k) and int(k) <= MAX_ARRAY_INDEX:
+            indices.append(k)
+        else:
+            others.append(k)
+    indices.sort(key=int)
+    others.sort(key=utf16_key)
+    return indices + others
+
+
+def js_number(n: int | float) -> str:
+    """A number as JavaScript's `String(n)` / `JSON.stringify` prints it."""
+    if isinstance(n, int):
+        # JavaScript numbers are doubles: an integer past 2^53 prints as the double it rounds to.
+        if abs(n) <= 2**53:
+            return str(n)
+        n = float(n)
+    if not math.isfinite(n):
+        return "null"
+    if n == 0:
+        return "0"  # also -0.0
+    sign = "-" if n < 0 else ""
+    # repr gives the shortest digits that round-trip, as JavaScript does; only the layout differs.
+    # The value is 0.DIGITS x 10^point (the k digits and n of ECMAScript's Number::toString).
+    t = Decimal(repr(abs(n))).normalize().as_tuple()
+    digits = "".join(map(str, t.digits))
+    point = len(digits) + int(t.exponent)
+    k = len(digits)
+    if k <= point <= 21:
+        return sign + digits + "0" * (point - k)
+    if 0 < point <= 21:
+        return sign + digits[:point] + "." + digits[point:]
+    if -6 < point <= 0:
+        return sign + "0." + "0" * -point + digits
+    e = point - 1
+    e_str = f"e+{e}" if e >= 0 else f"e-{-e}"
+    if k == 1:
+        return sign + digits + e_str
+    return sign + digits[0] + "." + digits[1:] + e_str
+
+
+def js_string(s: str) -> str:
+    """A string as `JSON.stringify` prints it."""
+    # Re-pair surrogates first: a high and a low surrogate side by side are one character to
+    # JavaScript, printed raw; only lone surrogates are escaped.
+    s = s.encode("utf-16-be", "surrogatepass").decode("utf-16-be", "surrogatepass")
+    out = ['"']
+    for ch in s:
+        c = ord(ch)
+        if ch in _SHORT_ESCAPES:
+            out.append(_SHORT_ESCAPES[ch])
+        elif c < 0x20 or 0xD800 <= c <= 0xDFFF:
+            out.append(f"\\u{c:04x}")
+        else:
+            out.append(ch)
+    out.append('"')
+    return "".join(out)

accordsync_core/errors.py

@@ -0,0 +1,9 @@
+"""Errors raised by the core."""
+
+
+class AccordError(ValueError):
+    """Invalid input: a malformed op, a write that does not fit the schema, a bad snapshot."""
+
+
+class ClockSkewError(AccordError):
+    """A remote clock too far ahead of this device's physical time."""

accordsync_core/hlc.py

@@ -0,0 +1,100 @@
+"""Hybrid logical clock: physical time + logical counter + node id.
+
+Orders events consistently even when device clocks are wrong, and `compare_hlc` is a total order:
+two distinct clocks never compare equal, because the node id breaks ties.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from ._text import utf16_key
+from .errors import AccordError, ClockSkewError
+
+MAX_COUNTER = 99_999
+MAX_SAFE_INTEGER = 2**53 - 1
+"""JavaScript's `Number.MAX_SAFE_INTEGER`: integers on the wire stay within +/- this."""
+
+# fullmatch and explicit [0-9]: Python's `$` accepts a trailing newline and `\d` any Unicode digit.
+_NODE = re.compile(r"[A-Za-z0-9_-]{1,64}")
+_ENCODED = re.compile(r"([0-9]{1,16}):([0-9]{5}):([A-Za-z0-9_-]{1,64})")
+
+
+@dataclass(frozen=True, slots=True)
+class Hlc:
+    wall: int
+    """Milliseconds since the Unix epoch, as seen by the node (maybe pushed forward by others)."""
+    counter: int
+    """Disambiguates events within the same `wall` millisecond."""
+    node: str
+    """The device or server that produced the clock."""
+
+    @staticmethod
+    def initial(node: str) -> Hlc:
+        assert_node(node)
+        return Hlc(0, 0, node)
+
+    def encode(self) -> str:
+        """`wall:counter:node`, with the counter zero-padded to 5 digits."""
+        return f"{self.wall}:{self.counter:05d}:{self.node}"
+
+    @staticmethod
+    def decode(s: str) -> Hlc:
+        m = _ENCODED.fullmatch(s)
+        if not m:
+            raise AccordError(f'malformed hlc "{s}"')
+        wall = int(m[1])
+        if wall > MAX_SAFE_INTEGER:
+            raise AccordError(f'hlc wall out of range in "{s}"')
+        return Hlc(wall, int(m[2]), m[3])
+
+    def compare(self, other: Hlc) -> int:
+        return compare_hlc(self, other)
+
+    def tick(self, now: int) -> Hlc:
+        """The clock for a new local event at physical time `now`."""
+        if now > self.wall:
+            return Hlc(now, 0, self.node)
+        return _after(self.wall, self.counter, self.node)
+
+    def receive(self, remote: Hlc, now: int, max_skew_ms: int) -> Hlc:
+        """The clock after observing `remote` at physical time `now`.
+
+        Refuses a remote clock more than `max_skew_ms` ahead of `now`, so one phone with a wrong
+        date cannot win every merge forever.
+        """
+        if remote.wall - now > max_skew_ms:
+            raise ClockSkewError(
+                f"clock of {remote.node} is {remote.wall - now} ms ahead (limit {max_skew_ms} ms)"
+            )
+        wall = max(self.wall, remote.wall, now)
+        if wall == self.wall and wall == remote.wall:
+            return _after(wall, max(self.counter, remote.counter), self.node)
+        if wall == self.wall:
+            return _after(wall, self.counter, self.node)
+        if wall == remote.wall:
+            return _after(wall, remote.counter, self.node)
+        return Hlc(wall, 0, self.node)
+
+
+def compare_hlc(a: Hlc, b: Hlc) -> int:
+    if a.wall != b.wall:
+        return -1 if a.wall < b.wall else 1
+    if a.counter != b.counter:
+        return -1 if a.counter < b.counter else 1
+    if a.node != b.node:
+        return -1 if utf16_key(a.node) < utf16_key(b.node) else 1
+    return 0
+
+
+def assert_node(node: str) -> None:
+    if not isinstance(node, str) or not _NODE.fullmatch(node):
+        raise AccordError(f'node id must match [A-Za-z0-9_-]{{1,64}}, got "{node}"')
+
+
+def _after(wall: int, counter: int, node: str) -> Hlc:
+    """The smallest clock after (wall, counter): a full counter rolls into the next millisecond."""
+    if counter >= MAX_COUNTER:
+        return Hlc(wall + 1, 0, node)
+    return Hlc(wall, counter + 1, node)

accordsync_core/op.py

@@ -0,0 +1,142 @@
+"""Operations: one change to one field of one record."""
+
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import dataclass
+from typing import ClassVar, Literal, TypeAlias
+
+from ._text import utf16_key, utf16_len
+from .errors import AccordError
+from .hlc import MAX_SAFE_INTEGER, Hlc
+
+JsonValue: TypeAlias = "bool | int | float | str | list[JsonValue] | dict[str, JsonValue] | None"
+"""Any JSON value. Field values must survive a JSON round trip."""
+
+SetElement: TypeAlias = str | int | float
+"""Set elements are compared by value, so they are limited to strings and finite numbers."""
+
+OpId: TypeAlias = str
+"""`deviceId:sequence`. Unique per op, so applying an op twice is a no-op."""
+
+OpKind: TypeAlias = Literal["assign", "inc", "add", "remove"]
+
+_OP_ID = re.compile(r"([A-Za-z0-9_-]{1,64}):([1-9][0-9]{0,15})")
+_RECORD_ID = re.compile(r"([A-Za-z][A-Za-z0-9_]{0,63}):(.+)", re.DOTALL)
+
+
+@dataclass(frozen=True, slots=True)
+class AssignOp:
+    """Writes a value. For `lww` the highest clock wins. For `conflict`, `deps` lists the values the
+    writer could see; the assign supersedes exactly those, so resolving a conflict is an assign
+    whose deps name every conflicting value (ADR-0003)."""
+
+    kind: ClassVar[Literal["assign"]] = "assign"
+    op_id: OpId
+    record: str
+    field: str
+    hlc: Hlc
+    value: JsonValue
+    deps: tuple[OpId, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class IncOp:
+    """Adds `by` (a positive or negative integer) to a counter."""
+
+    kind: ClassVar[Literal["inc"]] = "inc"
+    op_id: OpId
+    record: str
+    field: str
+    hlc: Hlc
+    by: int
+
+
+@dataclass(frozen=True, slots=True)
+class AddOp:
+    """Adds an element to a set. The op id is the element's unique tag. `deps` lists the element's
+    tags the writer could see: the add replaces them, so re-adding keeps the set's state small,
+    while a concurrent remove (which only cites the tags it saw) still loses."""
+
+    kind: ClassVar[Literal["add"]] = "add"
+    op_id: OpId
+    record: str
+    field: str
+    hlc: Hlc
+    element: SetElement
+    deps: tuple[OpId, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class RemoveOp:
+    """Removes the add-tags in `deps` (the ones the writer had seen); concurrent adds survive."""
+
+    kind: ClassVar[Literal["remove"]] = "remove"
+    op_id: OpId
+    record: str
+    field: str
+    hlc: Hlc
+    element: SetElement
+    deps: tuple[OpId, ...] = ()
+
+
+Op: TypeAlias = AssignOp | IncOp | AddOp | RemoveOp
+
+
+@dataclass(frozen=True, slots=True)
+class ParsedOpId:
+    device: str
+    seq: int
+
+
+def parse_op_id(op_id: str) -> ParsedOpId:
+    m = _OP_ID.fullmatch(op_id) if isinstance(op_id, str) else None
+    if not m:
+        raise AccordError(f'malformed op id "{op_id}" (expected device:sequence)')
+    return ParsedOpId(m[1], int(m[2]))
+
+
+def record_type(record: str) -> str:
+    """The type of a `type:id` record id (the id: 1 to 256 UTF-16 code units, as in JavaScript)."""
+    m = _RECORD_ID.fullmatch(record) if isinstance(record, str) else None
+    if not m or utf16_len(m[2]) > 256:
+        raise AccordError(f'malformed record id "{record}" (expected type:id)')
+    return m[1]
+
+
+def op_id_key(op_id: OpId) -> bytes:
+    """Sort key for op ids, used wherever output order must be deterministic (code-unit order)."""
+    return utf16_key(op_id)
+
+
+def compare_op_ids(a: OpId, b: OpId) -> int:
+    ka, kb = op_id_key(a), op_id_key(b)
+    return -1 if ka < kb else 1 if ka > kb else 0
+
+
+def is_number(x: object) -> bool:
+    """A JSON number: `int` or `float`, never `bool` (which is an `int` subclass in Python)."""
+    return type(x) is not bool and isinstance(x, int | float)
+
+
+def as_set_element(e: object) -> SetElement:
+    """Checks a set element: a string or a finite number. Booleans are refused, so `True` can never
+    be confused with `1`. An integer past 2^53 becomes the double JavaScript would read."""
+    if isinstance(e, str):
+        return e
+    if type(e) is int:
+        return e if abs(e) <= MAX_SAFE_INTEGER else float(e)
+    if type(e) is float and math.isfinite(e):
+        return e
+    raise AccordError("set elements must be a string or finite number")
+
+
+def as_increment(by: object) -> int:
+    """Checks a counter increment: a safe integer. A whole float (`3.0`, as some JSON decoders give)
+    is the same number to JavaScript and is accepted; `True` is not a number."""
+    if type(by) is float and math.isfinite(by) and by == int(by):
+        by = int(by)
+    if type(by) is not int or abs(by) > MAX_SAFE_INTEGER:
+        raise AccordError(f"counter increment must be a safe integer, got {by!r}")
+    return by

accordsync_core/replica.py

@@ -0,0 +1,196 @@
+"""An op log and the state projected from it."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from typing import Any, Literal, TypeAlias
+
+from ._text import utf16_key
+from .canonical import canonical_json
+from .errors import AccordError
+from .op import Op, OpId, SetElement, op_id_key, parse_op_id
+from .schema import KINDS, Schema, fields_of, strategy_for
+from .strategies import (
+    ABSENT,
+    ConflictState,
+    FieldSnapshot,
+    FieldState,
+    apply_op,
+    empty_state,
+    observed_deps,
+    read_state,
+    snapshot_state,
+    state_from_snapshot,
+)
+
+ApplyResult: TypeAlias = Literal["applied", "duplicate"]
+
+
+@dataclass(frozen=True, slots=True)
+class RecordSnapshot:
+    """A record's state with its history folded away (log compaction, ADR-0008)."""
+
+    record: str
+    fields: Mapping[str, FieldSnapshot]
+
+    def to_json(self) -> dict[str, Any]:
+        return {"record": self.record, "fields": dict(self.fields)}
+
+    @staticmethod
+    def from_json(data: Mapping[str, Any]) -> RecordSnapshot:
+        record, fields = data.get("record"), data.get("fields")
+        if not isinstance(record, str) or not isinstance(fields, Mapping):
+            raise AccordError("record snapshot needs a record and fields")
+        return RecordSnapshot(record, dict(fields))
+
+
+@dataclass(frozen=True, slots=True)
+class FieldRef:
+    record: str
+    field: str
+
+
+class Replica:
+    """An op log and the state projected from it. Pure: no I/O, no clock.
+
+    Two replicas holding the same set of ops always read the same state, whatever order the ops
+    arrived in.
+    """
+
+    def __init__(self, schema: Schema) -> None:
+        self._schema = schema
+        self._ops: dict[OpId, Op] = {}
+        self._records: dict[str, dict[str, FieldState]] = {}
+        # Snapshots this replica's state was started from, by record.
+        self._bases: dict[str, RecordSnapshot] = {}
+
+    @property
+    def schema(self) -> Schema:
+        return self._schema
+
+    def has(self, op_id: OpId) -> bool:
+        return op_id in self._ops
+
+    def __len__(self) -> int:
+        return len(self._ops)
+
+    @property
+    def size(self) -> int:
+        return len(self._ops)
+
+    def ops(self) -> list[Op]:
+        """All ops, in a deterministic order."""
+        return sorted(self._ops.values(), key=lambda o: op_id_key(o.op_id))
+
+    def validate(self, op: Op) -> None:
+        """Raises (without changing anything) if the op does not fit the schema."""
+        strategy = strategy_for(self._schema, op.record, op.field)
+        if op.kind not in KINDS[strategy]:
+            raise AccordError(
+                f'op kind "{op.kind}" does not apply to {op.field}, a {strategy} field'
+            )
+        if parse_op_id(op.op_id).device != op.hlc.node:
+            raise AccordError(f'op {op.op_id} carries a clock from "{op.hlc.node}"')
+
+    def apply(self, op: Op) -> ApplyResult:
+        if op.op_id in self._ops:
+            return "duplicate"
+        self.validate(op)
+        apply_op(self._state(op.record, op.field), op)
+        self._ops[op.op_id] = op
+        return "applied"
+
+    def read(self, record: str) -> dict[str, object] | None:
+        """The record's fields, or None if no op touched it. Fields never written are left out."""
+        states = self._records.get(record)
+        if states is None:
+            return None
+        out: dict[str, object] = {}
+        for name, s in fields_of(self._schema, record).items():
+            state = states.get(name)
+            value = read_state(state if state is not None else empty_state(s.strategy))
+            if value is not ABSENT:
+                out[name] = value
+        return out
+
+    def records(self) -> list[str]:
+        return sorted(self._records, key=utf16_key)
+
+    def conflicts(self) -> list[FieldRef]:
+        """Every `conflict()` field currently holding more than one value."""
+        out: list[FieldRef] = []
+        for record in self.records():
+            states = self._records[record]
+            for name in sorted(states, key=utf16_key):
+                state = states[name]
+                if isinstance(state, ConflictState) and len(state.live) > 1:
+                    out.append(FieldRef(record, name))
+        return out
+
+    def observed_deps(
+        self, record: str, field: str, element: SetElement | None = None
+    ) -> list[OpId]:
+        """Op ids a new write to this field must cite (see `AssignOp` and `RemoveOp`)."""
+        strategy_for(self._schema, record, field)
+        state = self._records.get(record, {}).get(field)
+        return observed_deps(state, element) if state is not None else []
+
+    def snapshot(self) -> str:
+        """The whole state as canonical JSON: equal strings mean converged replicas."""
+        return canonical_json({r: self.read(r) for r in self.records()})
+
+    def snapshot_record(self, record: str) -> RecordSnapshot:
+        """The record's current state, with its history folded away."""
+        states = self._records.get(record, {})
+        return RecordSnapshot(record, {f: snapshot_state(s) for f, s in states.items()})
+
+    def load_snapshot(self, snap: RecordSnapshot, keep: Iterable[OpId] = ()) -> None:
+        """Replaces a record's state with a snapshot and forgets that record's ops, except `keep`
+        (local ops not yet on the server), which are applied again on top."""
+        keep = set(keep)
+        fields: dict[str, FieldState] = {}
+        for name, fs in snap.fields.items():
+            strategy_for(self._schema, snap.record, name)
+            fields[name] = state_from_snapshot(fs)
+        # Everything checked: now change state.
+        reapply = [o for o in self._ops.values() if o.record == snap.record and o.op_id in keep]
+        self._ops = {k: o for k, o in self._ops.items() if o.record != snap.record}
+        self._records[snap.record] = fields
+        self._bases[snap.record] = snap
+        for op in reapply:
+            self.apply(op)
+
+    def without(self, drop: Iterable[OpId]) -> Replica:
+        """A copy without the given ops (same snapshots, every other op): used to roll back."""
+        drop = set(drop)
+        nxt = Replica(self._schema)
+        for snap in self._bases.values():
+            nxt.load_snapshot(snap)
+        for op in self.ops():
+            if op.op_id not in drop:
+                nxt.apply(op)
+        return nxt
+
+    def forget(self, record: str, keep: Iterable[OpId] = ()) -> Replica:
+        """Forgets a record entirely (it left this device's scope), except ops in `keep`."""
+        keep = set(keep)
+        nxt = Replica(self._schema)
+        for r, snap in self._bases.items():
+            if r != record:
+                nxt.load_snapshot(snap)
+        for op in self.ops():
+            if op.record != record or op.op_id in keep:
+                nxt.apply(op)
+        return nxt
+
+    def bases(self) -> list[RecordSnapshot]:
+        """Snapshots this replica was started from (to persist them alongside the ops)."""
+        return list(self._bases.values())
+
+    def _state(self, record: str, field: str) -> FieldState:
+        fields = self._records.setdefault(record, {})
+        state = fields.get(field)
+        if state is None:
+            state = fields[field] = empty_state(strategy_for(self._schema, record, field))
+        return state