@trioforge/crucible 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Trio Forge Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/client/package.json

@@ -0,0 +1,4 @@
+{
+	"main": "../out/client/init.luau",
+	"types": "../out/client/index.d.ts"
+}

package/emit/package.json

@@ -0,0 +1,4 @@
+{
+	"main": "../out/emit/init.luau",
+	"types": "../out/emit/index.d.ts"
+}

package/out/all.d.ts

@@ -0,0 +1,7 @@
+export interface All<T extends object> {
+    size(): number;
+    has(item: T): boolean;
+    first(): T | undefined;
+    forEach(visit: (item: T) => void): void;
+    observe(added: (item: T) => void, removed?: (item: T) => void): () => void;
+}

package/out/all.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/out/attribute.d.ts

@@ -0,0 +1,7 @@
+type AttributeValue = string | number | boolean | Vector3 | Color3;
+export declare function attribute<T extends AttributeValue>(): T;
+export declare function attribute(fallback: number): number;
+export declare function attribute(fallback: string): string;
+export declare function attribute(fallback: boolean): boolean;
+export declare function attribute<T extends AttributeValue | undefined>(fallback: T): T;
+export {};

package/out/attribute.luau

@@ -0,0 +1,7 @@
+-- Compiled with roblox-ts v3.0.0
+local function attribute(_fallback)
+	error("attribute() was not replaced; add the Crucible transformer to the compiler plugins")
+end
+return {
+	attribute = attribute,
+}

package/out/client/index.d.ts

@@ -0,0 +1,3 @@
+import type { BootOptions } from "../index";
+export declare const BOOTED_ATTRIBUTE = "CrucibleBooted";
+export declare function boot(options: BootOptions): void;

package/out/client/init.luau

@@ -0,0 +1,20 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootSide = TS.import(script, script.Parent, "internal", "boot").boot
+if not game:GetService("RunService"):IsClient() then
+	error("@trioforge/crucible/client loaded on the server")
+end
+local BOOTED_ATTRIBUTE = "CrucibleBooted"
+local function boot(options)
+	bootSide({
+		name = "client",
+		renders = true,
+		booted = function()
+			return game:GetService("Players").LocalPlayer:SetAttribute(BOOTED_ATTRIBUTE, true)
+		end,
+	}, options)
+end
+return {
+	boot = boot,
+	BOOTED_ATTRIBUTE = BOOTED_ATTRIBUTE,
+}

package/out/crucible-behaviour.d.ts

@@ -0,0 +1,16 @@
+import { CrucibleObject } from "./crucible-object";
+export type BehaviourClass<T extends CrucibleBehaviour<string>> = new (...args: never[]) => T;
+export declare abstract class CrucibleBehaviour<Tag extends string, I extends Instance = Instance> extends CrucibleObject {
+    static accepts(instance: Instance): boolean;
+    static refresh(instance: Instance): void;
+    static get<T extends CrucibleBehaviour<string>>(this: BehaviourClass<T>, instance: Instance): T | undefined;
+    readonly instance: I;
+    readonly tag: Tag;
+    constructor();
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    remove(): void;
+    protected onEnable(): void;
+    protected onDisable(): void;
+    protected onDestroy(): void;
+}

package/out/crucible-behaviour.luau

@@ -0,0 +1,78 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local CrucibleObject = TS.import(script, script.Parent, "crucible-object").CrucibleObject
+local _binding = TS.import(script, script.Parent, "internal", "binding")
+local boundTo = _binding.boundTo
+local defaultAccepts = _binding.defaultAccepts
+local refresh = _binding.refresh
+local remove = _binding.remove
+local readClaim = TS.import(script, script.Parent, "internal", "construction-claim").readClaim
+local installBehaviourHooks = TS.import(script, script.Parent, "internal", "hooks").installBehaviourHooks
+local _lifecycle = TS.import(script, script.Parent, "internal", "lifecycle")
+local isLive = _lifecycle.isLive
+local request = _lifecycle.request
+local stateOf = _lifecycle.stateOf
+local CrucibleBehaviour
+do
+	local super = CrucibleObject
+	CrucibleBehaviour = setmetatable({}, {
+		__tostring = function()
+			return "CrucibleBehaviour"
+		end,
+		__index = super,
+	})
+	CrucibleBehaviour.__index = CrucibleBehaviour
+	function CrucibleBehaviour:constructor()
+		super.constructor(self)
+		local state = readClaim() or error("CrucibleBehaviour constructed outside Crucible")
+		self.instance = state.instance
+	end
+	function CrucibleBehaviour:accepts(instance)
+		return defaultAccepts(instance)
+	end
+	function CrucibleBehaviour:refresh(instance)
+		refresh(instance)
+	end
+	function CrucibleBehaviour:get(instance)
+		local state = boundTo(self, instance)
+		return if state ~= nil and isLive(state) then (state.object) else nil
+	end
+	function CrucibleBehaviour:isEnabled()
+		local state = stateOf(self)
+		return state ~= nil and state.phase == 3 and isLive(state)
+	end
+	function CrucibleBehaviour:setEnabled(enabled)
+		local state = stateOf(self)
+		if state ~= nil then
+			request(state, if enabled then 0 else 1)
+		end
+	end
+	function CrucibleBehaviour:remove()
+		local state = stateOf(self)
+		if state ~= nil then
+			remove(state)
+		end
+	end
+	function CrucibleBehaviour:onEnable()
+	end
+	function CrucibleBehaviour:onDisable()
+	end
+	function CrucibleBehaviour:onDestroy()
+	end
+	do
+		installBehaviourHooks({
+			onEnable = function(b)
+				return b:onEnable()
+			end,
+			onDisable = function(b)
+				return b:onDisable()
+			end,
+			onDestroy = function(b)
+				return b:onDestroy()
+			end,
+		})
+	end
+end
+return {
+	CrucibleBehaviour = CrucibleBehaviour,
+}

