@trioforge/crucible 0.0.0-stage → 0.2.0

package/out/log-level.d.ts

@@ -0,0 +1,7 @@
+export declare enum LogLevel {
+    Debug = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3,
+    Off = 4
+}

package/out/log-level.luau

@@ -0,0 +1,21 @@
+-- Compiled with roblox-ts v3.0.0
+local LogLevel
+do
+	local _inverse = {}
+	LogLevel = setmetatable({}, {
+		__index = _inverse,
+	})
+	LogLevel.Debug = 0
+	_inverse[0] = "Debug"
+	LogLevel.Info = 1
+	_inverse[1] = "Info"
+	LogLevel.Warning = 2
+	_inverse[2] = "Warning"
+	LogLevel.Error = 3
+	_inverse[3] = "Error"
+	LogLevel.Off = 4
+	_inverse[4] = "Off"
+end
+return {
+	LogLevel = LogLevel,
+}

package/out/logging.d.ts

@@ -0,0 +1,34 @@
+import { LogLevel } from "./log-level";
+export { LogLevel } from "./log-level";
+export type LogContext = Readonly<Record<string, unknown>>;
+export type LogProperties = Readonly<Record<string, string | number | boolean>>;
+export interface LogRecord {
+    readonly sequence: number;
+    readonly time: number;
+    readonly source: string;
+    readonly level: Exclude<LogLevel, LogLevel.Off>;
+    readonly template: string;
+    readonly context: LogProperties;
+    readonly message: string;
+    readonly traceback?: string;
+}
+export interface LogSink {
+    readonly write: (record: LogRecord) => void;
+}
+export interface SinkSubscription {
+    setMinimum(level: LogLevel): void;
+    disconnect(): void;
+}
+export interface Logger {
+    isEnabled(level: Exclude<LogLevel, LogLevel.Off>): boolean;
+    debug(template: string, context?: LogContext): void;
+    info(template: string, context?: LogContext): void;
+    warn(template: string, context?: LogContext): void;
+    error(template: string, context?: LogContext): void;
+}
+export declare class Logging {
+    private constructor();
+    static readonly defaultSink: SinkSubscription;
+    static getLogger(source: string): Logger;
+    static addSink(sink: LogSink, minimum?: LogLevel): SinkSubscription;
+}

package/out/logging.luau

