@rbxts/replecs 0.1.0-alpha9 → 0.2.0-cdtest.2

package/out/replecs/common.luau

@@ -1,52 +1,69 @@
 local jecs = require "../jecs"
+local customid = require "./customid"
+
+export type FunctionFilter = (player: Player) -> boolean
+export type AnyFilter = PlayerFilter | Player
+type Entity<T = any> = jecs.Entity<T>
 
 export type PlayerFilter = {
 	[Player]: boolean,
 }
 
+export type SharedInfo<T> = {
+	lookup: { [string]: T },
+	keys: { string },
+	indexes: { [number]: T },
+	members: { [T]: number },
+}
+export type HandshakeInfo = {
+	components: { [string]: boolean },
+	custom_ids: { [string]: boolean },
+	serdes: { [string]: {
+		includes_variants: boolean?,
+		bytespan: number?,
+	} },
+}
+
 export type Serdes = {
 	includes_variants: boolean?,
+	bytespan: number?,
 	serialize: (value: any) -> (buffer, { any }?),
 	deserialize: (buffer, { any }?) -> any,
 }
 
 export type Components = {
-	shared: jecs.Entity,
-	networked: jecs.Entity<PlayerFilter?>,
-	reliable: jecs.Entity,
-	unreliable: jecs.Entity,
-	pair: jecs.Entity,
-
-	serdes: jecs.Entity<Serdes>,
-	bytespan: jecs.Entity<number>,
-	custom: jecs.Entity,
-	custom_handler: jecs.Entity<(value: any) -> jecs.Entity>,
-	global: jecs.Entity<number>,
-	__alive_tracking__: jecs.Entity,
+	shared: Entity,
+	networked: Entity<AnyFilter?>,
+	reliable: Entity<AnyFilter?>,
+	unreliable: Entity<AnyFilter?>,
+	pair: Entity<AnyFilter?>,
+
+	serdes: Entity<Serdes>,
+	custom: Entity,
+	custom_handler: Entity<(val: any) -> Entity?>,
+	global: Entity<number>,
+	__alive_tracking__: Entity,
 }
 
 export type Shared = {
-	lookup: { [string]: jecs.Entity },
-
-	components: { [number]: jecs.Entity },
-	ids: { [jecs.Entity]: number },
+	components: SharedInfo<Entity>,
+	custom_ids: SharedInfo<customid.CustomId>,
 
-	bytespan: { [jecs.Entity]: number },
-	serdes: { [jecs.Entity]: Serdes },
+	serdes: { [Entity]: Serdes },
 }
 
 export type WorldHooks = {
 	added: (
 		world: jecs.World,
-		component: jecs.Entity,
-		fn: (entity: jecs.Entity, id: jecs.Id, value: any) -> ()
+		component: Entity,
+		fn: (entity: Entity, id: jecs.Id, value: any) -> ()
 	) -> () -> (),
 	changed: (
 		world: jecs.World,
-		component: jecs.Entity,
-		fn: (entity: jecs.Entity, id: jecs.Id, value: any) -> ()
+		component: Entity,
+		fn: (entity: Entity, id: jecs.Id, value: any) -> ()
 	) -> () -> (),
-	removed: (world: jecs.World, component: jecs.Entity, fn: (entity: jecs.Entity, id: jecs.Id) -> ()) -> () -> (),
+	removed: (world: jecs.World, component: Entity, fn: (entity: Entity, id: jecs.Id) -> ()) -> () -> (),
 }
 
 return nil

package/out/replecs/customid.luau

@@ -0,0 +1,39 @@
+local jecs = require "../jecs"
+
+type Entity<T = any> = jecs.Entity<T>
+type Id<T = any> = jecs.Id<T>
+type World = jecs.World
+
+export type HandleContext = {
+	entity_id: number,
+	component: <T>(component: Entity<T>) -> T,
+	target: (relation: jecs.Id, index: number?) -> Entity?,
+	pair_value: <T>(relation: jecs.Id<T>, target: Entity) -> T?,
+	has_pair: (relation: jecs.Id, target: Entity) -> boolean,
+
+	entity: (server_entity: number) -> Entity,
+	has: (tag: Entity) -> boolean,
+}
+
+export type CustomId = {
+	identifier: string,
+	handle_callback: ((ctx: HandleContext) -> Entity?)?,
+
+	handle: (self: CustomId, handler: (ctx: HandleContext) -> Entity?) -> (),
+}
+
+local custom_id = {}
+
+function custom_id.handle(custom: CustomId, callback: (ctx: HandleContext) -> Entity?)
+	custom.handle_callback = callback
+end
+
+function create(identifier: string, callback: ((ctx: HandleContext) -> Entity?)?): CustomId
+	local handler = {} :: CustomId
+	handler.identifier = identifier
+	handler.handle_callback = callback
+
+	return setmetatable(handler, custom_id) :: any
+end
+
+return { create = create }

