@trioforge/crucible 0.1.0 → 0.2.0

package/out/network.d.ts

@@ -0,0 +1,66 @@
+declare const message: unique symbol;
+declare const width: unique symbol;
+export type f64 = number & {
+    readonly [width]?: "f64";
+};
+export type f32 = number & {
+    readonly [width]?: "f32";
+};
+export type u8 = number & {
+    readonly [width]?: "u8";
+};
+export type u16 = number & {
+    readonly [width]?: "u16";
+};
+export type u32 = number & {
+    readonly [width]?: "u32";
+};
+export interface ToServer<P> {
+    readonly [message]: {
+        readonly kind: "to-server";
+        readonly payload: (value: P) => P;
+    };
+}
+export interface ToClient<P> {
+    readonly [message]: {
+        readonly kind: "to-client";
+        readonly payload: (value: P) => P;
+    };
+}
+export interface AskServer<Request, Response> {
+    readonly [message]: {
+        readonly kind: "ask-server";
+        readonly request: (value: Request) => Request;
+        readonly response: (value: Response) => Response;
+    };
+}
+export interface ClientReady {
+    readonly [message]: {
+        readonly kind: "client-ready";
+    };
+}
+export declare const ClientReady: ClientReady;
+export interface Receiver {
+    readonly [message]: {
+        readonly kind: "receiver";
+    };
+}
+export type PayloadArgs<P> = [P] extends [undefined] ? [] : [payload: P];
+export type AskFailure = "timeout" | "disconnected" | "unavailable" | "handler-error" | "overloaded" | "invalid";
+export type AskResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly reason: AskFailure;
+};
+export interface AskOptions {
+    readonly timeout?: number;
+}
+export type ReceiveTarget = ToServer<any> | ToClient<any> | AskServer<any, any> | ClientReady;
+export type ReceiveCallback<T extends ReceiveTarget> = T extends ToServer<infer P> ? (player: Player, ...payload: PayloadArgs<P>) => void : T extends AskServer<infer Request, infer Response> ? (player: Player, ...request: PayloadArgs<Request>) => Response : T extends ToClient<infer P> ? (...payload: PayloadArgs<P>) => void : (player: Player) => (() => void) | void;
+export declare function toServer<P>(_name: string): ToServer<P>;
+export declare function toClient<P>(_name: string): ToClient<P>;
+export declare function askServer<Request, Response>(_name: string, _options?: AskOptions): AskServer<Request, Response>;
+export declare function receive<T extends ReceiveTarget>(_target: T, _callback: ReceiveCallback<T>): Receiver;
+export {};

package/out/network.luau

@@ -0,0 +1,24 @@
+-- Compiled with roblox-ts v3.0.0
+-- Function-valued phantom positions keep every payload type invariant under strictFunctionTypes.
+local ClientReady = table.freeze({})
+-- `any` is the only argument every invariant token is assignable to.
+local UNTRANSFORMED = "Crucible networking needs the @trioforge/crucible/transformer plugin"
+local function toServer(_name)
+	error(UNTRANSFORMED)
+end
+local function toClient(_name)
+	error(UNTRANSFORMED)
+end
+local function askServer(_name, _options)
+	error(UNTRANSFORMED)
+end
+local function receive(_target, _callback)
+	error(UNTRANSFORMED)
+end
+return {
+	toServer = toServer,
+	toClient = toClient,
+	askServer = askServer,
+	receive = receive,
+	ClientReady = ClientReady,
+}

package/out/reactive.d.ts

