@zylem/game-lib 0.3.14

package/dist/lib/camera/zylem-camera.d.ts

@@ -0,0 +1,68 @@
+import { Vector2, Camera, Vector3, Object3D, WebGLRenderer, Scene } from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { PerspectiveType } from './perspective';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { StageEntity } from '../interfaces/entity';
+/**
+ * Interface for perspective-specific camera controllers
+ */
+export interface PerspectiveController {
+    setup(params: {
+        screenResolution: Vector2;
+        renderer: WebGLRenderer;
+        scene: Scene;
+        camera: ZylemCamera;
+    }): void;
+    update(delta: number): void;
+    resize(width: number, height: number): void;
+}
+export declare class ZylemCamera {
+    cameraRig: Object3D;
+    camera: Camera;
+    screenResolution: Vector2;
+    renderer: WebGLRenderer;
+    composer: EffectComposer;
+    _perspective: PerspectiveType;
+    orbitControls: OrbitControls | null;
+    target: StageEntity | null;
+    sceneRef: Scene | null;
+    frustumSize: number;
+    perspectiveController: PerspectiveController | null;
+    constructor(perspective: PerspectiveType, screenResolution: Vector2, frustumSize?: number);
+    /**
+     * Setup the camera with a scene
+     */
+    setup(scene: Scene): Promise<void>;
+    /**
+     * Update camera and render
+     */
+    update(delta: number): void;
+    /**
+     * Dispose renderer, composer, controls, and detach from scene
+     */
+    destroy(): void;
+    /**
+     * Resize camera and renderer
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Create camera based on perspective type
+     */
+    private createCameraForPerspective;
+    /**
+     * Initialize perspective-specific controller
+     */
+    private initializePerspectiveController;
+    private createThirdPersonCamera;
+    private createFirstPersonCamera;
+    private createIsometricCamera;
+    private createFlat2DCamera;
+    private createFixed2DCamera;
+    private moveCamera;
+    move(position: Vector3): void;
+    rotate(pitch: number, yaw: number, roll: number): void;
+    /**
+     * Get the DOM element for the renderer
+     */
+    getDomElement(): HTMLCanvasElement;
+}

package/dist/lib/collision/collision-builder.d.ts

@@ -0,0 +1,23 @@
+import { ColliderDesc, RigidBodyDesc } from "@dimforge/rapier3d-compat";
+import { PhysicsOptions } from "./physics";
+import { Vec3 } from "../core/vector";
+import { CollisionOptions } from "./collision";
+export declare function getOrCreateCollisionGroupId(type: string): number;
+export declare function createCollisionFilter(allowedTypes: string[]): number;
+export declare function setCollisionGroups(collider: ColliderDesc, entityType: string, allowedTypes: string[]): void;
+export type ColliderFunction = () => ColliderDesc;
+export type RigidBodyFunction = ({ isDynamicBody }: {
+    isDynamicBody: boolean;
+}) => RigidBodyDesc;
+export declare class CollisionBuilder {
+    static: boolean;
+    sensor: boolean;
+    gravity: Vec3;
+    build(options: Partial<CollisionOptions>): [RigidBodyDesc, ColliderDesc];
+    withCollision(collisionOptions: Partial<CollisionOptions>): this;
+    withPhysics(physicsOptions: Partial<PhysicsOptions>): this;
+    collider(options: CollisionOptions): ColliderDesc;
+    bodyDesc({ isDynamicBody }: {
+        isDynamicBody?: boolean | undefined;
+    }): RigidBodyDesc;
+}

package/dist/lib/collision/collision-delegate.d.ts

@@ -0,0 +1,11 @@
+export declare function isCollisionHandlerDelegate(obj: any): obj is CollisionHandlerDelegate;
+export interface CollisionHandlerDelegate {
+    handlePostCollision(params: any): boolean;
+    handleIntersectionEvent(params: any): void;
+}
+export declare class CollisionHandler {
+    entityReference: CollisionHandlerDelegate;
+    constructor(entity: CollisionHandlerDelegate);
+    handlePostCollision(params: any): boolean;
+    handleIntersectionEvent(params: any): void;
+}

package/dist/lib/collision/collision-group.d.ts