package/out/replecs/index.d.ts

@@ -3,11 +3,13 @@ import type { Entity, Id, Pair, Tag, World } from "@rbxts/jecs";
 declare namespace Replecs {
    export type SerdesTable =
       | {
+           bytespan?: number;
            includes_variants?: false;
            serialize: (value: any) => buffer;
            deserialize: (buffer: buffer) => any;
         }
       | {
+           bytespan?: number;
            includes_variants: true;
            serialize: (value: any) => LuaTuple<[buffer, defined[] | undefined]>;
            deserialize: (buffer: buffer, blobs: defined[] | undefined) => any;
@@ -17,11 +19,41 @@ declare namespace Replecs {
    type MemberFilter = Player | MemberFilterMap | undefined;
    type Member = unknown;
 
-   interface MaskingController {
-      register_member(member: Member): void;
-      unregister_member(member: Member): void;
-      active_member(member: Member): void;
-      member_is_active(member: Member): boolean;
+   export interface SharedInfo<T> {
+      lookup: Record<string, T>;
+      keys: string[];
+      indexes: [T];
+      members: Map<T, number>;
+   }
+   export interface HandleContext {
+      entity_id: number;
+      component: <T>(component: Entity<T>) => T;
+      target: (relation: Id, index?: number) => Entity | undefined;
+      pair_value: <T>(relation: Id<T>, target: Entity) => T | undefined;
+      has_pair: (relation: Id, target: Entity) => boolean;
+
+      entity: (server_entity: number) => Entity | undefined;
+      has: (tag: Entity) => boolean;
+   }
+   export interface CustomId {
+      identifier: string;
+      handle_callback: (ctx: HandleContext) => Entity;
+      handle(handler: (ctx: HandleContext) => Entity): void;
+   }
+
+   export interface Shared {
+      components: SharedInfo<Entity>;
+      custom_ids: SharedInfo<CustomId>;
+   }
+   interface HandshakeSerdesInfo {
+      includes_variants?: boolean;
+      bytespan?: number;
+   }
+
+   export interface HandshakeInfo {
+      components: Record<string, boolean>;
+      custom_ids: Record<string, boolean>;
+      serdes: Record<string, HandshakeSerdesInfo>;
    }
 
    export interface Components {
@@ -32,7 +64,6 @@ declare namespace Replecs {
       pair: Entity<MemberFilter>;
 
       serdes: Entity<SerdesTable>;
-      bytespan: Entity<number>;
       custom: Entity;
       custom_handler: Entity<(value: any) => Entity>;
       global: Entity<number>;
@@ -44,7 +75,6 @@ declare namespace Replecs {
       Pair: Entity<MemberFilter>;
 
       Serdes: Entity<SerdesTable>;
-      Bytespan: Entity<number>;
       Custom: Entity;
       CustomHandler: Entity<(value: any) => Entity>;
       Global: Entity<number>;
@@ -54,13 +84,25 @@ declare namespace Replecs {
       world: World;
       inited?: boolean;
 
+      is_relicating: boolean;
+      after_relication_callbacks: [() => void];
+
+      components: Components;
+
       init(world?: World): void;
       destroy(): void;
 
       handle_global(handler: (id: number) => Entity): void;
 
+      get_server_entity(client_entity: Entity): number | undefined;
+      get_client_entity(server_entity: number): Entity | undefined;
+
+      register_entity(entity: Entity, server_entity: number): void;
+      unregister_entity(entity: Entity): void;
+
       after_replication(callback: () => void): void;
       added(callback: (entity: Entity) => void): () => void;
+
       hook<T>(
          action: "changed",
          relation: Pair<MemberFilter, T>,
@@ -95,22 +137,67 @@ declare namespace Replecs {
 
       encode_component(component: Entity): number;
       decode_component(encoded: number): Entity;
-
-      get_server_entity(client_entity: Entity): number | undefined;
-      get_client_entity(server_entity: number): Entity | undefined;
+      register_custom_id(custom_id: CustomId): void;
 
       apply_updates(buf: buffer, all_variants?: unknown[][]): void;
       apply_unreliable(buf: buffer, all_variants?: unknown[][]): void;
       apply_full(buf: buffer, all_variants?: unknown[][]): void;
+
+      generate_handshake(): HandshakeInfo;
+      verify_handshake(
+         handshake: HandshakeInfo
+      ): LuaTuple<[true]> | LuaTuple<[false, string]>;
    }
 
-   export interface Server {
+   export interface ServerImp {
+      set_networked(
+         server: Server,
+         entity: Entity,
+         filter?: MemberFilter
+      ): void;
+      stop_networked(server: Server, entity: Entity): void;
+
+      set_reliable(
+         server: Server,
+         entity: Entity,
+         component: Entity,
+         filter?: MemberFilter
+      ): void;
+      set_unreliable(
+         server: Server,
+         entity: Entity,
+         component: Entity,
+         filter?: MemberFilter
+      ): void;
+      set_pair(
+         server: Server,
+         entity: Entity,
+         relation: Entity,
+         filter?: MemberFilter
+      ): void;
+      set_custom(
+         server: Server,
+         entity: Entity,
+         handler: Entity | CustomId
+      ): void;
+
+      stop_reliable(server: Server, entity: Entity, component: Entity): void;
+      stop_unreliable(server: Server, entity: Entity, component: Entity): void;
+      stop_pair(server: Server, entity: Entity, relation: Entity): void;
+      remove_custom(server: Server, entity: Entity): void;
+   }
+
+   export interface Server extends ServerImp {
       world: World;
       inited?: boolean;
 
       init(world?: World): void;
       destroy(): void;
 
+      encode_component(component: Entity): number;
+      decode_component(encoded: number): Entity;
+      register_custom_id(custom_id: CustomId): void;
+
       get_full(player: Player): LuaTuple<[buffer, unknown[][]]>;
       collect_updates(): IterableFunction<
          LuaTuple<[Player, buffer, unknown[][]]>
@@ -119,16 +206,16 @@ declare namespace Replecs {
          LuaTuple<[Player, buffer, unknown[][]]>
       >;
 
-      encode_component(component: Entity): number;
-      decode_component(encoded: number): Entity;
-
       mark_player_ready(player: Player): void;
       is_player_ready(player: Player): boolean;
 
       add_player_alias(client: Player, alias: defined): void;
       remove_player_alias(alias: defined): void;
 
-      masking: MaskingController;
+      generate_handshake(): HandshakeInfo;
+      verify_handshake(
+         handshake: HandshakeInfo
+      ): LuaTuple<[true]> | LuaTuple<[false, string]>;
    }
 
    export interface ReplecsLib {
@@ -136,12 +223,19 @@ declare namespace Replecs {
       server: Server;
 
       after_replication(callback: () => void): void;
+      register_custom_id(custom_id: CustomId): void;
    }
 
    export interface Replecs extends Components {
+      VERSION: string;
+
       create: (world?: World) => ReplecsLib;
       create_server: (world?: World) => Server;
       create_client: (world?: World) => Client;
+      create_custom_id: (
+         identifier: string,
+         handler?: (ctx: HandleContext) => Entity
+      ) => CustomId;
    }
 }
 

package/out/replecs/init.luau

@@ -3,15 +3,32 @@ local common = require "@self/common"
 
 local client = require "@self/client"
 local server = require "@self/server"
+local customid = require "@self/customid"
+local VERSION = require "@self/ver"
 
 export type Server = server.Server
 export type Client = client.Client
 
+export type HandleContext = customid.HandleContext
+export type CustomId = customid.CustomId
+export type HandshakeInfo = common.HandshakeInfo
+
+type Entity = jecs.Entity
+
 export type ReplecsLib = {
 	server: Server,
 	client: Client,
 
 	after_replication: (self: ReplecsLib, callback: () -> ()) -> (),
+	register_custom_id: (self: ReplecsLib, custom_id: CustomId) -> (),
+}
+
+type Replecs = common.Components & {
+	create: (world: jecs.World?) -> ReplecsLib,
+
+	create_server: (world: jecs.World?) -> Server,
+	create_client: (world: jecs.World?) -> Client,
+	create_custom_id: (identifier: string, handler: (ctx: HandleContext) -> Entity?) -> CustomId,
 }
 
 type MemberFilter = {
@@ -19,23 +36,22 @@ type MemberFilter = {
 }
 
 local replecs = {
+	VERSION = VERSION,
 	shared = jecs.tag(),
-	networked = jecs.component() :: jecs.Entity<(MemberFilter | Player)?>,
-	reliable = jecs.component() :: jecs.Entity<(MemberFilter | Player)?>,
-	unreliable = jecs.component() :: jecs.Entity<(MemberFilter | Player)?>,
-	pair = jecs.component() :: jecs.Entity<(MemberFilter | Player)?>,
-
-	serdes = jecs.component() :: jecs.Entity<common.Serdes>,
-	bytespan = jecs.component() :: jecs.Entity<number>,
-	custom = jecs.tag() :: jecs.Entity,
-	custom_handler = jecs.component() :: jecs.Entity<(any) -> jecs.Entity>,
-	global = jecs.component() :: jecs.Entity<number>,
+	networked = jecs.component(),
+	reliable = jecs.component(),
+	unreliable = jecs.component(),
+	pair = jecs.component(),
+
+	serdes = jecs.component(),
+	custom = jecs.tag(),
+	custom_handler = jecs.component(),
+	global = jecs.component(),
 	__alive_tracking__ = jecs.tag(),
 }
 
 replecs.__index = replecs
 replecs.Serdes = replecs.serdes
-replecs.Bytespan = replecs.bytespan
 replecs.Custom = replecs.custom
 replecs.CustomHandler = replecs.custom_handler
 replecs.Networked = replecs.networked
@@ -46,7 +62,6 @@ replecs.Shared = replecs.shared
 replecs.Global = replecs.global
 
 jecs.meta(replecs.serdes, jecs.Name, "replecs.serdes")
-jecs.meta(replecs.bytespan, jecs.Name, "replecs.bytespan")
 jecs.meta(replecs.custom, jecs.Name, "replecs.custom")
 jecs.meta(replecs.custom_handler, jecs.Name, "replecs.custom_handler")
 jecs.meta(replecs.networked, jecs.Name, "replecs.networked")
@@ -62,11 +77,11 @@ jecs.meta(replecs.custom, jecs.Exclusive)
 jecs.meta(replecs.global, jecs.Exclusive)
 
 function replecs.create_server(world: jecs.World?): Server
-	return server.create(world, replecs)
+	return server.create(world, replecs :: Replecs)
 end
 
 function replecs.create_client(world: jecs.World?): Client
-	return client.create(world, replecs)
+	return client.create(world, replecs :: Replecs)
 end
 
 function replecs.create(world: jecs.World?): ReplecsLib
@@ -76,15 +91,19 @@ function replecs.create(world: jecs.World?): ReplecsLib
 	local lib = {} :: ReplecsLib
 
 	if RunService:IsServer() then
-		lib.server = server.create(world, replecs)
+		lib.server = server.create(world, replecs :: Replecs)
 	end
 	if RunService:IsClient() then
-		lib.client = client.create(world, replecs)
+		lib.client = client.create(world, replecs :: Replecs)
 	end
 
 	return setmetatable(lib, replecs) :: any
 end
 
+function replecs.create_custom_id(identifier: string, handler: (ctx: HandleContext) -> Entity?)
+	return customid.create(identifier, handler)
+end
+
 function replecs.after_replication(lib: ReplecsLib, callback: () -> ())
 	local lib_client = lib.client
 	if lib_client then
@@ -94,4 +113,13 @@ function replecs.after_replication(lib: ReplecsLib, callback: () -> ())
 	end
 end
 
-return replecs
+function replecs.register_custom_id(lib: ReplecsLib, custom_id: CustomId)
+	if lib.server then
+		lib.server:register_custom_id(custom_id)
+	end
+	if lib.client then
+		lib.client:register_custom_id(custom_id)
+	end
+end
+
+return replecs :: Replecs

package/out/replecs/masking/init.luau

@@ -163,8 +163,8 @@ export type MaskingController = {
 
 	propagate_entity_addition: (self: MaskingController, entity: Entity) -> (),
 
-	start_entity: (self: MaskingController, entity: Entity, filter: MemberFilter?) -> (),
-	set_entity: (self: MaskingController, entity: Entity, filter: MemberFilter?) -> (),
+	start_entity: (self: MaskingController, entity: Entity, filter: GivenFilter?) -> (),
+	set_entity: (self: MaskingController, entity: Entity, filter: GivenFilter?) -> (),
 	stop_entity: (self: MaskingController, entity: Entity) -> (),
 	cleanup_entity: (self: MaskingController, entity: Entity) -> (),
 
@@ -173,14 +173,14 @@ export type MaskingController = {
 		entity: Entity,
 		component: Entity,
 		component_type: number,
-		filter: MemberFilter?
+		filter: GivenFilter?
 	) -> (),
 	set_component: (
 		self: MaskingController,
 		entity: Entity,
 		component: Entity,
 		component_type: number,
-		filter: MemberFilter?
+		filter: GivenFilter?
 	) -> (),
 	stop_component: (self: MaskingController, entity: Entity, component: Entity, component_type: number) -> (),
 
@@ -235,7 +235,7 @@ end
 local function get_usable_filter(filter: (MemberFilter | any)?): MemberFilter?
 	if filter then
 		if type(filter) == "table" then
-			return filter
+			return filter :: MemberFilter
 		else
 			return { [filter] = true }
 		end
@@ -709,23 +709,24 @@ function masking_controller.move_component_storage(
 	local component_added =
 		get_component_index_entry(storage.changes.added_components, entity, component, component_type)
 	if component_added then
+		remove_component_index_entry(target_storage.changes.added_components, entity, component, component_type)
 		set_component_index_entry(target_storage.changes.added_components, entity, component, component_type, true)
 	end
 
 	local changes = storage.changes.changed[entity]
 	if changes then
 		local target_changes = get_or_set_changed(target_storage, entity)
-		if component_type == COMPONENT_TYPES.component then
-			target_changes.component[component] = changes.component[component]
+		if component_type == COMPONENT_TYPES.tag then
+			target_changes.tagged[component] = changes.tagged[component]
 			target_changes.removed[component] = changes.removed[component]
 
-			changes.component[component] = nil
+			changes.tagged[component] = nil
 			changes.removed[component] = nil
-		elseif component_type == COMPONENT_TYPES.tag then
-			target_changes.tagged[component] = changes.tagged[component]
+		elseif component_type == COMPONENT_TYPES.component then
+			target_changes.component[component] = changes.component[component]
 			target_changes.removed[component] = changes.removed[component]
 
-			changes.tagged[component] = nil
+			changes.component[component] = nil
 			changes.removed[component] = nil
 		elseif component_type == COMPONENT_TYPES.pair then
 			target_changes.pairs[component] = changes.pairs[component]
@@ -742,8 +743,6 @@ function masking_controller.move_component_storage(
 		end
 	end
 
-	--todo: move changes
-
 	return target_storage
 end
 
@@ -826,7 +825,6 @@ function masking_controller.register_stop_entity(masking: MaskingInternal, entit
 		return
 	end
 	storage.deletions.entities[entity] = true
-	storage.deletions_count += 1
 end
 
 function masking_controller.register_stop_component(
@@ -845,13 +843,11 @@ function masking_controller.register_stop_component(
 		deletions = create_component_indexes() :: ComponentIndex<boolean>
 		deletions[component_type][component] = true
 		storage.deletions.components[entity] = deletions
-		storage.deletions_count += 1
 	else
 		if deletions[component_type][component] then
 			return
 		end
 		deletions[component_type][component] = true
-		storage.deletions_count += 1
 	end
 end
 
@@ -896,7 +892,6 @@ function masking_controller.unregister_stop_component(
 	if deletions then
 		if deletions[component_type][component] then
 			deletions[component_type][component] = nil
-			storage.deletions_count -= 1
 		end
 	end
 end
@@ -1017,6 +1012,7 @@ function masking_controller.stop_entity(masking: MaskingInternal, entity: Entity
 			component_storage.shared_with[entity] = nil
 			component_storage.changes.added[entity] = nil
 			component_storage.changes.changed[entity] = nil
+			component_storage.changes.added_components[entity] = nil
 
 			if postponed == nil then
 				postponed = create_component_indexes() :: PostponedList
@@ -1039,6 +1035,7 @@ function masking_controller.stop_entity(masking: MaskingInternal, entity: Entity
 	remove_active(lookup.storage_group, entity)
 	lookup.storage_group.changes.added[entity] = nil
 	lookup.storage_group.changes.changed[entity] = nil
+	lookup.storage_group.changes.added_components[entity] = nil
 
 	masking.lookups.entities[entity] = nil
 end
@@ -1344,7 +1341,18 @@ end
 local function bitmask_from_set(masking: MaskingInternal, member_set: { [Member]: boolean }): utils.Bitmask
 	local new_bitmask = utils.bitmask.create(masking.member_count)
 	for member: Member in member_set do
-		local index = masking.member_indexes[member] or masking.member_indexes[masking.client_aliases[member]]
+		local index = masking.member_indexes[member]
+		if not index then
+			local alias = masking.member_indexes[masking.client_aliases[member]]
+			if alias then
+				if utils.is_client_valid(alias) then
+					index = alias
+				end
+			elseif utils.is_client_valid(member) then
+				masking_controller.register_client(masking, member)
+				index = masking.member_indexes[member]
+			end
+		end
 		if index then
 			new_bitmask:set(index)
 		end
@@ -1496,13 +1504,13 @@ function masking_controller.create_exclude_generator(masking: MaskingInternal, e
 	local bitmask = bitmask_from_set(masking, exclude)
 	local active_members = masking.active_members_generator
 
-	local generator = mask_generator.create(bitmask, function(generator)
-		local bitmask = generator.bitmask :: utils.Bitmask
-		return active_members.result:band(bitmask:bnot())
+	local new_generator = mask_generator.create(bitmask, function(generator)
+		local current = generator.bitmask :: utils.Bitmask
+		return active_members.result:band(current:bnot())
 	end)
-	generator:track(active_members)
+	new_generator:track(active_members)
 
-	return generator
+	return new_generator
 end
 
 -- TODO: check for players existing and register them if they don't
@@ -1510,13 +1518,13 @@ function masking_controller.create_include_generator(masking: MaskingInternal, i
 	local bitmask = bitmask_from_set(masking, include)
 	local active_members = masking.active_members_generator
 
-	local generator = mask_generator.create(bitmask, function(generator)
-		local bitmask = generator.bitmask :: utils.Bitmask
-		return bitmask:band(active_members.result)
+	local new_generator = mask_generator.create(bitmask, function(generator)
+		local current = generator.bitmask :: utils.Bitmask
+		return current:band(active_members.result)
 	end)
-	generator:track(active_members)
+	new_generator:track(active_members)
 
-	return generator
+	return new_generator
 end
 
 function masking_controller.create_all_members_generator(masking: MaskingInternal)
@@ -1544,9 +1552,9 @@ function masking_controller.create_active_generator(masking: MaskingController):
 	return new_generator
 end
 
-function masking_controller.register_mask_group(masking: MaskingInternal, group: Member) end
+--function masking_controller.register_mask_group(masking: MaskingInternal, group: Member) end
 
-function masking_controller.unregister_mask_group(masking: MaskingInternal, group: Member) end
+--function masking_controller.unregister_mask_group(masking: MaskingInternal, group: Member) end
 
 function masking_controller.register_client(masking: MaskingInternal, member: Member)
 	if masking.member_indexes[member] then
@@ -1575,16 +1583,12 @@ function masking_controller.unregister_client(masking: MaskingInternal, member:
 	end
 	masking.client_indexes[member] = nil
 	masking.member_indexes[member] = nil
-	masking.member_count -= 1
 	masking.all_members_generator.bitmask:clear(index)
 	masking.active_members_generator:compute()
 end
 
 function masking_controller.activate_client(masking: MaskingInternal, member: Member)
 	local index = masking.client_indexes[member]
-	if index == nil then
-		index = masking.client_indexes[member]
-	end
 
 	masking.unreplicated[member] = nil
 	masking.unactive_members_generator.bitmask:clear(index)

package/out/replecs/masking/mask_generator.luau

@@ -63,7 +63,7 @@ end
 
 function mask_generator.compute(generator: GeneratorInternal)
 	if generator.compute_callback then
-		local result = generator.compute_callback(generator :: GeneratorInternal)
+		local result: utils.Bitmask = generator.compute_callback(generator :: any)
 		generator.result = result
 	end
 	if generator.subscribed then