LogicSRC standards surface
++ A bucket you can mount: keyed objects, encrypted by their owner, kept on paid disks at a + stated redundancy, verified every period, repaired when a disk fails, and read back by path + from anywhere. +
++ OpenSwarm says how one swarm is paid to be held and how a + holder proves it still holds it. OpenDisk says how a disk is + found. What neither says is what an application needs: a bucket with a name, a thousand keys + under it that change, a promise that each object is on three different machines in two + countries, a list by prefix, a version history, and a mount so a process can open a path + without knowing any of the above. OpenObject is that shape written down, so a bucket at one + store is the same bucket at another. +
++ Status: 0.1. d1sks.com is the reference store, running every + bucket at three replicas on three operators in two countries by default. Every store is also + a storage offer in the OpenServer sense. An{" "} + OpenSlice slice mounts a bucket as its disk. +
+
+ Served at /.well-known/openobject.json. Only a name, an API and
+ one policy are required.
+
{DESCRIPTOR}
+
+ policies is what the store will run: replicas{" "}
+ means every holder has the whole object, erasure means every holder
+ has one shard and any k rebuild it. min_operators and{" "}
+ min_countries are floors on distinctness. disks{" "}
+ is the pool, as OpenDisk descriptors, so an owner reads it before trusting a promise of three
+ operators. record.lost is how many objects ever went below the read
+ threshold, and a store that has lost one says so.
+
One record per revision, appended to the bucket's index, an ipdb feed under the bucket key.
+{OBJECT}
+
+ key is a path. seq is the bucket's
+ clock: the higher seq is the newer statement about a key. id is
+ the SHA-256 of the plaintext and the ETag. holders are the disks
+ under lease, one per replica or per shard. state is healthy,
+ degraded, lost or pending, and a read of a degraded object still succeeds.
+
Nothing on the swarm side changes. The store keeps the index and posts the offers.
+| + {step} + | +{what} | +
+ A store may also serve S3, because every tool already speaks it: ETag is the id, versions are + revisions, multipart becomes one swarm. Owner-encrypted buckets are not reachable over S3, + because S3 has nowhere to put the key. +
+A store is a storage offer; its disks are listed separately as OpenDisk offers.
+| OpenServer | +from OpenObject | +
|---|---|
+ {key}
+ |
+ {from} | +
| + {what} + | +{why} | +
LogicSRC standards surface
++ A container whose compute is rented from one market and whose disk is mounted from + another, so the host is interchangeable: stop the slice here, start it there, the mount + reattaches. +
+
+ A c0mpute job ends; a service does not. A web app, a game
+ server, an agent that listens for messages need a share of a machine for a while, not a job
+ done. OpenSlice is that share written down: a host puts its free threads, memory, GPU, price,
+ runtime and policy at /.well-known/openslice.json, an owner writes
+ one signed file that says image, resources, mounts, ports and lifetime, and a reservation at
+ a hub matches them for a number of hours with proofs every epoch. The durable state is an{" "}
+ OpenObject bucket kept at three replicas elsewhere, which is
+ what makes a peer's machine tolerable to run on.
+
+ Status: 0.1. slic3s.com is the reference marketplace: every + host descriptor it has read, standing from the hubs each names, and a launcher that takes a + slice spec. Compute from c0mpute.com, disk from d1sks.com, the pair from slic3s.com. The name + is shared with ETSI's OpenSlice, an operations system for 5G network slicing; this + document is about containers. +
+
+ Served at /.well-known/openslice.json. Only a name, free threads,
+ free memory and the two hourly prices are required.
+
{DESCRIPTOR}
+
+ capacity is in OpenCPU,{" "}
+ OpenMemory and OpenGPU{" "}
+ units, and *_free is what a new slice can have now.{" "}
+ runtime is what runs the container. accepts{" "}
+ is policy stated up front. record.evicted counts slices the host
+ stopped before the owner did, and a marketplace ranks on the hub's number, not the
+ file's.
+
One signed file. The id is the slice key and it keeps it across hosts, which is what makes a move a move.
+{SLICE}
+
+ image is by digest, from a registry or from a bucket, so it
+ outlives the registry. mounts are OpenObject buckets seen as
+ directories, the content key granted to the slice, not the host.{" "}
+ env resolves secrets from an OpenCreds{" "}
+ vault at start. placement.near names a bucket so the marketplace
+ prefers hosts on the same network as its holders.
+
The disk protocols were written first. A reservation is a lease, an epoch is a period, a presence record is a proof.
+| + {step} + | +{what} | +
A host is a hosting offer, and a directory that reads OpenServer lists it without a second parser.
+| OpenServer | +from OpenSlice | +
|---|---|
+ {key}
+ |
+ {from} | +
| + {what} + | +{why} | +