@@ -0,0 +1,27 @@
+import { GameEntity } from '../entities/entity';
+import { CollisionContext } from '../entities/entity';
+/**
+ * Configure an entity's collision groups to only collide with the specified types.
+ * This uses Rapier's built-in collision group system for efficient filtering.
+ *
+ * @param entity - The entity to configure collision groups for
+ * @param allowedTypes - Array of collision types this entity should collide with
+ * @returns The entity for method chaining
+ */
+export declare function collisionGroup<T extends GameEntity<any>>(entity: T, allowedTypes: string[]): T;
+/**
+ * Legacy type definitions for backward compatibility
+ * @deprecated Use the new collisionGroup function instead
+ */
+export type CollisionCallback = (ctx: CollisionContext<any, any>) => void;
+export type CollisionGroupWrapper = (...actions: CollisionCallback[]) => CollisionCallback;
+/**
+ * @deprecated This function is deprecated. Use the new collisionGroup function instead.
+ */
+export declare function legacyCollisionGroup(...args: (string | GameEntity<any> | {
+    includeSameType?: boolean;
+})[]): CollisionGroupWrapper;
+/**
+ * @deprecated This function is deprecated.
+ */
+export declare function combineCollisionGroups(...wrappers: CollisionGroupWrapper[]): CollisionGroupWrapper;

package/dist/lib/collision/collision-mask.d.ts

@@ -0,0 +1,17 @@
+import type { GameEntity } from "../entities/entity";
+/**
+ * A branded bitmask representing a set of collision types.
+ * Construct with {@link buildCollisionMask}.
+ */
+export type CollisionMask = number & {
+    readonly __brand: "CollisionMask";
+};
+/**
+ * Builds a bitmask from one or more collision type names.
+ * The type names should match the values set on `GameEntity.collisionType`.
+ */
+export declare function buildCollisionMask(...types: string[]): CollisionMask;
+/**
+ * Tests whether the given entity's collision type is included in the mask.
+ */
+export declare function entityMatchesMask(entity: GameEntity<any>, mask: CollisionMask): boolean;

package/dist/lib/collision/collision.d.ts

@@ -0,0 +1,27 @@
+import { RigidBodyDesc } from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+export declare class BaseCollision {
+    static: boolean;
+    isSensor: boolean;
+    bodyDescription: RigidBodyDesc;
+    constructor({ isDynamicBody }: {
+        isDynamicBody?: boolean | undefined;
+    });
+}
+export declare const CollisionComponent: import("bitecs").ComponentType<{
+    static: "i8";
+    isSensor: "i8";
+    bodyDescription: "i8";
+}>;
+export declare const CollisionDebugComponent: import("bitecs").ComponentType<{
+    active: "i8";
+    color: "f32";
+}>;
+export interface CollisionOptions {
+    static?: boolean;
+    sensor?: boolean;
+    size?: Vector3;
+    position?: Vector3;
+    collisionType?: string;
+    collisionFilter?: string[];
+}

package/dist/lib/collision/physics.d.ts

@@ -0,0 +1,4 @@
+import { Vec3 } from '../core/vector';
+export interface PhysicsOptions {
+    gravity: Vec3;
+}

package/dist/lib/collision/utils.d.ts

@@ -0,0 +1,14 @@
+import type { GameEntity } from "../entities/entity";
+import type { CollisionMask } from "./collision-mask";
+export type NameSelector = string | string[] | RegExp;
+export type CollisionSelector = {
+    name: NameSelector;
+} | {
+    mask: CollisionMask | RegExp;
+} | {
+    test: (other: GameEntity<any>) => boolean;
+};
+/**
+ * Returns true if the `other` entity matches the provided selector.
+ */
+export declare function matchesCollisionSelector(other: GameEntity<any>, selector?: CollisionSelector): boolean;

package/dist/lib/collision/world.d.ts

@@ -0,0 +1,22 @@
+import { Vector3 } from 'three';
+import RAPIER, { World } from '@dimforge/rapier3d-compat';
+import { Entity } from '../interfaces/entity';
+import { UpdateContext } from '../core/base-node-life-cycle';
+import { GameEntity } from '../entities/entity';
+export declare class ZylemWorld implements Entity<ZylemWorld> {
+    type: string;
+    world: World;
+    collisionMap: Map<string, GameEntity<any>>;
+    collisionBehaviorMap: Map<string, GameEntity<any>>;
+    _removalMap: Map<string, GameEntity<any>>;
+    static loadPhysics(gravity: Vector3): Promise<RAPIER.World>;
+    constructor(world: World);
+    addEntity(entity: any): void;
+    setForRemoval(entity: any): void;
+    destroyEntity(entity: GameEntity<any>): void;
+    setup(): void;
+    update(params: UpdateContext<any>): void;
+    updatePostCollisionBehaviors(delta: number): void;
+    updateColliders(delta: number): void;
+    destroy(): void;
+}

