@hytopia.com/server-protocol 1.0.9 → 1.0.11

package/exports.ts

@@ -0,0 +1,7 @@
+import * as inboundPackets from './packets/inbound';
+import * as outboundPackets from './packets/outbound';
+
+export { inboundPackets, outboundPackets };
+export * from './packets/PacketCore';
+export * from './packets/PacketDefinitions';
+export * from './schemas';

package/index.ts

@@ -1,17 +1,3 @@
-import * as inboundPackets from './packets/inbound';
-import * as outboundPackets from './packets/outbound';
-import * as PacketCore from './packets/PacketCore';
-import * as schemas from './schemas';
-
-export { inboundPackets, outboundPackets };
-export * from './packets/inbound';
-export * from './packets/outbound';
-export * from './packets/PacketCore';
-export * from './schemas';
-
-export default {
-  inboundPackets,
-  outboundPackets,
-  ...PacketCore,
-  ...schemas,
-};
+import * as protocol from './exports';
+export * from './exports';
+export default protocol;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hytopia.com/server-protocol",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/packets/PacketCore.ts

@@ -17,7 +17,7 @@ import type { JSONSchemaType, ValidateFunction } from 'ajv';
  * in encoded format.
  */
 
-export enum PacketIds {
+export enum PacketId {
   // Standard Inbound Packet Types: 0 - 31 range
   HEARTBEAT = 0,
   INPUT = 1,
@@ -40,37 +40,41 @@ export enum PacketIds {
  * Generators for packet definitions and validators.
  */
 
-export interface IPacketDefinition<TId extends PacketIds, TSchema> {
+export interface IPacketDefinition<TId extends PacketId, TSchema> {
   id: TId;
   schema: JSONSchemaType<TSchema>;
   validate: ValidateFunction<TSchema>;
 }
 
-export interface IPacket<TId extends PacketIds, TSchema> {
-  id: TId;
-  payload: TSchema;
+export interface IPacket<TId extends PacketId, TSchema> {
+  i: TId;     // packet id
+  d: TSchema; // packet data
 }
 
-export type AnyPacket = IPacket<PacketIds, unknown>;
+export type AnyPacket = IPacket<PacketId, unknown>;
 
 export type AnyPacketDefinition = IPacketDefinition<number, unknown>;
 
-export const createPacket = <TId extends number, TSchema>(
+export function createPacket<TId extends number, TSchema>(
   packetDef: IPacketDefinition<TId, TSchema>,
-  payload: TSchema,
-): IPacket<TId, TSchema> => {
-  if (!packetDef.validate(payload)) {
+  data: TSchema,
+): IPacket<TId, TSchema> {
+  if (!packetDef.validate(data)) {
     throw new Error(`createPacket(): Invalid payload for packet with id ${packetDef.id}, error: ${Ajv.instance.errorsText(packetDef.validate.errors)}`);
   }
 
-  return { id: packetDef.id, payload };
+  return { i: packetDef.id, d: data };
 }
 
-export const definePacket = <TId extends PacketIds, TSchema>(
+export function definePacket<TId extends PacketId, TSchema>(
   id: TId,
   schema: JSONSchemaType<TSchema>,
-): IPacketDefinition<TId, TSchema> => ({
-  id,
-  schema,
-  validate: Ajv.instance.compile(schema),
-});
+): IPacketDefinition<TId, TSchema> {
+  return {
+    id,
+    schema,
+    validate: Ajv.instance.compile(schema),
+  };
+};
+
+

package/packets/PacketDefinitions.ts

@@ -0,0 +1,34 @@
+import * as inboundPackets from './inbound';
+import * as outboundPackets from './outbound';
+import type { PacketId, AnyPacket, AnyPacketDefinition } from './PacketCore';
+
+export const registeredPackets = new Map<PacketId, AnyPacketDefinition>();
+
+const allPackets = { ...inboundPackets, ...outboundPackets };
+
+for (const packet of Object.values(allPackets)) {
+  if ('id' in packet && 'schema' in packet) {
+    const definition = packet as AnyPacketDefinition;
+
+    if (registeredPackets.has(definition.id)) {
+      throw new Error(`Packet with id ${definition.id} is already registered.`);
+    }
+    
+    registeredPackets.set(definition.id, definition);
+  }
+}
+
+export function isValidPacket(packet: unknown): packet is AnyPacket {
+  if (
+    typeof packet !== 'object' || 
+    packet === null || 
+    !('i' in packet) || 
+    !('d' in packet) ||
+    typeof packet.i !== 'number'
+  ) {
+    return false;
+  }
+
+  const packetDef = registeredPackets.get(packet.i);
+  return !!packetDef && packetDef.validate(packet.d);
+}

package/packets/inbound/Heartbeat.ts

@@ -1,11 +1,11 @@
-import { definePacket, PacketIds } from '../PacketCore';
+import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { heartbeatSchema } from '../../schemas/Heartbeat';
-import type { Heartbeat } from '../../schemas/Heartbeat';
+import type { HeartbeatSchema } from '../../schemas/Heartbeat';
 
-export type HeartbeatPacket = IPacket<typeof PacketIds.HEARTBEAT, Heartbeat>;
+export type HeartbeatPacket = IPacket<typeof PacketId.HEARTBEAT, HeartbeatSchema>;
 
 export const heartbeatPacketDefinition = definePacket(
-  PacketIds.HEARTBEAT,
+  PacketId.HEARTBEAT,
   heartbeatSchema
 );

package/packets/inbound/Input.ts

@@ -1,11 +1,11 @@
-import { definePacket, PacketIds } from '../PacketCore';
+import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { inputSchema } from '../../schemas/Input';
-import type { Input } from '../../schemas/Input';
+import type { InputSchema } from '../../schemas/Input';
 
-export type InputPacket = IPacket<typeof PacketIds.INPUT, Input>;
+export type InputPacket = IPacket<typeof PacketId.INPUT, InputSchema>;
 
 export const inputPacketDefinition = definePacket(
-  PacketIds.INPUT,
+  PacketId.INPUT,
   inputSchema
 );

package/packets/outbound/Block.ts

@@ -1,11 +1,11 @@
-import { definePacket, PacketIds } from '../PacketCore';
+import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { blockSchema } from '../../schemas/Block';
-import type { Block } from '../../schemas/Block';
+import type { BlockSchema } from '../../schemas/Block';
 
-export type BlockPacket = IPacket<typeof PacketIds.BLOCK, Block>;
+export type BlockPacket = IPacket<typeof PacketId.BLOCK, BlockSchema>;
 
 export const blockPacketDefinition = definePacket(
-  PacketIds.BLOCK,
+  PacketId.BLOCK,
   blockSchema,
 );

package/packets/outbound/BlockRegistry.ts

@@ -1,11 +1,11 @@
-import { definePacket, PacketIds } from '../PacketCore';
+import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { blockRegistrySchema } from '../../schemas/BlockRegistry';
-import type { BlockRegistry } from '../../schemas/BlockRegistry';
+import type { BlockRegistrySchema } from '../../schemas/BlockRegistry';
 
-export type BlockRegistryPacket = IPacket<typeof PacketIds.BLOCK_REGISTRY, BlockRegistry>;
+export type BlockRegistryPacket = IPacket<typeof PacketId.BLOCK_REGISTRY, BlockRegistrySchema>;
 
 export const blockRegistryPacketDefinition = definePacket(
-  PacketIds.BLOCK_REGISTRY,
+  PacketId.BLOCK_REGISTRY,
   blockRegistrySchema,
 );

package/packets/outbound/BlockType.ts

@@ -1,11 +1,11 @@
-import { definePacket, PacketIds } from '../PacketCore';
+import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { blockTypeSchema } from '../../schemas/BlockType';
-import type { BlockType } from '../../schemas/BlockType';
+import type { BlockTypeSchema } from '../../schemas/BlockType';
 
-export type BlockTypePacket = IPacket<typeof PacketIds.BLOCK_TYPE, BlockType>;
+export type BlockTypePacket = IPacket<typeof PacketId.BLOCK_TYPE, BlockTypeSchema>;
 
 export const blockTypePacketDefinition = definePacket(
-  PacketIds.BLOCK_TYPE,
+  PacketId.BLOCK_TYPE,
   blockTypeSchema,
 );

package/packets/outbound/Chunk.ts

@@ -1,11 +1,11 @@
-import { definePacket, PacketIds } from '../PacketCore';
+import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { chunkSchema } from '../../schemas/Chunk';
-import type { Chunk } from '../../schemas/Chunk';
+import type { ChunkSchema } from '../../schemas/Chunk';
 
-export type ChunkPacket = IPacket<typeof PacketIds.CHUNK, Chunk>;
+export type ChunkPacket = IPacket<typeof PacketId.CHUNK, ChunkSchema>;
 
 export const chunkPacketDefinition = definePacket(
-  PacketIds.CHUNK,
+  PacketId.CHUNK,
   chunkSchema,
 );

package/packets/outbound/Entity.ts

@@ -1,11 +1,11 @@
-import { definePacket, PacketIds } from '../PacketCore';
+import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { entitySchema } from '../../schemas/Entity';
-import type { Entity } from '../../schemas/Entity';
+import type { EntitySchema } from '../../schemas/Entity';
 
-export type EntityPacket = IPacket<typeof PacketIds.ENTITY, Entity>;
+export type EntityPacket = IPacket<typeof PacketId.ENTITY, EntitySchema>;
 
 export const entityPacketDefinition = definePacket(
-  PacketIds.ENTITY,
+  PacketId.ENTITY,
   entitySchema,
 );

package/packets/outbound/PhysicsDebugRender.ts

@@ -1,11 +1,11 @@
-import { definePacket, PacketIds } from '../PacketCore';
+import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { physicsDebugRenderSchema } from '../../schemas/PhysicsDebugRender';
-import type { PhysicsDebugRender } from '../../schemas/PhysicsDebugRender';
+import type { PhysicsDebugRenderSchema } from '../../schemas/PhysicsDebugRender';
 
-export type PhysicsDebugRenderPacket = IPacket<typeof PacketIds.PHYSICS_DEBUG_RENDER, PhysicsDebugRender>;
+export type PhysicsDebugRenderPacket = IPacket<typeof PacketId.PHYSICS_DEBUG_RENDER, PhysicsDebugRenderSchema>;
 
 export const physicsDebugRenderPacketDefinition = definePacket(
-  PacketIds.PHYSICS_DEBUG_RENDER,
+  PacketId.PHYSICS_DEBUG_RENDER,
   physicsDebugRenderSchema,
 );

package/schemas/Block.ts

@@ -1,14 +1,14 @@
 import { vectorSchema } from './Vector';
 import type { JSONSchemaType } from 'ajv';
-import type { Vector } from './Vector';
+import type { VectorSchema } from './Vector';
 
-export type Block = {
-  wi: string; // world id
-  i: number;  // block id
-  c: Vector;  // coordinate
+export type BlockSchema = {
+  wi: string;       // world id
+  i: number;        // block id
+  c: VectorSchema;  // coordinate
 };
 
-export const blockSchema: JSONSchemaType<Block> = {
+export const blockSchema: JSONSchemaType<BlockSchema> = {
   type: 'object',
   properties: {
     wi: { type: 'string' },

package/schemas/BlockRegistry.ts

@@ -1,13 +1,13 @@
 import { blockTypeSchema } from './BlockType';
 import type { JSONSchemaType } from 'ajv';
-import type { BlockType } from './BlockType';
+import type { BlockTypeSchema } from './BlockType';
 
-export type BlockRegistry = {
-  wi: string;     // world id
-  b: BlockType[]; // block types
+export type BlockRegistrySchema = {
+  wi: string;           // world id
+  b: BlockTypeSchema[]; // block types
 }
 
-export const blockRegistrySchema: JSONSchemaType<BlockRegistry> = {
+export const blockRegistrySchema: JSONSchemaType<BlockRegistrySchema> = {
   type: 'object',
   properties: {
     wi: { type: 'string' },

package/schemas/BlockType.ts

@@ -1,18 +1,18 @@
 import { colliderDescSchema } from './ColliderDesc';
 import type { JSONSchemaType } from 'ajv';
-import type { ColliderDesc } from './ColliderDesc';
+import type { ColliderDescSchema } from './ColliderDesc';
 
-export type BlockType = {
-  wi: string;       // world id
-  i: number;        // block type id
-  d: boolean;       // delta
-  t?: string;       // textureUri
-  n?: string;       // name
-  c?: ColliderDesc; // collider desc
-  s?: boolean;      // is solid
+export type BlockTypeSchema = {
+  wi: string;             // world id
+  i: number;              // block type id
+  d: boolean;             // delta
+  t?: string;             // textureUri
+  n?: string;             // name
+  c?: ColliderDescSchema; // collider desc
+  s?: boolean;            // is solid
 }
 
-export const blockTypeSchema: JSONSchemaType<BlockType> = {
+export const blockTypeSchema: JSONSchemaType<BlockTypeSchema> = {
   type: 'object',
   properties: {
     wi: { type: 'string' },

package/schemas/Chunk.ts

@@ -1,14 +1,14 @@
 import { vectorSchema } from './Vector';
 import type { JSONSchemaType } from 'ajv';
-import type { Vector } from './Vector';
+import type { VectorSchema } from './Vector';
 
-export type Chunk = {
-  wi: string; // world id
-  c: Vector; // chunk coordinate [ 16n, 16n, 16n ]
+export type ChunkSchema = {
+  wi: string;               // world id
+  c: VectorSchema;          // chunk coordinate [ 16n, 16n, 16n ]
   b: Uint8Array | number[]; // block ids in chunk, 16^3 entries, registry block ids 1-255, 0 = none
 };
 
-export const chunkSchema: JSONSchemaType<Chunk> = {
+export const chunkSchema: JSONSchemaType<ChunkSchema> = {
   type: 'object',
   properties: {
     wi: { type: 'string' },

package/schemas/Collider.ts

@@ -1,12 +1,12 @@
 import { colliderDescSchema } from './ColliderDesc';
 import type { JSONSchemaType } from 'ajv';
-import type { ColliderDesc } from './ColliderDesc';
+import type { ColliderDescSchema } from './ColliderDesc';
 
-export type Collider = {
+export type ColliderSchema = {
   h?: number; // collider handle for rapier
-} & ColliderDesc;
+} & ColliderDescSchema;
 
-export const colliderSchema: JSONSchemaType<Collider> = {
+export const colliderSchema: JSONSchemaType<ColliderSchema> = {
   type: 'object',
   properties: {
     h: { type: 'number', nullable: true },

package/schemas/ColliderDesc.ts

@@ -2,29 +2,29 @@ import { shapeSchema } from './Shape';
 import { quaternionSchema } from './Quaternion';
 import { vectorSchema } from './Vector';
 import type { JSONSchemaType } from 'ajv';
-import type { Shape } from './Shape';
-import type { Quaternion } from './Quaternion';
-import type { Vector } from './Vector';
+import type { ShapeSchema } from './Shape';
+import type { QuaternionSchema } from './Quaternion';
+import type { VectorSchema } from './Vector';
 
-export type ColliderDesc = {
-  at?: number;    // active collision types
-  cg?: number;    // collision groups
-  cs?: number;    // contact skin
-  d?: number;     // density
-  f?: number;     // friction
-  fr?: number;    // friction combine rule
-  en?: boolean;   // enabled
-  sn?: boolean;   // sensor
-  m?: number;     // mass
-  re?: number;    // restitution
-  rer?: number;   // restitution combine rule
-  r?: Quaternion; // rotation
-  s?: Shape;      // shape
-  sg?: number;    // solver groups
-  t?: Vector;     // translation
+export type ColliderDescSchema = {
+  at?: number;          // active collision types
+  cg?: number;          // collision groups
+  cs?: number;          // contact skin
+  d?: number;           // density
+  f?: number;           // friction
+  fr?: number;          // friction combine rule
+  en?: boolean;         // enabled
+  sn?: boolean;         // sensor
+  m?: number;           // mass
+  re?: number;          // restitution
+  rer?: number;         // restitution combine rule
+  r?: QuaternionSchema; // rotation
+  s?: ShapeSchema;      // shape
+  sg?: number;          // solver groups
+  t?: VectorSchema;     // translation
 }
 
-export const colliderDescSchema: JSONSchemaType<ColliderDesc> = {
+export const colliderDescSchema: JSONSchemaType<ColliderDescSchema> = {
   type: 'object',
   properties: {
     at: { type: 'number', nullable: true },

package/schemas/Entity.ts

@@ -1,19 +1,19 @@
 import { rigidBodySchema } from './RigidBody';
 import type { JSONSchemaType } from 'ajv';
-import type { RigidBody } from './RigidBody';
+import type { RigidBodySchema } from './RigidBody';
 
-export type Entity = {
-  wi: string;    // world id
-  i: number;     // entity id
-  d: boolean;    // delta
-  f?: boolean;   // focused
-  n?: string;    // name
-  m?: string;    // model uri
-  t?: string;    // texture uri
-  r?: RigidBody; // rigid body
+export type EntitySchema = {
+  wi: string;          // world id
+  i: number;           // entity id
+  d: boolean;          // delta
+  f?: boolean;         // focused
+  n?: string;          // name
+  m?: string;          // model uri
+  t?: string;          // texture uri
+  r?: RigidBodySchema; // rigid body
 }
 
-export const entitySchema: JSONSchemaType<Entity> = {
+export const entitySchema: JSONSchemaType<EntitySchema> = {
   type: 'object',
   properties: {
     wi: { type: 'string' },

package/schemas/Heartbeat.ts

@@ -1,8 +1,8 @@
 import type { JSONSchemaType } from 'ajv';
 
-export type Heartbeat = null;
+export type HeartbeatSchema = null;
 
-export const heartbeatSchema: JSONSchemaType<Heartbeat> = {
+export const heartbeatSchema: JSONSchemaType<HeartbeatSchema> = {
   type: 'null',
   nullable: true,
 }

package/schemas/Input.ts

@@ -1,6 +1,6 @@
 import { JSONSchemaType } from 'ajv';
 
-export type Input = {
+export type InputSchema = {
   w?: boolean;  // w key pressed
   a?: boolean;  // a key pressed
   s?: boolean;  // s key pressed
@@ -15,7 +15,7 @@ export type Input = {
   cy?: number;  // camera yaw radians
 }
 
-export const inputSchema: JSONSchemaType<Input> = {
+export const inputSchema: JSONSchemaType<InputSchema> = {
   type: 'object',
   properties: {
     w: { type: 'boolean', nullable: true },

package/schemas/PhysicsDebugRender.ts

@@ -1,12 +1,12 @@
 import { JSONSchemaType } from 'ajv';
 
-export type PhysicsDebugRender = {
+export type PhysicsDebugRenderSchema = {
   wi: string;  // world id
   v: number[]; // rapier debug render vertices
   c: number[]; // rapier debug render colors
 }
 
-export const physicsDebugRenderSchema: JSONSchemaType<PhysicsDebugRender> = {
+export const physicsDebugRenderSchema: JSONSchemaType<PhysicsDebugRenderSchema> = {
   type: 'object',
   properties: {
     wi: { type: 'string' },

package/schemas/Quaternion.ts

@@ -1,13 +1,13 @@
 import type { JSONSchemaType } from 'ajv';
 
-export type Quaternion = [
+export type QuaternionSchema = [
   number, // x
   number, // y
   number, // z
   number, // w
 ];
 
-export const quaternionSchema: JSONSchemaType<Quaternion> = {
+export const quaternionSchema: JSONSchemaType<QuaternionSchema> = {
   type: 'array',
   items: [
     { type: 'number' },

package/schemas/RigidBody.ts

@@ -1,15 +1,15 @@
 import { rigidBodyDescSchema } from './RigidBodyDesc';
 import type { JSONSchemaType } from 'ajv';
-import { RigidBodyDesc } from './RigidBodyDesc';
+import { RigidBodyDescSchema } from './RigidBodyDesc';
 
-export type RigidBody = {
+export type RigidBodySchema = {
   h?: number; // rigid body handle for rapier
-} & RigidBodyDesc;
+} & RigidBodyDescSchema;
 
-export const rigidBodySchema: JSONSchemaType<RigidBody> = {
+export const rigidBodySchema: JSONSchemaType<RigidBodySchema> = {
   type: 'object',
   properties: {
-    handle: { type: 'number', nullable: true },
+    h: { type: 'number', nullable: true },
     ...rigidBodyDescSchema.properties,
   },
   additionalProperties: false,

package/schemas/RigidBodyDesc.ts

@@ -2,29 +2,29 @@ import { colliderSchema } from './Collider';
 import { vectorSchema } from './Vector';
 import { vectorBooleanSchema } from './VectorBoolean'
 import type { JSONSchemaType } from 'ajv';
-import type { Collider } from './Collider';
-import type { Vector } from './Vector';
-import type { VectorBoolean } from './VectorBoolean';
+import type { ColliderSchema } from './Collider';
+import type { VectorSchema } from './Vector';
+import type { VectorBooleanSchema } from './VectorBoolean';
 
-export type RigidBodyDesc = {
-  ad?: number;        // angular dampening
-  av?: Vector;        // angular velocity
-  b?: number;         // body type
-  c?: Collider[];     // colliders
-  d?: number;         // dominance group
-  ce?: boolean;       // ccd enabled
-  en?: boolean;       // enabled
-  er?: VectorBoolean; // enabled rotations
-  et?: VectorBoolean; // enabled translations
-  g?: number;         // gravity scaling
-  ld?: number;        // linear damping
-  lv?: Vector;        // linear velocity
-  sl?: boolean;       // sleeping
-  scp?: number;       // soft ccd prediction
-  t?: Vector;         // translation
+export type RigidBodyDescSchema = {
+  ad?: number;              // angular dampening
+  av?: VectorSchema;        // angular velocity
+  b?: number;               // body type
+  c?: ColliderSchema[];     // colliders
+  d?: number;               // dominance group
+  ce?: boolean;             // ccd enabled
+  en?: boolean;             // enabled
+  er?: VectorBooleanSchema; // enabled rotations
+  et?: VectorBooleanSchema; // enabled translations
+  g?: number;               // gravity scaling
+  ld?: number;              // linear damping
+  lv?: VectorSchema;        // linear velocity
+  sl?: boolean;             // sleeping
+  scp?: number;             // soft ccd prediction
+  t?: VectorSchema;         // translation
 }
 
-export const rigidBodyDescSchema: JSONSchemaType<RigidBodyDesc> = {
+export const rigidBodyDescSchema: JSONSchemaType<RigidBodyDescSchema> = {
   type: 'object',
   properties: {
     ad: { type: 'number', nullable: true },

package/schemas/Shape.ts

@@ -1,16 +1,16 @@
 import { JSONSchemaType } from 'ajv';
 import { vectorSchema } from './Vector';
-import type { Vector } from './Vector';
+import type { VectorSchema } from './Vector';
 
-export type Shape = {
-  t?: number;  // type
-  b?: number;  // border radius
-  r?: number;  // radius
-  hx?: Vector; // half extends
-  hh?: number; // half height
+export type ShapeSchema = {
+  t?: number;        // type
+  b?: number;        // border radius
+  r?: number;        // radius
+  hx?: VectorSchema; // half extends
+  hh?: number;       // half height
 }
 
-export const shapeSchema: JSONSchemaType<Shape> = {
+export const shapeSchema: JSONSchemaType<ShapeSchema> = {
   type: 'object',
   properties: {
     t: { type: 'number', nullable: true },

package/schemas/Vector.ts

@@ -1,12 +1,12 @@
 import type { JSONSchemaType } from 'ajv';
 
-export type Vector = [
+export type VectorSchema = [
   number, // x
   number, // y
   number, // z
 ];
 
-export const vectorSchema: JSONSchemaType<Vector> = {
+export const vectorSchema: JSONSchemaType<VectorSchema> = {
   type: 'array',
   items: [
     { type: 'number' },

package/schemas/VectorBoolean.ts

@@ -1,12 +1,12 @@
 import { JSONSchemaType } from 'ajv';
 
-export type VectorBoolean = [
+export type VectorBooleanSchema = [
   boolean, // x
   boolean, // y
   boolean, // z
 ];
 
-export const vectorBooleanSchema: JSONSchemaType<VectorBoolean> = {
+export const vectorBooleanSchema: JSONSchemaType<VectorBooleanSchema> = {
   type: 'array',
   items: [
     { type: 'boolean' },