@@ -0,0 +1,76 @@
+declare const stateKind: unique symbol;
+/**
+ * A value read by calling it. Any function of no arguments is one, so a getter that reads state, such as
+ * `() => this.open() && !this.locked()`, tracks like a state or a computed.
+ */
+export interface Readable<T> {
+    (): T;
+}
+/**
+ * A writable local value. `set` stores its argument as is, and `update` stores what its callback returns for the
+ * current value. A write equal (`rawequal`) to the current value does nothing, so replace tables instead of
+ * mutating them. At runtime a State is a callable table, not a function: pass `() => s()` to code that tests
+ * `type(x) == "function"`.
+ */
+export interface State<T> extends Readable<T> {
+    readonly [stateKind]: {
+        readonly value: (value: T) => T;
+    };
+    set(value: T): void;
+    update(change: (current: T) => T): void;
+}
+/** A local source of truth. It needs no owner: a field initializer, a local or a module constant. */
+export declare function state<T>(initial: T): State<T>;
+/**
+ * A cached value derived from other readables. It evaluates on its first read and again only when read after a
+ * dependency changed. A result equal to the cached one stops propagation. A throw or a yield is cached and rethrown
+ * to every reader until a dependency changes. Writing state or creating an effect, watch, scope or cleanup inside
+ * `read` throws. It needs no owner.
+ */
+export declare function computed<T>(read: () => T): Readable<T>;
+/**
+ * Keeps something outside the graph in step with state. The body runs on the next reactive flush, never inside
+ * the call that created it, and again after anything it read changed. It may return a cleanup, which runs before
+ * the next run and when the effect ends. It belongs to the code that created it: inside `onEnable` it ends at
+ * disable; otherwise it ends with its object, its parent effect run or its scope. A throw, a yield or another
+ * return value stops it for good, after what its run created is released. With no owner it throws.
+ */
+export declare function effect(body: () => void | (() => void)): void;
+/**
+ * Calls `onChange(value, previous)` on the flushes where `source()` differs from the last value seen. The source is
+ * read now as the baseline, so a change before the first flush is seen. It observes the value at each flush, not
+ * each write. Owned and stopped like `effect`.
+ */
+export declare function watch<T>(source: Readable<T>, onChange: (value: T, previous: T) => void): void;
+/** Calls `read` without tracking what it reads. Ownership is unchanged. */
+export declare function untracked<T>(read: () => T): T;
+/**
+ * Runs `setup` now as a new lifetime that owns every effect, watch, scope and cleanup created inside it. Returns
+ * an idempotent dispose. Inside another owner it also ends when that owner ends; outside every owner it is a root
+ * that only its dispose ends. If `setup` throws or yields, what it created ends and the error is rethrown.
+ */
+export declare function scope(setup: () => void): () => void;
+/**
+ * Registers `release` to run once when the current owner ends: after the owner's effects and scopes ended, newest
+ * release first. Under an owner that already ended it runs at once. With no owner it throws.
+ */
+export declare function onCleanup(release: () => void): void;
+/**
+ * What `own` releases: a function, called with no arguments; a connection, disconnected; an Instance, destroyed; a
+ * thread, cancelled with `task.cancel`; or an object, through its `destroy()` or else its `Destroy()`. A `State` is a
+ * callable table, not a function, so it is not one.
+ */
+export type Ownable = ((() => void) & {
+    readonly [stateKind]?: never;
+}) | RBXScriptConnection | Instance | thread | {
+    destroy(): void;
+} | {
+    Destroy(): void;
+};
+/**
+ * Releases `value` once when the current owner ends, exactly as `onCleanup` would release a function that does it,
+ * and returns `value`. How it is released is decided now, from its type. Under an owner that already ended it is
+ * released at once. With no owner it throws, and so does a value that is not `Ownable`.
+ */
+export declare function own<T extends Ownable>(value: T): T;
+export {};

package/out/reactive.luau