@@ -0,0 +1,233 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+local LogLevel = TS.import(script, script.Parent, "log-level").LogLevel
+local runtimeDiagnostic = TS.import(script, script.Parent, "internal", "diagnostics").runtimeDiagnostic
+local loggingPort = TS.import(script, script.Parent, "internal", "log-output").loggingPort
+local call = TS.import(script, script.Parent, "internal", "runner").call
+exports.LogLevel = TS.import(script, script.Parent, "log-level").LogLevel
+local registrations = {}
+local snapshot = {}
+local minimum = LogLevel.Off
+local sequence = 0
+local emitting = false
+local function derive(added)
+	local entries = {}
+	minimum = LogLevel.Off
+	-- roblox-ts Maps compile to unordered Luau tables. The array owns delivery order.
+	for _, registration in snapshot do
+		if not registration.connected then
+			continue
+		end
+		table.insert(entries, registration)
+		minimum = math.min(minimum, registration.minimum)
+	end
+	if added ~= nil then
+		local _added = added
+		table.insert(entries, _added)
+		minimum = math.min(minimum, added.minimum)
+	end
+	snapshot = table.freeze(entries)
+end
+local function validateMinimum(level)
+	local _arg0 = level >= LogLevel.Debug and level <= LogLevel.Off and level % 1 == 0
+	assert(_arg0, "Invalid log minimum")
+end
+local function register(sink, level)
+	validateMinimum(level)
+	local _sink = sink
+	local existing = registrations[_sink]
+	if existing ~= nil then
+		return existing.subscription
+	end
+	local _write = sink.write
+	local _arg0 = type(_write) == "function"
+	assert(_arg0, "Log sink requires write")
+	local registration
+	registration = {
+		sink = sink,
+		minimum = level,
+		connected = true,
+		subscription = {
+			setMinimum = function(self, value)
+				validateMinimum(value)
+				if not registration.connected then
+					return nil
+				end
+				registration.minimum = value
+				derive()
+			end,
+			disconnect = function(self)
+				if not registration.connected then
+					return nil
+				end
+				registration.connected = false
+				local _sink_1 = sink
+				registrations[_sink_1] = nil
+				derive()
+			end,
+		},
+	}
+	local _sink_1 = sink
+	registrations[_sink_1] = registration
+	derive(registration)
+	return registration.subscription
+end
+local function normalize(input)
+	local context = {}
+	if input ~= nil then
+		for key, value in pairs(input) do
+			context[key] = if typeof(value) == "Instance" then loggingPort().describeInstance(value) elseif type(value) == "string" or type(value) == "number" or type(value) == "boolean" then value else tostring(value)
+		end
+	end
+	return table.freeze(context)
+end
+local function render(template, context)
+	local parts = {}
+	local index = 1
+	while index <= #template do
+		local _template = template
+		local _index = index
+		local _index_1 = index
+		local char = string.sub(_template, _index, _index_1)
+		local _template_1 = template
+		local _index_2 = index
+		local _arg1 = index + 1
+		local pair = string.sub(_template_1, _index_2, _arg1)
+		if pair == "{{" or pair == "}}" then
+			table.insert(parts, char)
+			index += 2
+		elseif char == "{" then
+			local _template_2 = template
+			local _arg1_1 = index + 1
+			local close = string.find(_template_2, "}", _arg1_1, true)
+			if close ~= nil then
+				local _template_3 = template
+				local _arg0 = index + 1
+				local _arg1_2 = close - 1
+				local key = string.sub(_template_3, _arg0, _arg1_2)
+				local value = context[key]
+				local _result
+				if value == nil then
+					local _template_4 = template
+					local _index_3 = index
+					_result = string.sub(_template_4, _index_3, close)
+				else
+					_result = tostring(value)
+				end
+				table.insert(parts, _result)
+				index = close + 1
+			else
+				table.insert(parts, char)
+				index += 1
+			end
+		else
+			table.insert(parts, char)
+			index += 1
+		end
+	end
+	return table.concat(parts, "")
+end
+local function emit(source, level, template, input)
+	if emitting or level < minimum then
+		return nil
+	end
+	emitting = true
+	local trace = if level == LogLevel.Error then debug.traceback("", 3) else nil
+	local result, failure = call(function()
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(r)
+			return level >= r.minimum
+		end
+		local _length = 0
+		for _k, _v in snapshot do
+			if _callback(_v, _k - 1, snapshot) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		local accepted = _newValue
+		local context = normalize(input)
+		local _object = {}
+		local _left = "sequence"
+		sequence += 1
+		_object[_left] = sequence
+		_object.time = loggingPort().now()
+		_object.source = source
+		_object.level = level
+		_object.template = template
+		_object.context = context
+		_object.message = render(template, context)
+		_object.traceback = trace
+		local record = table.freeze(_object)
+		for _, registration in accepted do
+			if not registration.connected then
+				continue
+			end
+			local status, err = call(registration.sink.write, record, nil)
+			if status ~= 0 then
+				registration.subscription:disconnect()
+				runtimeDiagnostic("error", `Log sink failed: {tostring(err)}`)
+			end
+		end
+	end, nil, nil)
+	if result ~= 0 then
+		runtimeDiagnostic("error", `Logging failed: {tostring(failure)}`)
+	end
+	emitting = false
+end
+local Logging
+do
+	Logging = setmetatable({}, {
+		__tostring = function()
+			return "Logging"
+		end,
+	})
+	Logging.__index = Logging
+	function Logging.new(...)
+		local self = setmetatable({}, Logging)
+		return self:constructor(...) or self
+	end
+	function Logging:constructor()
+	end
+	function Logging:getLogger(source)
+		local _arg0 = #source > 0 and #source <= 256 and (string.find(source, "%c")) == nil
+		assert(_arg0, "Invalid logger name")
+		for _, segment in string.split(source, ".") do
+			local _arg0_1 = #segment > 0
+			assert(_arg0_1, "Invalid logger name segment")
+		end
+		return {
+			isEnabled = function(self, level)
+				return level >= minimum
+			end,
+			debug = function(self, template, context)
+				emit(source, LogLevel.Debug, template, context)
+			end,
+			info = function(self, template, context)
+				emit(source, LogLevel.Info, template, context)
+			end,
+			warn = function(self, template, context)
+				emit(source, LogLevel.Warning, template, context)
+			end,
+			error = function(self, template, context)
+				emit(source, LogLevel.Error, template, context)
+			end,
+		}
+	end
+	function Logging:addSink(sink, minimum)
+		if minimum == nil then
+			minimum = LogLevel.Info
+		end
+		return register(sink, minimum)
+	end
+	Logging.defaultSink = register({
+		write = function(record)
+			return loggingPort().writeGame(record)
+		end,
+	}, if loggingPort().isStudio() then LogLevel.Debug else LogLevel.Info)
+end
+exports.Logging = Logging
+return exports

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,
+}