Writing
both layers

put/3 and put/4

# EchoStore.Table — handle_call({:put, id, value, version}, ...)
# Both layers, in order: L2 first, then L1.
# Reached from both put/3 (minted version) and put/4 (caller's version).
def handle_call({:put, id, value, version}, _from, state) do
  # L2 first: compose the Valkey key and SET the framed value.
  # The frame is version <> value — the 14-byte branded id prepended
  # to the binary so a future GET can split it with <>.
  # PX ttl_ms: key expires in ttl_ms milliseconds.
  l2 = Keyspace.key(state.table, id)

  {:ok, "OK"} =
    Connector.command(state.conn, [
      "SET",
      l2,
      version <> value,   # the frame: version prepended to the payload
      "PX",
      Integer.to_string(state.spec.ttl_ms)
    ])

  # L1 second: insert the ETS row {id, value, expires_at, version}.
  # expires_at is jittered: ttl ± ttl*jitter (monotonic ms).
  # The version is stored in the row tuple so a coherence comparison
  # can read it without decoding the value binary.
  insert(state, id, value, version)
  {:reply, :ok, state}
end

# EchoStore.Table — put/3 (public)
# Mints a version of the table's kind at the moment of the write.
# BrandedId.generate!(spec.kind) mints a 14-byte branded id, e.g. "RMM0Kp7..."
# The write is its own event, identified by its own snowflake.
def put(name, id, value) when is_binary(value) do
  case EchoStore.spec(name) do
    :error -> {:error, :no_such_cache}
    {:ok, spec} -> put(name, id, value, EchoData.BrandedId.generate!(spec.kind))
  end
end

L2 first, L1 second — in that order, every time. L2 is the durable shared tier; L1 is the fast local tier. A reader that misses L1 but hits L2 always finds a framed value it can split.

The L2 frame: version <> value

# The L2 frame — how a flight splits a stored value
# When GET ecc:{table}:id returns a binary, the flight matches it:
{:ok, <<version::binary-14, value::binary>>} ->
  {:l2, value, version}   # both parts recovered in one match, no extra GET

# The "short" guard catches a malformed frame (should never happen in practice):
{:ok, _short} ->
  {:error, :corrupt_l2_frame}

The frame is the contract: wherever a value goes — L2, L1, a coherence message, a fill reply — its version travels with it. The version is not metadata. It is part of the value.

invalidate/3 — the admin verb

# EchoStore.Table — handle_call({:invalidate, id}, ...)
# The admin verb: DEL L2, :ets.delete L1, unconditionally.
# No version check. This is the operator path: use when you need the
# value evicted regardless of what version is current.
# Distinct from the coherence drop (module 03), which is version-guarded.
def handle_call({:invalidate, id}, _from, state) do
  l2 = Keyspace.key(state.table, id)
  {:ok, _} = Connector.command(state.conn, ["DEL", l2])  # drop L2
  :ets.delete(state.name, id)                             # drop L1
  {:reply, :ok, state}
end

Two drops, no guard. The admin verb is a sledgehammer — the right tool when you need the entry gone and do not care about the race. The coherence drop is the scalpel.

Write simulator — frame and recover

The frame is a binary contract: 14 bytes of identity, then arbitrarily many bytes of payload. The version is always recoverable from a single GET, with no separate metadata key and no schema.

Pattern & implementation

The version is not an afterthought. It is written with the value, always, so that every future reader — a fill, a coherence message, a newer-wins comparison — has the information it needs without a second round-trip.

References