@@ -0,0 +1,136 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _flush = TS.import(script, script.Parent, "internal", "reactive", "flush")
+local createEffect = _flush.createEffect
+local createWatch = _flush.createWatch
+local _graph = TS.import(script, script.Parent, "internal", "reactive", "graph")
+local createComputedNode = _graph.createComputedNode
+local createStateNode = _graph.createStateNode
+local readComputed = _graph.readComputed
+local readState = _graph.readState
+local readUntracked = _graph.readUntracked
+local update = _graph.update
+local write = _graph.write
+local _ownership = TS.import(script, script.Parent, "internal", "reactive", "ownership")
+local createScope = _ownership.createScope
+local registerCleanup = _ownership.registerCleanup
+local registerOwned = _ownership.registerOwned
+--[[
+	*
+	 * A value read by calling it. Any function of no arguments is one, so a getter that reads state, such as
+	 * `() => this.open() && !this.locked()`, tracks like a state or a computed.
+	 
+]]
+--[[
+	*
+	 * A writable local value. `set` stores its argument as is, and `update` stores what its callback returns for the
+	 * current value. A write equal (`rawequal`) to the current value does nothing, so replace tables instead of
+	 * mutating them. At runtime a State is a callable table, not a function: pass `() => s()` to code that tests
+	 * `type(x) == "function"`.
+	 
+]]
+local stateMethods = {
+	set = function(self, value)
+		write(self, value)
+	end,
+	update = function(self, change)
+		update(self, change)
+	end,
+}
+local stateMeta = {
+	__index = stateMethods,
+	__call = function(node)
+		return readState(node)
+	end,
+}
+--* A local source of truth. It needs no owner: a field initializer, a local or a module constant. 
+local function state(initial)
+	return setmetatable(createStateNode(initial), stateMeta)
+end
+--[[
+	*
+	 * A cached value derived from other readables. It evaluates on its first read and again only when read after a
+	 * dependency changed. A result equal to the cached one stops propagation. A throw or a yield is cached and rethrown
+	 * to every reader until a dependency changes. Writing state or creating an effect, watch, scope or cleanup inside
+	 * `read` throws. It needs no owner.
+	 
+]]
+local function computed(read)
+	local node = createComputedNode(read)
+	return function()
+		return readComputed(node)
+	end
+end
+--[[
+	*
+	 * Keeps something outside the graph in step with state. The body runs on the next reactive flush, never inside
+	 * the call that created it, and again after anything it read changed. It may return a cleanup, which runs before
+	 * the next run and when the effect ends. It belongs to the code that created it: inside `onEnable` it ends at
+	 * disable; otherwise it ends with its object, its parent effect run or its scope. A throw, a yield or another
+	 * return value stops it for good, after what its run created is released. With no owner it throws.
+	 
+]]
+local function effect(body)
+	createEffect(body)
+end
+--[[
+	*
+	 * Calls `onChange(value, previous)` on the flushes where `source()` differs from the last value seen. The source is
+	 * read now as the baseline, so a change before the first flush is seen. It observes the value at each flush, not
+	 * each write. Owned and stopped like `effect`.
+	 
+]]
+local function watch(source, onChange)
+	createWatch(source, onChange)
+end
+--* Calls `read` without tracking what it reads. Ownership is unchanged. 
+local function untracked(read)
+	return readUntracked(read)
+end
+--[[
+	*
+	 * Runs `setup` now as a new lifetime that owns every effect, watch, scope and cleanup created inside it. Returns
+	 * an idempotent dispose. Inside another owner it also ends when that owner ends; outside every owner it is a root
+	 * that only its dispose ends. If `setup` throws or yields, what it created ends and the error is rethrown.
+	 
+]]
+local function scope(setup)
+	return createScope(setup)
+end
+--[[
+	*
+	 * Registers `release` to run once when the current owner ends: after the owner's effects and scopes ended, newest
+	 * release first. Under an owner that already ended it runs at once. With no owner it throws.
+	 
+]]
+local function onCleanup(release)
+	registerCleanup(release)
+end
+--[[
+	*
+	 * What `own` releases: a function, called with no arguments; a connection, disconnected; an Instance, destroyed; a
+	 * thread, cancelled with `task.cancel`; or an object, through its `destroy()` or else its `Destroy()`. A `State` is a
+	 * callable table, not a function, so it is not one.
+	 
+]]
+--[[
+	*
+	 * Releases `value` once when the current owner ends, exactly as `onCleanup` would release a function that does it,
+	 * and returns `value`. How it is released is decided now, from its type. Under an owner that already ended it is
+	 * released at once. With no owner it throws, and so does a value that is not `Ownable`.
+	 
+]]
+local function own(value)
+	registerOwned(value)
+	return value
+end
+return {
+	state = state,
+	computed = computed,
+	effect = effect,
+	watch = watch,
+	untracked = untracked,
+	scope = scope,
+	onCleanup = onCleanup,
+	own = own,
+}

package/out/replicated.d.ts