package/dist/lib/core/asset-manager.d.ts

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

package/dist/lib/core/base-node-life-cycle.d.ts

@@ -0,0 +1,53 @@
+import { Vector3 } from 'three';
+import { Inputs } from '../input/input';
+export interface IGame<TGlobals extends Record<string, unknown> = any> {
+    start: () => Promise<this>;
+    nextStage: () => Promise<void>;
+    previousStage: () => Promise<void>;
+    reset: () => Promise<void>;
+    pause: () => Promise<void>;
+    resume: () => Promise<void>;
+    end: () => Promise<void>;
+    goToStage: () => void;
+    getGlobal: <K extends keyof TGlobals>(key: K) => TGlobals[K];
+    setGlobal: <K extends keyof TGlobals>(key: K, value: TGlobals[K]) => void;
+}
+export interface IStage {
+    onUpdate: (callback: UpdateFunction<IStage>) => void;
+    onSetup: (callback: SetupFunction<IStage>) => void;
+    onDestroy: (callback: DestroyFunction<IStage>) => void;
+}
+export interface ICamera {
+    move: (position: Vector3) => void;
+    rotate: (pitch: number, yaw: number, roll: number) => void;
+}
+export interface SetupContext<T, TGlobals extends Record<string, unknown> = any> {
+    me: T;
+    globals: TGlobals;
+    inputs?: Inputs;
+    camera?: ICamera;
+    stage?: IStage;
+    game?: IGame<TGlobals>;
+}
+export interface SetupFunction<T, TGlobals extends Record<string, unknown> = any> {
+    (context: SetupContext<T, TGlobals>): void;
+}
+export type UpdateContext<T, TGlobals extends Record<string, unknown> = any> = {
+    me: T;
+    delta: number;
+    inputs: Inputs;
+    globals: TGlobals;
+    camera: ICamera;
+    stage?: IStage;
+    game?: IGame<TGlobals>;
+};
+export interface UpdateFunction<T, TGlobals extends Record<string, unknown> = any> {
+    (context: UpdateContext<T, TGlobals>): void;
+}
+export interface DestroyContext<T, TGlobals extends Record<string, unknown> = any> {
+    me: T;
+    globals: TGlobals;
+}
+export interface DestroyFunction<T, TGlobals extends Record<string, unknown> = any> {
+    (context: DestroyContext<T, TGlobals>): void;
+}

package/dist/lib/core/base-node.d.ts

@@ -0,0 +1,32 @@
+import { Behavior } from "~/lib/actions/behaviors/behavior";
+import { DestroyContext, DestroyFunction, SetupContext, SetupFunction, UpdateContext, UpdateFunction } from "./base-node-life-cycle";
+export type BaseNodeOptions<T = any> = BaseNode | Partial<T>;
+export declare abstract class BaseNode<Options = any, T = any> {
+    protected parent: BaseNode | null;
+    protected children: BaseNode[];
+    behaviors: Behavior[];
+    options: Options;
+    eid: number;
+    uuid: string;
+    name: string;
+    markedForRemoval: boolean;
+    update: UpdateFunction<this>;
+    setup: SetupFunction<this>;
+    destroy: DestroyFunction<this>;
+    constructor(args?: BaseNodeOptions[]);
+    setParent(parent: BaseNode | null): void;
+    getParent(): BaseNode | null;
+    add(baseNode: BaseNode): void;
+    remove(baseNode: BaseNode): void;
+    getChildren(): BaseNode[];
+    isComposite(): boolean;
+    abstract create(): T;
+    protected abstract _setup(params: SetupContext<this>): void;
+    protected abstract _update(params: UpdateContext<this>): void;
+    protected abstract _destroy(params: DestroyContext<this>): void;
+    nodeSetup(params: SetupContext<this>): void;
+    nodeUpdate(params: UpdateContext<this>): void;
+    nodeDestroy(params: DestroyContext<this>): void;
+    getOptions(): Options;
+    setOptions(options: Partial<Options>): void;
+}