package/out/crucible-object.d.ts

@@ -0,0 +1,10 @@
+export declare abstract class CrucibleObject {
+    static readonly renderPriority?: number;
+    constructor();
+    protected awake(): void;
+    protected start(): void;
+    protected fixedUpdate(_dt: number): void;
+    protected update(_dt: number): void;
+    protected lateUpdate(_dt: number): void;
+    protected preRender(_dt: number): void;
+}

package/out/crucible-object.luau

@@ -0,0 +1,69 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local readClaim = TS.import(script, script.Parent, "internal", "construction-claim").readClaim
+local _hooks = TS.import(script, script.Parent, "internal", "hooks")
+local FRAME_HOOK_NAMES = _hooks.FRAME_HOOK_NAMES
+local installObjectHooks = _hooks.installObjectHooks
+local CrucibleObject
+do
+	CrucibleObject = {}
+	function CrucibleObject:constructor()
+		local state = readClaim() or error("CrucibleObject constructed outside Crucible")
+		state.object = self
+	end
+	function CrucibleObject:awake()
+	end
+	function CrucibleObject:start()
+	end
+	function CrucibleObject:fixedUpdate(_dt)
+	end
+	function CrucibleObject:update(_dt)
+	end
+	function CrucibleObject:lateUpdate(_dt)
+	end
+	function CrucibleObject:preRender(_dt)
+	end
+	do
+		installObjectHooks({
+			awake = function(o)
+				return o:awake()
+			end,
+			start = function(o)
+				return o:start()
+			end,
+			frame = {
+				[0] = function(o, dt)
+					return o:preRender(dt)
+				end,
+				[1] = function(o, dt)
+					return o:fixedUpdate(dt)
+				end,
+				[2] = function(o, dt)
+					return o:update(dt)
+				end,
+				[3] = function(o, dt)
+					return o:lateUpdate(dt)
+				end,
+			},
+			overrides = function(klass)
+				local methods = klass
+				local defaults = CrucibleObject
+				local mask = 0
+				-- ▼ ReadonlyArray.forEach ▼
+				local _callback = function(name, hook)
+					if methods[name] ~= defaults[name] then
+						mask = bit32.bor(mask, bit32.lshift(1, hook))
+					end
+				end
+				for _k, _v in FRAME_HOOK_NAMES do
+					_callback(_v, _k - 1, FRAME_HOOK_NAMES)
+				end
+				-- ▲ ReadonlyArray.forEach ▲
+				return mask
+			end,
+		})
+	end
+end
+return {
+	CrucibleObject = CrucibleObject,
+}

package/out/emit/index.d.ts