@@ -0,0 +1,38 @@
+import type { Readable } from "./reactive";
+declare const replicatedKind: unique symbol;
+/** Whether a replicated value holds what the server published: before the first frame, after it, or failed. */
+export type SyncStatus = "pending" | "ready" | "failed";
+/**
+ * A value every client receives. On the server it reads the authoritative value; on a client, the last value the
+ * server sent, or `initial` before the first frame. At runtime it is a plain function, so it composes like any getter.
+ */
+export interface Replicated<T> extends Readable<T> {
+    readonly [replicatedKind]: {
+        readonly audience: "all";
+        readonly value: (value: T) => T;
+    };
+}
+/**
+ * A value each player receives privately. On a client it reads the local player's value, or `initial` before the
+ * first frame. On the server there is no single value, so calling it throws.
+ */
+export interface ReplicatedPerPlayer<T> extends Readable<T> {
+    readonly [replicatedKind]: {
+        readonly audience: "player";
+        readonly value: (value: T) => T;
+    };
+}
+/**
+ * Declares a value every client receives. Write it as the initializer of an exported top-level const in a shared
+ * module, with an explicit type argument and a literal name. The server writes it through `publish`; fields the type
+ * does not declare are never sent.
+ */
+export declare function replicated<T = never>(_name: string, _initial: NoInfer<T>): Replicated<T>;
+/** Declares a value each player receives privately. The server supplies it with `publish(declaration, project)`. */
+export declare function replicatedPerPlayer<T = never>(_name: string, _initial: NoInfer<T>): ReplicatedPerPlayer<T>;
+/**
+ * The declaration's sync status. Inside an effect or a computed it tracks like a value. On the server, a per-player
+ * declaration throws.
+ */
+export declare function syncStatus<T>(declaration: Replicated<T> | ReplicatedPerPlayer<T>): SyncStatus;
+export {};

package/out/replicated.luau

@@ -0,0 +1,45 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local statusOf = TS.import(script, script.Parent, "internal", "sync", "declarations").statusOf
+--* Whether a replicated value holds what the server published: before the first frame, after it, or failed. 
+--[[
+	*
+	 * A value every client receives. On the server it reads the authoritative value; on a client, the last value the
+	 * server sent, or `initial` before the first frame. At runtime it is a plain function, so it composes like any getter.
+	 
+]]
+--[[
+	*
+	 * A value each player receives privately. On a client it reads the local player's value, or `initial` before the
+	 * first frame. On the server there is no single value, so calling it throws.
+	 
+]]
+local UNTRANSFORMED = "Crucible replicated state needs the @trioforge/crucible/transformer plugin"
+--[[
+	*
+	 * Declares a value every client receives. Write it as the initializer of an exported top-level const in a shared
+	 * module, with an explicit type argument and a literal name. The server writes it through `publish`; fields the type
+	 * does not declare are never sent.
+	 
+]]
+local function replicated(_name, _initial)
+	error(UNTRANSFORMED)
+end
+--* Declares a value each player receives privately. The server supplies it with `publish(declaration, project)`. 
+local function replicatedPerPlayer(_name, _initial)
+	error(UNTRANSFORMED)
+end
+--[[
+	*
+	 * The declaration's sync status. Inside an effect or a computed it tracks like a value. On the server, a per-player
+	 * declaration throws.
+	 
+]]
+local function syncStatus(declaration)
+	return statusOf(declaration)
+end
+return {
+	replicated = replicated,
+	replicatedPerPlayer = replicatedPerPlayer,
+	syncStatus = syncStatus,
+}

package/out/server/data.d.ts

@@ -0,0 +1,54 @@
+import type { Migration, OperationId, ProfileMessage, StoreFailure, StoreResult } from "../data";
+declare const recordKind: unique symbol;
+export interface StoreOptions<T> {
+    /**
+     * A new record's value, and the value of a missing required key on an object path from the root. It never fills an
+     * array element, a map value or an optional key of an existing record. Admitted and frozen once.
+     */
+    readonly defaults: T;
+    /** Append-only. Removing or reordering a step changes what every older record becomes. */
+    readonly migrations?: readonly Migration[];
+}
+/**
+ * A generic update's result. `replayed` is true when the operation id was already recorded for the key: `change` did
+ * not run, and `value` is the current stored record (the defaults when the key holds no payload), which may include
+ * later writers' changes. A marker stores no result, so the original one cannot be returned.
+ */
+export type UpdateResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+    readonly replayed: boolean;
+} | {
+    readonly ok: false;
+    readonly reason: StoreFailure;
+};
+/**
+ * Keyed records with no session. Each call is one DataStore request that yields and may fail, so the surface is two
+ * calls with result unions, not live handles.
+ */
+export interface DataStore<T> {
+    readonly [recordKind]: {
+        readonly kind: "records";
+        readonly value: (value: T) => T;
+    };
+    /** Yields. The stored record, migrated and admitted, or undefined when the key has none. */
+    read(key: string): StoreResult<T | undefined>;
+    /**
+     * Yields. One atomic change; `change` may run more than once, so it must be pure. A replayed id returns the current
+     * record with `replayed: true`. A throw in `change` cancels the write and is rethrown here.
+     */
+    update(key: string, change: (current: T) => T, id?: OperationId): UpdateResult<T>;
+}
+/**
+ * Declares keyed records by their DataStore name. It must initialize an exported top-level const in a server module,
+ * with `T` explicit. `T` is an object or a string-keyed record at its root.
+ */
+export declare function dataStore<T extends object>(_name: string, _options: StoreOptions<NoInfer<T>>): DataStore<T>;
+/** A fresh operation identity. Create it once per logical operation and reuse it for that operation's retries. */
+export declare function operationId(): OperationId;
+/**
+ * Declares a durable message to a player's profile. It must initialize an exported top-level const in a server module,
+ * with the payload type explicit. A payload type changes only by adding optional fields.
+ */
+export declare function profileMessage<P>(_name: string): ProfileMessage<P>;
+export {};