package/dist/lib/core/entity-asset-loader.d.ts

@@ -0,0 +1,29 @@
+import { AnimationClip, Object3D } from 'three';
+import { GLTF } from 'three/addons/loaders/GLTFLoader.js';
+export declare enum FileExtensionTypes {
+    FBX = "fbx",
+    GLTF = "gltf"
+}
+export interface AssetLoaderResult {
+    object?: Object3D;
+    animation?: AnimationClip;
+    gltf?: GLTF;
+}
+export interface IAssetLoader {
+    load(file: string): Promise<AssetLoaderResult>;
+    isSupported(file: string): boolean;
+}
+export declare class FBXAssetLoader implements IAssetLoader {
+    private loader;
+    isSupported(file: string): boolean;
+    load(file: string): Promise<AssetLoaderResult>;
+}
+export declare class GLTFAssetLoader implements IAssetLoader {
+    private loader;
+    isSupported(file: string): boolean;
+    load(file: string): Promise<AssetLoaderResult>;
+}
+export declare class EntityAssetLoader {
+    private loaders;
+    loadFile(file: string): Promise<AssetLoaderResult>;
+}

package/dist/lib/core/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class EntityErrors {
+    errorEntityBody(): string;
+    errorIncompatibleFileType(extension?: string): string;
+}

package/dist/lib/core/flags.d.ts

@@ -0,0 +1,2 @@
+/** Vite build flags */
+export declare const DEBUG_FLAG: boolean;

package/dist/lib/core/game-canvas.d.ts

@@ -0,0 +1,4 @@
+export declare const GameCanvas: (targetRatio: number) => {
+    targetRatio: number;
+    canvasWrapper: null;
+};

package/dist/lib/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../game/zylem-game';
+export * from '../stage/zylem-stage';
+export * from './vessel';
+export * from '../types';

package/dist/lib/core/lazy-loader.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Lazy loading utilities for Zylem components
+ * Use these functions to load parts of the library only when needed
+ *
+ * Loading order follows dependency hierarchy:
+ * 1. Foundation (core utilities, types)
+ * 2. State, Input, Graphics, Physics (parallel)
+ * 3. Camera (depends on graphics)
+ * 4. Entities (depends on foundation, graphics, physics)
+ * 5. Behaviors (depends on entities)
+ * 6. Core game systems (depends on most others)
+ * 7. Stage (depends on everything)
+ */
+export declare const loadFoundation: () => Promise<{
+    baseNode: typeof import("./base-node");
+    lifeCycle: typeof import("./base-node-life-cycle");
+    utility: typeof import("./utility");
+    vector: typeof import("./vector");
+}>;
+export declare const loadState: () => Promise<typeof import("../game/game-state")>;
+export declare const loadInput: () => Promise<typeof import("../input/input-manager")>;
+export declare const loadGraphics: () => Promise<{
+    material: typeof import("../graphics/material");
+    mesh: typeof import("../graphics/mesh");
+}>;
+export declare const loadPhysics: () => Promise<{
+    physics: typeof import("../collision/physics");
+    collision: typeof import("../collision/collision");
+    collisionBuilder: typeof import("../collision/collision-builder");
+}>;
+export declare const loadCamera: () => Promise<{
+    camera: typeof import("../camera/camera");
+    perspectives: typeof import("../camera/perspective");
+}>;
+export declare const loadAllEntities: () => Promise<typeof import("../entities/entity")>;
+export declare const loadEntity: (entityType: "box" | "sphere" | "sprite" | "plane" | "zone" | "actor") => Promise<typeof import("../entities/box") | typeof import("../entities/sphere") | typeof import("../entities/sprite") | typeof import("../entities/plane") | typeof import("../entities/zone") | typeof import("../entities/actor")>;
+export declare const loadBehaviors: () => Promise<typeof import("../actions/behaviors/actions")>;
+export declare const loadGameCore: () => Promise<{
+    game: typeof import("../game/game");
+    vessel: typeof import("./vessel");
+}>;
+export declare const loadStage: () => Promise<{
+    stage: typeof import("../stage/stage");
+    world: typeof import("../collision/world");
+    scene: typeof import("../graphics/zylem-scene");
+}>;
+export declare const loadDebugTools: () => Promise<typeof import("../ui/Debug")>;
+export declare const loadFullGame: () => Promise<{
+    foundation: {
+        baseNode: typeof import("./base-node");
+        lifeCycle: typeof import("./base-node-life-cycle");
+        utility: typeof import("./utility");
+        vector: typeof import("./vector");
+    };
+    state: typeof import("../game/game-state");
+    input: typeof import("../input/input-manager");
+    graphics: {
+        material: typeof import("../graphics/material");
+        mesh: typeof import("../graphics/mesh");
+    };
+    physics: {
+        physics: typeof import("../collision/physics");
+        collision: typeof import("../collision/collision");
+        collisionBuilder: typeof import("../collision/collision-builder");
+    };
+    camera: {
+        camera: typeof import("../camera/camera");
+        perspectives: typeof import("../camera/perspective");
+    };
+    entities: typeof import("../entities/entity");
+    behaviors: typeof import("../actions/behaviors/actions");
+    gameCore: {
+        game: typeof import("../game/game");
+        vessel: typeof import("./vessel");
+    };
+    stage: {
+        stage: typeof import("../stage/stage");
+        world: typeof import("../collision/world");
+        scene: typeof import("../graphics/zylem-scene");
+    };
+}>;

