@divinevoxel/vlox 0.0.4 → 0.0.6

package/Voxels/State/Schema/BinarySchema.d.ts

@@ -1,11 +1,14 @@
 import { BinarySchemaNode } from "./BinarySchemaNode";
 import { BinarySchemaNodeData } from "../State.types";
+type StateObject = (string | number)[];
 export declare class BinarySchema {
     nodeMap: Map<string, BinarySchemaNode>;
     nodes: BinarySchemaNode[];
     constructor(schema: BinarySchemaNodeData[]);
     private _value;
     readString(stateString: string): number;
+    fromStateObject(stateObject: StateObject): number;
+    getStateObject(stateValue: number): StateObject;
     compareString(stateString: string, ecnoded: number): boolean;
     startEncoding(value?: number): this;
     getNmber(id: string): number;
@@ -14,3 +17,4 @@ export declare class BinarySchema {
     setValue(id: string, value: string): this;
     getEncoded(): number;
 }
+export {};

package/Voxels/State/Schema/BinarySchema.js

@@ -27,7 +27,7 @@ export class BinarySchema {
             if (node.valuePalette) {
                 const value = node.valuePalette.getNumberId(v);
                 if (value === undefined)
-                    throw new Error(`Binary schema string node value  with id ${v} does not exist.`);
+                    throw new Error(`Binary schema string node value with id ${v} does not exist.`);
                 ecnoded = node.setValue(ecnoded, value);
             }
             else {
@@ -36,6 +36,37 @@ export class BinarySchema {
         }
         return ecnoded;
     }
+    fromStateObject(stateObject) {
+        let encodedValue = 0;
+        for (let i = 0; i < stateObject.length; i += 2) {
+            const key = stateObject[i];
+            if (typeof key !== "string")
+                continue;
+            const value = stateObject[i + 1];
+            const node = this.nodeMap.get(key);
+            if (!node)
+                continue;
+            if (typeof value == "string") {
+                if (!node.valuePalette)
+                    continue;
+                encodedValue = node.setValue(encodedValue, node.valuePalette.getNumberId(value) || 0);
+                continue;
+            }
+            encodedValue = node.setValue(encodedValue, value);
+        }
+        return encodedValue;
+    }
+    getStateObject(stateValue) {
+        const stateArray = [];
+        for (const node of this.nodes) {
+            if (node.valuePalette) {
+                stateArray.push(node.id, node.valuePalette.getStringId(node.getValue(stateValue)));
+                continue;
+            }
+            stateArray.push(node.id, node.getValue(stateValue));
+        }
+        return stateArray;
+    }
     compareString(stateString, ecnoded) {
         if (stateString == "*")
             return true;

package/Voxels/State/Schema/StateSchema.d.ts

@@ -1,9 +1,9 @@
 import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
 import { BinarySchemaNode } from "./BinarySchemaNode";
 import { VoxelModelStateSchemaData } from "../State.types";
-import { DataCursorInterface } from "../../../Data/Cursor/Interfaces/DataCursor.interface";
+import { DataCursorInterface } from "../../../Data/Cursor/DataCursor.interface";
 import { Vector3Like } from "@amodx/math";
-import { VoxelCursorInterface } from "../../../Data/Cursor/Interfaces/VoxelCursor.interface";
+import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
 export declare class StateSchema {
     nodes: (BinarySchemaNode | ShapeStateRelationsNode)[];
     position: Vector3Like;

package/Voxels/State/Schema/VoxelSchema.d.ts

@@ -1,7 +1,7 @@
 import { BinarySchema } from "./BinarySchema";
-export declare class VoxelSceham {
+export declare class VoxelSchema {
     id: string;
-    shapeState: BinarySchema;
-    modState: BinarySchema;
-    constructor(id: string, shapeState: BinarySchema, modState: BinarySchema);
+    state: BinarySchema;
+    mod: BinarySchema;
+    constructor(id: string, state: BinarySchema, mod: BinarySchema);
 }

package/Voxels/State/Schema/VoxelSchema.js

@@ -1,10 +1,10 @@
-export class VoxelSceham {
+export class VoxelSchema {
     id;
-    shapeState;
-    modState;
-    constructor(id, shapeState, modState) {
+    state;
+    mod;
+    constructor(id, state, mod) {
         this.id = id;
-        this.shapeState = shapeState;
-        this.modState = modState;
+        this.state = state;
+        this.mod = mod;
     }
 }

package/Voxels/State/SchemaRegister.d.ts

@@ -1,5 +1,5 @@
 import { BinarySchema } from "./Schema/BinarySchema";
-import { VoxelSceham } from "./Schema/VoxelSchema";
+import { VoxelSchema } from "./Schema/VoxelSchema";
 import { BinarySchemaNodeData, VoxelModelStateSchemaData } from "./State.types";
 export declare class SchemaRegister {
     static modelStaeBaseSchemaData: Map<string, VoxelModelStateSchemaData[]>;
@@ -8,8 +8,9 @@ export declare class SchemaRegister {
     static modelStaeSchemas: Map<string, BinarySchema>;
     static voxelModSchemas: Map<string, BinarySchema>;
     static voxelModelMap: Map<string, string>;
-    static voxelSchemas: Map<string, VoxelSceham>;
-    static getVoxelSchemas(voxelId: string): VoxelSceham;
+    static voxelSchemas: Map<string, VoxelSchema>;
+    static hasVoxelSchema(voxelId: string): boolean;
+    static getVoxelSchemas(voxelId: string): VoxelSchema;
     static registerModel(id: string, data: VoxelModelStateSchemaData[]): void;
     static registerVoxel(id: string, modelId: string, data: VoxelModelStateSchemaData[]): void;
 }

package/Voxels/State/SchemaRegister.js

@@ -1,5 +1,5 @@
 import { BinarySchema } from "./Schema/BinarySchema";
-import { VoxelSceham } from "./Schema/VoxelSchema";
+import { VoxelSchema } from "./Schema/VoxelSchema";
 export class SchemaRegister {
     static modelStaeBaseSchemaData = new Map();
     static modelStateSchemaData = new Map();
@@ -8,6 +8,9 @@ export class SchemaRegister {
     static voxelModSchemas = new Map();
     static voxelModelMap = new Map();
     static voxelSchemas = new Map();
+    static hasVoxelSchema(voxelId) {
+        return this.voxelSchemas.has(voxelId);
+    }
     static getVoxelSchemas(voxelId) {
         if (this.voxelSchemas.has(voxelId)) {
             return this.voxelSchemas.get(voxelId);
@@ -29,7 +32,7 @@ export class SchemaRegister {
                 throw new Error(`Voxel ${voxelId} is not registered`);
             modSchema = new BinarySchema(schemaData);
         }
-        const voxelSchema = new VoxelSceham(voxelId, shapeStateSchema, modSchema);
+        const voxelSchema = new VoxelSchema(voxelId, shapeStateSchema, modSchema);
         this.voxelSchemas.set(voxelId, voxelSchema);
         return voxelSchema;
     }

package/Voxels/State/VoxelTagStates.js

@@ -1,4 +1,4 @@
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
 import { StateSchema } from "./Schema/StateSchema";
 import { StateTreeReader } from "./StateTreeReader";
 import { SchemaRegister } from "./SchemaRegister";

package/Voxels/Structs/Builder/SubstanceStructBuilder.d.ts

@@ -0,0 +1,2 @@
+import { StructBuilder } from "../../../Data/Structs/StructBuilder.js";
+export declare const SubstanceStructBuilder: StructBuilder;

package/{Data → Voxels}/Structs/Builder/SubstanceStructBuilder.js

@@ -1,6 +1,6 @@
 import { BinaryNumberTypes } from "@amodx/binary";
-import { SubstanceStructIds } from "../../../Voxels/VoxelSubstances.types";
-import { StructBuilder } from "./StructBuilder.js";
+import { SubstanceStructIds } from "../../Types/VoxelSubstances.types";
+import { StructBuilder } from "../../../Data/Structs/StructBuilder.js";
 export const SubstanceStructBuilder = new StructBuilder("substance-tag-manager", "substance");
 SubstanceStructBuilder.addNode([
     {

package/Voxels/Structs/Builder/VoxelStructBuilder.d.ts

@@ -0,0 +1,2 @@
+import { StructBuilder } from "../../../Data/Structs/StructBuilder.js";
+export declare const VoxelStructBuilder: StructBuilder;

package/{Data → Voxels}/Structs/Builder/VoxelStructBuilder.js

@@ -1,6 +1,6 @@
 import { BinaryNumberTypes } from "@amodx/binary";
-import { VoxelStructIds } from "../../../Voxels/Voxel.types";
-import { StructBuilder } from "./StructBuilder.js";
+import { VoxelStructIds } from "../../Types/Voxel.types";
+import { StructBuilder } from "../../../Data/Structs/StructBuilder.js";
 export const VoxelStructBuilder = new StructBuilder("voxel-tag-manager", "voxel");
 VoxelStructBuilder.addNode([
     {
@@ -8,11 +8,6 @@ VoxelStructBuilder.addNode([
         type: "string-map",
         allowedComms: ["constructor", "nexus", "fx", "world", "render"],
     },
-    {
-        id: VoxelStructIds.shapeID,
-        type: "string-map",
-        allowedComms: ["constructor"],
-    },
     {
         id: VoxelStructIds.colliderID,
         type: "string-map",

package/{Data → Voxels}/Structs/SubstanceStruct.d.ts

@@ -1,6 +1,7 @@
 import { BinaryStructData, InstantiatedStruct } from "@amodx/binary/";
-import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
+import { SubstanceStructIds } from "../Types/VoxelSubstances.types.js";
 export interface SubstanceStruct {
+    [key: string]: any;
     [SubstanceStructIds.parent]: number;
     [SubstanceStructIds.isSolid]: number;
     [SubstanceStructIds.isTransparent]: number;

package/{Data → Voxels}/Structs/SubstanceStruct.js

@@ -1,5 +1,5 @@
 import { RemoteBinaryStruct, InstantiatedStruct, } from "@amodx/binary/";
-import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
+import { SubstanceStructIds } from "../Types/VoxelSubstances.types.js";
 import { SubstancePalette } from "../Palettes/SubstancePalette.js";
 const remote = new RemoteBinaryStruct("voxel-data");
 export class SubstanceStruct extends InstantiatedStruct {
@@ -11,9 +11,7 @@ export class SubstanceStruct extends InstantiatedStruct {
         SubstanceStruct.instance = instance;
     }
     static setSubstance(id) {
-        this.instance.setIndex(typeof id == "string"
-            ? SubstancePalette.id.numberFromString(id)
-            : id);
+        this.instance.setIndex(typeof id == "string" ? SubstancePalette.id.numberFromString(id) : id);
     }
     static initData;
 }

package/{Data → Voxels}/Structs/VoxelStruct.d.ts

@@ -1,8 +1,8 @@
 import { BinaryStructData, InstantiatedStruct } from "@amodx/binary/";
-import { VoxelStructIds } from "../../Voxels/Voxel.types";
+import { VoxelStructIds } from "../Types/Voxel.types";
 export interface VoxelStruct {
+    [key: string]: any;
     [VoxelStructIds.substance]: number;
-    [VoxelStructIds.shapeID]: number;
     [VoxelStructIds.renderedMaterial]: number;
     [VoxelStructIds.voxelMaterial]: number;
     [VoxelStructIds.hardness]: number;

package/{Data → Voxels}/Structs/VoxelStruct.js

@@ -1,5 +1,5 @@
 import { RemoteBinaryStruct, InstantiatedStruct, } from "@amodx/binary/";
-import { VoxelStructIds } from "../../Voxels/Voxel.types";
+import { VoxelStructIds } from "../Types/Voxel.types";
 import { VoxelPalette } from "../Palettes/VoxelPalette";
 const remote = new RemoteBinaryStruct("voxel-data");
 export class VoxelStruct extends InstantiatedStruct {

package/Voxels/{Voxel.types.d.ts → Types/Voxel.types.d.ts}

@@ -1,5 +1,5 @@
-import { ConstructorTextureData } from "../Textures/Constructor.types";
-import { VoxelModelConstructorData } from "../Models/VoxelModel.types";
+import { TextureId } from "../../Textures/index";
+import { VoxelModelConstructorData } from "../../Models/VoxelModel.types";
 export type VoxelNamedStateData = {
     id: string;
     name?: string;
@@ -10,13 +10,23 @@ export type VoxelNamedStateData = {
     };
     display: {
         type: "texture";
-        source: ConstructorTextureData | string;
+        source: TextureId | string;
     } | {
         type: "model";
         state?: string;
         mod?: string;
     };
 };
+export declare class PaintVoxelData {
+    id: string;
+    mod: number;
+    state: number;
+    level: number;
+    levelState: number;
+    secondaryVoxelId: string;
+    static Create(data: Partial<PaintVoxelData>): PaintVoxelData;
+    private constructor();
+}
 /**
  * An array representing the raw data of a voxel.
  */
@@ -25,16 +35,17 @@ export type RawVoxelData = [
     id: number,
     /**The light of the voxel */
     light: number,
+    /**The level of the voxel */
+    level: number,
     /**The state of the voxel */
     state: number,
-    /**The secondary id of the voxel */
-    secondaryId: number,
     /**The mod of the voxel */
-    mod: number
+    mod: number,
+    /**The secondary id of the voxel */
+    secondary: number
 ];
 export declare enum VoxelStructIds {
     substance = "dve_substance",
-    shapeID = "dve_shape_id",
     renderedMaterial = "dve_rendered_material",
     voxelMaterial = "dve_voxel_material",
     hardness = "dve_hardness",

package/Voxels/{Voxel.types.js → Types/Voxel.types.js}

@@ -1,7 +1,25 @@
+export class PaintVoxelData {
+    id;
+    mod;
+    state;
+    level;
+    levelState;
+    secondaryVoxelId;
+    static Create(data) {
+        return new PaintVoxelData(data.id, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId);
+    }
+    constructor(id = "dve_air", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air") {
+        this.id = id;
+        this.mod = mod;
+        this.state = state;
+        this.level = level;
+        this.levelState = levelState;
+        this.secondaryVoxelId = secondaryVoxelId;
+    }
+}
 export var VoxelStructIds;
 (function (VoxelStructIds) {
     VoxelStructIds["substance"] = "dve_substance";
-    VoxelStructIds["shapeID"] = "dve_shape_id";
     VoxelStructIds["renderedMaterial"] = "dve_rendered_material";
     VoxelStructIds["voxelMaterial"] = "dve_voxel_material";
     VoxelStructIds["hardness"] = "dve_hardness";

package/Voxels/Types/VoxelModelCompiledData.types.d.ts

@@ -0,0 +1,93 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelAOResultsIndexData } from "../../Models/Indexing/VoxelAOResultsIndex";
+import { VoxelFaceCullResultsIndexData } from "../../Models/Indexing/VoxelFaceCullResultsIndex";
+import { VoxelFaceTransparentResultsIndexData } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
+import { VoxelModelStateSchemaData, StateLogicStatement } from "../State/State.types";
+import { VoxelGeometryData, VoxelGeometryNodes } from "../../Models/VoxelModel.types";
+import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
+import { VoxelTagStatesData } from "../State/VoxelTagStates";
+import { BinaryStructData } from "@amodx/binary";
+export type CompiledVoxelData = {
+    models: FinalCompiledVoxelModelData;
+    data: {
+        struct: BinaryStructData;
+        index: Uint16Array;
+        palette: string[];
+        nameToIdMap: Record<string, string>;
+        idToNameMap: Record<string, string>;
+        stringMaps: Record<string, string[]>;
+        objectMaps: Record<string, any[]>;
+    };
+    substances: {
+        struct: BinaryStructData;
+        palette: string[];
+        stringMaps: Record<string, string[]>;
+        objectMaps: Record<string, any[]>;
+    };
+    materials: {
+        palette: string[];
+    };
+};
+export interface CompiledVoxelGeometryNodes {
+    node: VoxelGeometryNodes;
+    tranform: VoxelGeometryTransform;
+}
+export interface VoxelGeometryTransform {
+    position?: Vec3Array;
+    scale?: Vec3Array;
+    rotation?: Vec3Array;
+    rotationPivot?: Vec3Array;
+    lockUVs?: true;
+    flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
+}
+export interface CompiledVoxelGeometryData {
+    id: string;
+    ogData: VoxelGeometryData;
+    nodes: CompiledVoxelGeometryNodes[];
+}
+export type CompiledVoxelGeometrySyncData = {
+    id: string;
+    nodes: CompiledVoxelGeometryNodes[];
+    faceCullMap?: number[][];
+    vertexHitMap?: number[][];
+    aoIndex?: VoxelAOResultsIndexData;
+    cullIndex?: VoxelFaceCullResultsIndexData;
+};
+export interface CompiledVoxelGeometryRulessData {
+    id: string;
+    nodes: CompiledVoxelGeometryNodes[];
+    ruleless: true;
+}
+export interface CompiledVoxelModelData {
+    id: string;
+    schema: VoxelModelStateSchemaData[];
+    effects: VoxelEffectSyncData[];
+    geoLinkMap: number[];
+    shapeStateTree: any[];
+    shapeStateMap: number[][];
+    shapeStateGeometryMap: number[][];
+    shapeStateRelativeGeometryMap: number[][];
+    relativeGeometryByteIndexMap: number[];
+    condiotnalStatements: StateLogicStatement[];
+    condiotnalStateMap: number[][];
+    condiotnalShapeStateMap: number[][][];
+    condiotnalShapeStateGeometryMap: number[][][];
+    condiotnalShapeStateRelativeGeometryMap: number[][];
+    condiotnalStateTree: any[];
+}
+export interface CompiledVoxelModelInputData {
+    id: string;
+    modelId: string;
+    transparentFaceIndex: VoxelFaceTransparentResultsIndexData;
+    modSchema: VoxelModelStateSchemaData[];
+    modStateTree: any[];
+    baseGeometryInputMap: any[][];
+    condiotnalGeometryInputMap: any[][];
+}
+export interface FinalCompiledVoxelModelData {
+    geometryPalette: string[];
+    geometry: (CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData)[];
+    models: CompiledVoxelModelData[];
+    voxels: CompiledVoxelModelInputData[];
+    tagState: VoxelTagStatesData;
+}

package/Voxels/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./Voxel.types";
-export * from "./VoxelMaterial.types";
-export * from "./VoxelSubstances.types";
+export * from "./Types/Voxel.types";
+export * from "./Types/VoxelMaterial.types";
+export * from "./Types/VoxelSubstances.types";

package/Voxels/index.js

@@ -1,3 +1,3 @@
-export * from "./Voxel.types";
-export * from "./VoxelMaterial.types";
-export * from "./VoxelSubstances.types";
+export * from "./Types/Voxel.types";
+export * from "./Types/VoxelMaterial.types";
+export * from "./Types/VoxelSubstances.types";

package/World/Archive/Archive.types.d.ts

@@ -0,0 +1,159 @@
+import { Vec3Array } from "@amodx/math";
+import { LocationData } from "../../Math";
+/**
+ * Interface for an archived sector.
+ */
+export interface ArchivedSectorData {
+    /** The version of vlox the data was stored in. */
+    version: string;
+    /** The location of the sector in the world. */
+    location: LocationData;
+    /** Record of the sector's state, storing dynamic or user-defined data. */
+    sectorState: Record<string, any>;
+    /** The palette data used within the sector. */
+    palettes: ArchivedSectorPaletteData;
+    /** Placeholder for future buffer data. */
+    buffers: ArchivedSectorBuffersData;
+    /** Keys associated with section states and other objects. */
+    keys: ArchivedSectorKeysData;
+    /** Array of archived section data within the sector. */
+    sections: ArchivedSectionData[];
+}
+/**
+ * Interface for the palettes of an archived sector.
+ */
+export interface ArchivedSectorPaletteData {
+    id: string[];
+    secondaryId?: string[];
+    level?: Uint8Array;
+    stateMap: Record<number, any[]>;
+    modMap: Record<number, any[]>;
+    state: Uint16Array;
+    mod: Uint16Array;
+    light?: Uint16Array;
+    secondaryState?: Uint16Array;
+}
+/**
+ * Interface for the keys of an archived sector.
+ */
+export interface ArchivedSectorKeysData {
+    /** Array of strings that are the keys for the section state struct.  */
+    sectionState: string[];
+}
+/**
+ * Placeholder interface for future buffer data in a sector.
+ */
+export interface ArchivedSectorBuffersData {
+}
+/**
+ * Interface for an archived section.
+ */
+export interface ArchivedSectionData {
+    /** Array representing the section's state, holding dynamic or user-defined data. */
+    state: any[];
+    /** Palette data used within the section. */
+    palettes: ArchivedSectionPaletteData;
+    /** Buffer data for the section, holding voxel type identifiers, light data, state, and secondary state. */
+    buffers: ArchivedSectionBuffers;
+}
+/**
+ * Interface representing the palette data for a single section in the voxel engine.
+ */
+export interface ArchivedSectionPaletteData {
+    id?: Uint16Array;
+    light?: Uint16Array;
+    level?: Uint8Array;
+    secondaryId?: Uint16Array;
+    state?: Uint16Array;
+    mod?: Uint16Array;
+    secondaryState?: Uint16Array;
+}
+/**
+ * Interface representing the buffer data for a section.
+ */
+export interface ArchivedSectionBuffers {
+    id: Uint16Array | Uint8Array | number;
+    light: Uint16Array | Uint8Array | number;
+    level: Uint8Array | number;
+    state: Uint16Array | Uint8Array | number;
+    mod: Uint16Array | Uint8Array | number;
+    secondary: Uint16Array | Uint8Array | number;
+}
+/**
+ * Interface for an archived area.
+ */
+export interface ArchivedAreaData {
+    /** The version of vlox the data was stored in. */
+    version: string;
+    /** String representing the dimension or world type the area belongs to. */
+    dimension: string;
+    /** The palette maps for the area, including voxel, light, and state data. */
+    maps: ArchivedAreaMapData;
+    /** Keys associated with sector and section states and other objects. */
+    keys: ArchivedAreaKeysData;
+    /** Array of archived sector data within the area. */
+    sectors: ArchivedAreaSectorData[];
+}
+/**
+ * Interface for an archived area maps.
+ */
+export interface ArchivedAreaMapData {
+    /** Record mapping voxel IDs to string identifiers. */
+    id: Record<string, string>;
+    /** Record mapping string IDs to arrays of voxel identifiers. */
+    idPalette: Record<string, string[]>;
+    /** Record mapping string IDs to Uint16Arrays of light data. */
+    lightPalette: Record<string, Uint16Array>;
+    /** Record mapping string IDs to Uint8Arrays of level data. */
+    levelPalette: Record<string, Uint8Array>;
+    /** Record mapping string IDs to Uint16Arrays of voxel states. */
+    statePalette: Record<string, Uint16Array>;
+    /** Record mapping string IDs to Uint16Arrays of voxel mods. */
+    modPalette: Record<string, Uint16Array>;
+    /** Record mapping string IDs to arrays of secondary voxel identifiers. */
+    secondaryIdPalette: Record<string, string[]>;
+    /** Record mapping string IDs to Uint16Arrays of secondary voxel states. */
+    secondaryStatePalette: Record<string, Uint16Array>;
+    /** Record mapping section identifiers to `ArchivedSectionData`. */
+    section: Record<string, ArchivedSectionData>;
+    /** Record mapping sector state identifiers to arrays of state data. */
+    sectorState: Record<string, any[]>;
+}
+/**
+ * Interface representing the keys associated with sector and section states within an area.
+ */
+export interface ArchivedAreaKeysData {
+    /** Array of strings that are the keys for the sector state struct.  */
+    sectorState: string[];
+    /** Array of strings that are the keys for the section state struct.  */
+    sectionState: string[];
+}
+/**
+ * Interface representing the palette data for a sector.
+ */
+export interface ArchivedAreaSectorPaletteData {
+    id: string[];
+    light?: Uint16Array;
+    level?: Uint8Array;
+    state?: Uint16Array;
+    mod?: Uint16Array;
+    stateMap: Record<number, any[]>;
+    modMap: Record<number, any[]>;
+    secondaryId?: string[];
+    secondaryState?: Uint16Array;
+}
+/**
+ * Interface representing the archived data for a sector within an area.
+ */
+export interface ArchivedAreaSectorData {
+    /** A Vec3Array representing the position of the sector within the area. */
+    position: Vec3Array;
+    /** The state data for the sector, either as an array or a reference string. */
+    sectorState: any[] | string;
+    /** Buffer data for the sector. */
+    buffers: ArchivedSectorBuffersData;
+    /** The palette data used within the sector. */
+    palettes: ArchivedAreaSectorPaletteData;
+    /** Array of archived section data or references to section data. */
+    sections: (ArchivedSectionData | string)[];
+}

package/World/Archive/Functions/ArchiveArea.d.ts

@@ -0,0 +1,10 @@
+import { ArchivedAreaSectorData, ArchivedAreaData, ArchivedSectorData } from "../Archive.types";
+type RunData = {
+    dimension: string;
+    sectors: ArchivedSectorData[];
+    version?: number;
+};
+export default function CreateArchiveArea(archiveData: RunData): ArchivedAreaData;
+export declare function CreateSectorFromArea(area: ArchivedAreaData, sector: ArchivedAreaSectorData): ArchivedSectorData;
+export declare function CreateSectorsFromArea(area: ArchivedAreaData): Generator<ArchivedSectorData>;
+export {};