package/out/server/data.luau

@@ -0,0 +1,44 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local newOperationId = TS.import(script, script.Parent.Parent, "internal", "data", "operation-id").newOperationId
+local dataPort = TS.import(script, script.Parent.Parent, "internal", "data", "port").dataPort
+--[[
+	*
+	 * A generic update's result. `replayed` is true when the operation id was already recorded for the key: `change` did
+	 * not run, and `value` is the current stored record (the defaults when the key holds no payload), which may include
+	 * later writers' changes. A marker stores no result, so the original one cannot be returned.
+	 
+]]
+--[[
+	*
+	 * Keyed records with no session. Each call is one DataStore request that yields and may fail, so the surface is two
+	 * calls with result unions, not live handles.
+	 
+]]
+--[[
+	*
+	 * Declares keyed records by their DataStore name. It must initialize an exported top-level const in a server module,
+	 * with `T` explicit. `T` is an object or a string-keyed record at its root.
+	 
+]]
+local function dataStore(_name, _options)
+	error("Crucible data needs the @trioforge/crucible/transformer plugin")
+end
+--* A fresh operation identity. Create it once per logical operation and reuse it for that operation's retries. 
+local function operationId()
+	return newOperationId(dataPort())
+end
+--[[
+	*
+	 * Declares a durable message to a player's profile. It must initialize an exported top-level const in a server module,
+	 * with the payload type explicit. A payload type changes only by adding optional fields.
+	 
+]]
+local function profileMessage(_name)
+	error("Crucible data needs the @trioforge/crucible/transformer plugin")
+end
+return {
+	dataStore = dataStore,
+	operationId = operationId,
+	profileMessage = profileMessage,
+}

package/out/server/index.d.ts

@@ -1,2 +1,18 @@
 import type { BootOptions } from "../index";
+import type { PayloadArgs, ToClient } from "../network";
+import "../internal/data/record-bindings";
+export { config, playerConfig, configReady, refreshConfigs } from "../configs";
+export type { Config, PlayerConfig } from "../configs";
+export { publish } from "./publish";
+export type { Publication } from "./publish";
+export { dataStore, operationId, profileMessage } from "./data";
+export type { DataStore, StoreOptions, UpdateResult } from "./data";
+export type { OperationId, StoreFailure, StoreResult } from "../data";
+export type { ProfileMessage, ProfileClaim, LoadReason, ReleaseReason, Purchase, AfterGrant, QuarantinedMessage, SaveResult, SaveFailure, } from "../data";
 export declare function boot(options: BootOptions): void;
+export declare namespace Network {
+    /** True when accepted locally: fired now, or queued before the player's client is ready. Never delivery. */
+    function send<P>(player: Player, message: ToClient<P>, ...payload: PayloadArgs<NoInfer<P>>): boolean;
+    /** Encodes once and delivers the same packet to every player in the game now. */
+    function broadcast<P>(message: ToClient<P>, ...payload: PayloadArgs<NoInfer<P>>): void;
+}

package/out/server/init.luau

@@ -1,16 +1,62 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
+local exports = {}
 local bootSide = TS.import(script, script.Parent, "internal", "boot").boot
+local installConfigRuntime = TS.import(script, script.Parent, "internal", "configs", "runtime").installConfigRuntime
+local networkPort = TS.import(script, script.Parent, "internal", "network", "port").networkPort
+local ServerSession = TS.import(script, script.Parent, "internal", "network", "server-session").ServerSession
+local SyncFrameMessage = TS.import(script, script.Parent, "internal", "sync", "frame").SyncFrameMessage
+local installServerSync = TS.import(script, script.Parent, "internal", "sync", "server-sync").installServerSync
+TS.import(script, script.Parent, "internal", "data", "record-bindings")
+local installDataRuntime = TS.import(script, script.Parent, "internal", "data", "runtime").installDataRuntime
 if not game:GetService("RunService"):IsServer() then
 	error("@trioforge/crucible/server loaded on the client")
 end