package/dist/lib/core/lifecycle-base.d.ts

@@ -0,0 +1,16 @@
+import { DestroyContext, DestroyFunction, SetupContext, SetupFunction, UpdateContext, UpdateFunction } from './base-node-life-cycle';
+/**
+ * Provides BaseNode-like lifecycle without ECS/children. Consumers implement
+ * the protected hooks and may assign public setup/update/destroy callbacks.
+ */
+export declare abstract class LifeCycleBase<TSelf> {
+    update: UpdateFunction<TSelf>;
+    setup: SetupFunction<TSelf>;
+    destroy: DestroyFunction<TSelf>;
+    protected abstract _setup(context: SetupContext<TSelf>): void;
+    protected abstract _update(context: UpdateContext<TSelf>): void;
+    protected abstract _destroy(context: DestroyContext<TSelf>): void;
+    nodeSetup(context: SetupContext<TSelf>): void;
+    nodeUpdate(context: UpdateContext<TSelf>): void;
+    nodeDestroy(context: DestroyContext<TSelf>): void;
+}

package/dist/lib/core/preset-shader.d.ts

@@ -0,0 +1,10 @@
+export type ZylemShaderObject = {
+    fragment: string;
+    vertex: string;
+};
+export declare const starShader: ZylemShaderObject;
+export declare const fireShader: ZylemShaderObject;
+export declare const standardShader: ZylemShaderObject;
+export type ZylemShaderType = 'standard' | 'fire' | 'star';
+declare const shaderMap: Map<ZylemShaderType, ZylemShaderObject>;
+export default shaderMap;

package/dist/lib/core/three-addons/Timer.d.ts