@@ -0,0 +1,41 @@
+import type { All } from "../all";
+import type { CrucibleObject } from "../crucible-object";
+export type EmittedDep = string | {
+    readonly all: string;
+};
+interface EmittedBase {
+    readonly id: string;
+    readonly deps: readonly EmittedDep[];
+    readonly provides: readonly string[];
+}
+export type EmittedClass = (EmittedBase & {
+    readonly kind: "subsystem";
+}) | (EmittedBase & {
+    readonly kind: "behaviour";
+    readonly tag: string;
+    readonly instance: readonly (keyof Instances)[];
+    readonly attributes?: {
+        readonly [field: string]: EmittedAttribute;
+    };
+});
+export type Check = (value: unknown) => boolean;
+export declare function defineClass(klass: new (...args: never[]) => CrucibleObject, emitted: EmittedClass): void;
+export declare function resolve<T extends object>(id: string): T;
+export declare function resolveAll<T extends object>(id: string): All<T>;
+export declare const t: {
+    readonly string: Check;
+    readonly number: Check;
+    readonly boolean: Check;
+    readonly vector3: Check;
+    readonly color3: Check;
+    readonly literal: (expected: string | number | boolean) => Check;
+    readonly optional: (check: Check) => Check;
+    readonly union: (...checks: Check[]) => Check;
+};
+export interface EmittedAttribute {
+    readonly name: string;
+    readonly check: Check;
+    readonly required: boolean;
+}
+export declare function attribute<T>(object: object, field: string, fallback?: T): T;
+export {};

package/out/emit/init.luau

@@ -0,0 +1,85 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local readClaim = TS.import(script, script.Parent, "internal", "construction-claim").readClaim
+local _registry = TS.import(script, script.Parent, "internal", "registry")
+local define = _registry.define
+local resolveOne = _registry.resolveOne
+local setFor = _registry.setFor
+local function defineClass(klass, emitted)
+	define(klass, emitted)
+end
+local function resolve(id)
+	return resolveOne(id)
+end
+local function resolveAll(id)
+	return setFor(id)
+end
+local t = {
+	string = (function(value)
+		local _value = value
+		return type(_value) == "string"
+	end),
+	number = (function(value)
+		local _value = value
+		return type(_value) == "number"
+	end),
+	boolean = (function(value)
+		local _value = value
+		return type(_value) == "boolean"
+	end),
+	vector3 = (function(value)
+		local _value = value
+		return typeof(_value) == "Vector3"
+	end),
+	color3 = (function(value)
+		local _value = value
+		return typeof(_value) == "Color3"
+	end),
+	literal = function(expected)
+		return function(value)
+			return value == expected
+		end
+	end,
+	optional = function(check)
+		return function(value)
+			return value == nil or check(value)
+		end
+	end,
+	union = function(...)
+		local checks = { ... }
+		return function(value)
+			-- ▼ ReadonlyArray.some ▼
+			local _result = false
+			local _callback = function(check)
+				return check(value)
+			end
+			for _k, _v in checks do
+				if _callback(_v, _k - 1, checks) then
+					_result = true
+					break
+				end
+			end
+			-- ▲ ReadonlyArray.some ▲
+			return _result
+		end
+	end,
+}
+local function attribute(object, field, fallback)
+	local claim = readClaim()
+	if claim == nil or claim.object ~= object then
+		error("attribute read outside construction claim")
+	end
+	local _value = claim.attributes
+	if _value ~= nil then
+		_value = _value[field]
+	end
+	local value = _value
+	return if value == nil then fallback else value
+end
+return {
+	defineClass = defineClass,
+	resolve = resolve,
+	resolveAll = resolveAll,
+	attribute = attribute,
+	t = t,
+}

package/out/index.d.ts

@@ -0,0 +1,12 @@
+export { Subsystem } from "./subsystem";
+export type { CrucibleObject } from "./crucible-object";
+export type { All } from "./all";
+export { inject } from "./inject";
+export { attribute } from "./attribute";
+export { CrucibleBehaviour, type BehaviourClass } from "./crucible-behaviour";
+export interface BootOptions {
+    readonly load: readonly string[];
+    readonly fixedRate?: number;
+}
+export { Logging, LogLevel } from "./logging";
+export type { Logger, LogRecord, LogSink, SinkSubscription, LogContext, LogProperties } from "./logging";

package/out/init.luau

@@ -0,0 +1,11 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+exports.Subsystem = TS.import(script, script, "subsystem").Subsystem
+exports.inject = TS.import(script, script, "inject").inject
+exports.attribute = TS.import(script, script, "attribute").attribute
+exports.CrucibleBehaviour = TS.import(script, script, "crucible-behaviour").CrucibleBehaviour
+local _logging = TS.import(script, script, "logging")
+exports.Logging = _logging.Logging
+exports.LogLevel = _logging.LogLevel
+return exports

package/out/inject.d.ts

@@ -0,0 +1 @@
+export declare function inject<T extends object>(): T;

package/out/inject.luau

@@ -0,0 +1,7 @@
+-- Compiled with roblox-ts v3.0.0
+local function inject()
+	error("inject<T>() was not replaced; add the Crucible transformer to the compiler plugins")
+end
+return {
+	inject = inject,
+}

package/out/internal/binding.d.ts

@@ -0,0 +1 @@
+export {};