+local session
+local _configs = TS.import(script, script.Parent, "configs")
+exports.config = _configs.config
+exports.playerConfig = _configs.playerConfig
+exports.configReady = _configs.configReady
+exports.refreshConfigs = _configs.refreshConfigs
+exports.publish = TS.import(script, script, "publish").publish
+local _data = TS.import(script, script, "data")
+exports.dataStore = _data.dataStore
+exports.operationId = _data.operationId
+exports.profileMessage = _data.profileMessage
+local function active()
+	return session or error("Crucible networking is not ready; send from a constructor, a hook, or later", 0)
+end
+installConfigRuntime()
+installDataRuntime()
 local function boot(options)
+	local network = ServerSession.new(networkPort())
+	session = network
+	installServerSync(function(player, frame)
+		return active():send(player, SyncFrameMessage, frame)
+	end)
 	bootSide({
 		name = "server",
 		renders = false,
 		booted = function() end,
+		network = network,
 	}, options)
 end
-return {
-	boot = boot,
-}
+local Network = {}
+do
+	local _container = Network
+	--* True when accepted locally: fired now, or queued before the player's client is ready. Never delivery. 
+	local function send(player, message, ...)
+		local payload = { ... }
+		return active():send(player, message, payload[1])
+	end
+	_container.send = send
+	--* Encodes once and delivers the same packet to every player in the game now. 
+	local function broadcast(message, ...)
+		local payload = { ... }
+		active():broadcast(message, payload[1])
+	end
+	_container.broadcast = broadcast
+end
+exports.boot = boot
+exports.Network = Network
+return exports

package/out/server/publish.d.ts

@@ -0,0 +1,20 @@
+import type { State } from "../reactive";
+import type { Replicated, ReplicatedPerPlayer } from "../replicated";
+declare const publication: unique symbol;
+/** What a per-player `publish` returns: an opaque claim that holds nothing callable. */
+export interface Publication {
+    readonly [publication]: true;
+}
+/**
+ * Takes the write side of a value every client sees. Call it while a server Subsystem is constructed, as a field
+ * initializer: `private readonly phase = publish(JobPhase)`. `set` and `update` drop fields the type does not
+ * declare, check and freeze the rest, and throw at a write that cannot replicate. One Subsystem publishes each value.
+ */
+export declare function publish<T>(target: Replicated<T>): State<T>;
+/**
+ * Supplies a per-player value as a projection. For each player whose client is ready, it is evaluated like a
+ * `computed`, admitted on every pull and sent to that player alone. It must be pure and must not yield. A throw or a
+ * rejected value marks that player's value failed until it next changes.
+ */
+export declare function publish<T>(target: ReplicatedPerPlayer<T>, project: (player: Player) => T): Publication;
+export {};

package/out/server/publish.luau

@@ -0,0 +1,24 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local claimPublication = TS.import(script, script.Parent.Parent, "internal", "sync", "declarations").claimPublication
+--* What a per-player `publish` returns: an opaque claim that holds nothing callable. 
+--[[
+	*
+	 * Takes the write side of a value every client sees. Call it while a server Subsystem is constructed, as a field
+	 * initializer: `private readonly phase = publish(JobPhase)`. `set` and `update` drop fields the type does not
+	 * declare, check and freeze the rest, and throw at a write that cannot replicate. One Subsystem publishes each value.
+	 
+]]
+--[[
+	*
+	 * Supplies a per-player value as a projection. For each player whose client is ready, it is evaluated like a
+	 * `computed`, admitted on every pull and sent to that player alone. It must be pure and must not yield. A throw or a
+	 * rejected value marks that player's value failed until it next changes.
+	 
+]]
+local function publish(target, project)
+	return claimPublication(target, project)
+end
+return {
+	publish = publish,
+}

package/out/vide/index.d.ts

@@ -0,0 +1,7 @@
+import { type Readable } from "../reactive";
+/**
+ * A Vide source that follows `readable`. It holds the value read now, untracked, and takes each change on the
+ * reactive flush, through a `watch` that ends with the current Vide owner. Outside a Vide component or `root` it
+ * throws.
+ */
+export declare function useReadable<T>(readable: Readable<T>): () => T;