@@ -0,0 +1,106 @@
+/**
+ * This class is an alternative to {@link Clock} with a different API design and behavior.
+ * The goal is to avoid the conceptual flaws that became apparent in `Clock` over time.
+ *
+ * - `Timer` has an `update()` method that updates its internal state. That makes it possible to
+ * call `getDelta()` and `getElapsed()` multiple times per simulation step without getting different values.
+ * - The class can make use of the Page Visibility API to avoid large time delta values when the app
+ * is inactive (e.g. tab switched or browser hidden).
+ *
+ * ```js
+ * const timer = new Timer();
+ * timer.connect( document ); // use Page Visibility API
+ * ```
+ *
+ * @three_import import { Timer } from 'three/addons/misc/Timer.js';
+ */
+declare class Timer {
+    protected _previousTime: number;
+    protected _currentTime: number;
+    protected _startTime: number;
+    protected _delta: number;
+    protected _elapsed: number;
+    protected _timescale: number;
+    protected _document: Document | null;
+    protected _pageVisibilityHandler: (() => void) | null;
+    /**
+     * Constructs a new timer.
+     */
+    constructor();
+    /**
+     * Connect the timer to the given document.Calling this method is not mandatory to
+     * use the timer but enables the usage of the Page Visibility API to avoid large time
+     * delta values.
+     *
+     * @param {Document} document - The document.
+     */
+    connect(document: Document): void;
+    /**
+     * Disconnects the timer from the DOM and also disables the usage of the Page Visibility API.
+     */
+    disconnect(): void;
+    /**
+     * Returns the time delta in seconds.
+     *
+     * @return {number} The time delta in second.
+     */
+    getDelta(): number;
+    /**
+     * Returns the elapsed time in seconds.
+     *
+     * @return {number} The elapsed time in second.
+     */
+    getElapsed(): number;
+    /**
+     * Returns the timescale.
+     *
+     * @return {number} The timescale.
+     */
+    getTimescale(): number;
+    /**
+     * Sets the given timescale which scale the time delta computation
+     * in `update()`.
+     *
+     * @param {number} timescale - The timescale to set.
+     * @return {Timer} A reference to this timer.
+     */
+    setTimescale(timescale: number): Timer;
+    /**
+     * Resets the time computation for the current simulation step.
+     *
+     * @return {Timer} A reference to this timer.
+     */
+    reset(): Timer;
+    /**
+     * Can be used to free all internal resources. Usually called when
+     * the timer instance isn't required anymore.
+     */
+    dispose(): void;
+    /**
+     * Updates the internal state of the timer. This method should be called
+     * once per simulation step and before you perform queries against the timer
+     * (e.g. via `getDelta()`).
+     *
+     * @param {number} timestamp - The current time in milliseconds. Can be obtained
+     * from the `requestAnimationFrame` callback argument. If not provided, the current
+     * time will be determined with `performance.now`.
+     * @return {Timer} A reference to this timer.
+     */
+    update(timestamp?: number): Timer;
+}
+/**
+ * A special version of a timer with a fixed time delta value.
+ * Can be useful for testing and debugging purposes.
+ *
+ * @augments Timer
+ */
+declare class FixedTimer extends Timer {
+    /**
+     * Constructs a new timer.
+     *
+     * @param {number} [fps=60] - The fixed FPS of this timer.
+     */
+    constructor(fps?: number);
+    update(): FixedTimer;
+}
+export { Timer, FixedTimer };

package/dist/lib/core/utility.d.ts

@@ -0,0 +1,15 @@
+import { Color, Vector3 as ThreeVector3 } from 'three';
+import { Vector3 } from '@dimforge/rapier3d-compat';
+/**
+ * @deprecated This type is deprecated.
+ */
+export type Vect3 = ThreeVector3 | Vector3;
+export declare const ZylemBlueColor: Color;
+export declare const ZylemBlue = "#0333EC";
+export declare const ZylemBlueTransparent = "#0333ECA0";
+export declare const ZylemGoldText = "#DAA420";
+export type SizeVector = Vect3 | null;
+export declare function sortedStringify(obj: Record<string, any>): string;
+export declare function shortHash(objString: string): string;
+export declare const Vec0: Vector3;
+export declare const Vec1: Vector3;

package/dist/lib/core/vector.d.ts

@@ -0,0 +1,3 @@
+import { Vector3 as ThreeVector3 } from 'three';
+import { Vector3 as RapierVector3 } from '@dimforge/rapier3d-compat';
+export type Vec3 = ThreeVector3 | RapierVector3;

package/dist/lib/core/vessel.d.ts

@@ -0,0 +1,11 @@
+import { BaseNode } from './base-node';
+import { SetupContext, UpdateContext, DestroyContext } from './base-node-life-cycle';
+export declare const VESSEL_TYPE: unique symbol;
+export declare class Vessel extends BaseNode<{}, Vessel> {
+    static type: symbol;
+    protected _setup(_params: SetupContext<this>): void;
+    protected _update(_params: UpdateContext<this>): void;
+    protected _destroy(_params: DestroyContext<this>): void;
+    create(): this;
+}
+export declare function vessel(...args: Array<BaseNode>): BaseNode<{}, Vessel>;

package/dist/lib/debug/console/console-state.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Console state for managing debug console messages
+ */
+export declare const consoleState: {
+    messages: string[];
+};
+/**
+ * Append a message to the debug console
+ * @param message The message to append to the console
+ */
+export declare const printToConsole: (message: string) => void;
+/**
+ * Clear all messages from the debug console
+ */
+export declare const clearConsole: () => void;
+/**
+ * Get all console messages as a single string
+ */
+export declare const getConsoleContent: () => string;

package/dist/lib/debug/console/console-store.d.ts

@@ -0,0 +1,5 @@
+export declare const consoleStore: {
+    messages: string[];
+}, setConsoleStore: import("solid-js/store").SetStoreFunction<{
+    messages: string[];
+}>;