Dataspaces, tuples, Linda, and continuations

Cursors places a Syndicate/Linda-like dataspace above the mailbox fabric and below language worlds. The point is not to clone one historical tuple-space API. The point is to give programs a small coordination model that remains meaningful while carriers, bodies, and network reachability change.

The dataspace holds current coordination state:

• assertions: “body Cedar currently offers an NVMe queue”;
• interests: “wake me while any trusted body offers this continuation ABI”;
• facets: scoped behavior whose assertions and interests end together;
• leases: expiration when a publisher disappears or cannot renew;
• attribution: every assertion retains its responsible publisher and relevant grant.

The Linda family resemblance

Classic Linda gives useful verbs such as out, rd, and in: put a tuple, observe a matching tuple, or consume one. Cursors wants the useful compositional idea without pretending there is one immortal globally consistent tuple server.

A conceptual mapping is:

The important change is attribution. A tuple is not simply “in the space”; Cursors should retain who asserted it, under what curve/capability, with what lease and causal context.

Why above mailboxes

Mailboxes answer where envelopes wait and how they are delivered. Dataspaces answer what participants currently claim and what patterns programs care about. Implementing tuples directly in every transport would couple program semantics to recovery, routing, and packet choices.

A mailbox may carry an assertion envelope. The assertion itself belongs to dataspace semantics. A WebRTC packet or HTTP request is lower still. Keeping those layers separate is what lets the same program survive offline, LAN-only, or relay-backed operation.

Why ephemeral

An expired “body is online” assertion should disappear; its historical publication can still be audited through cursor or mailbox records when required. Treating all coordination as permanent produces unbounded, misleading state.

Durable truth belongs in signed history, immutable objects, checkpoints, or explicit mailbox/storage policy. Current presence and availability usually do not.

Tuple shape

The shipped SQLite body schema now materializes leased assertions in cursor_tuples and interests in cursor_interests. These are local operational projections, not a global tuple space. The restricted Lua example compiles directly to renewable assert and interest graph nodes; expiry remains explicit and capability checking still occurs before placement/execution.

The reference model uses typed lists and structural capture patterns:

await space.assert({
  publisher: body.id,
  tuple: ["body", body.id, "offers", "nvme"],
  attributes: { queueDepth: 32, locality: "rack-7" },
  leaseUntil: clock + 30,
});

space.query(["body", capture("body"), "offers", capture("resource")], clock);

Tuples are not the only possible surface language. Preserves-like syntax, Smalltalk objects, Syndicate patterns, typed language records, or compact wire values can map to the same canonical values at boundaries.

Continuations are the other half

A tuple says something about the current world. A continuation says where computation may resume.

cursor N
  continuation: media-player/watch-party@step-18
  checkpoint: state:sha256:…
  interests:
    ["room", roomId, "clock", ?leader]
    ["media", mediaId, "piece", ?piece]

If the required tuple is absent, a body can checkpoint and stop consuming resources. When a matching assertion appears, the continuation can be resumed by an authorized body. The body is replaceable; the continuation and causal cursor history are the durable programming concepts.

Useful program operators therefore line up naturally:

exchange(value)   publish/request semantic material
mailbox(address)  choose an addressed coordination boundary
split(a, b)       fork causal work
join(a, b)        wait for compatible child results
exec(program)     ask an authorized body to resume a continuation
checkpoint(state) make resumable state explicit
interest(pattern) wait on current dataspace state
assert(tuple)     publish current dataspace state

This is why exec should not mean “RPC this machine.” It means “continue this inspectable program at a capable body and produce signed history/receipts.”

Partitions and offline operation

There should not be one magical global tuple space. Dataspaces form overlapping scopes:

• one body or process;
• one Self/world;
• a trusted LAN constellation;
• an application fabric;
• a public discovery plane.

A partition yields divergent current views, not false global consistency. If two LAN islands both continue operating, each may hold different assertions while sharing the same earlier cursor history. Reconnection republishes or reconciles leased assertions according to facet policy; immutable cursor history is reconciled causally rather than overwritten.

That gives an expected offline behavior:

Internet disappears
  → remote assertions expire or become unreachable
  → LAN/device assertions remain
  → interested continuations either keep running locally or checkpoint
  → queued mailbox envelopes retain IDs/expiry
  → reconnection re-observes state before resuming effects

What should become visible in the cockpit

The dataspace should eventually be explorable as circuitry rather than a table hidden behind jargon:

• assertion nodes show tuple shape, publisher evidence, lease, and curve;
• interest nodes show the structural pattern and the continuation waiting on it;
• wires show the mailbox/fabric carrier that transported an assertion;
• a matched interest visually closes a circuit to the continuation it wakes;
• fan-out and fan-in appear as causal branches, not merely counters;
• expired assertions fade from the current-world view while remaining reachable from historical cursor records when recorded there.

The cockpit must keep one boundary obvious: matching a tuple is not authority to execute an effect. The continuation still passes its capability checks.