@its-c10/dis-codec 0.1.0

package/dist/dis7/constants.js

@@ -0,0 +1,41 @@
+/**
+ * DIS protocol version 7 (IEEE 1278.1-2012 application protocols).
+ * Version is implied by module path; add `dis8/constants.ts` etc. for other editions.
+ */
+export const PROTOCOL_VERSION = 7;
+/** Entity Information protocol family. */
+export const PROTOCOL_FAMILY_ENTITY_INFORMATION = 1;
+/** Simulation Management protocol family. */
+export const PROTOCOL_FAMILY_SIMULATION_MANAGEMENT = 5;
+/** PDU type: Entity State. */
+export const PDU_TYPE_ENTITY_STATE = 1;
+/** PDU type: Create Entity. */
+export const PDU_TYPE_CREATE_ENTITY = 11;
+/** PDU type: Remove Entity. */
+export const PDU_TYPE_REMOVE_ENTITY = 12;
+/** PDU type: Start/Resume. */
+export const PDU_TYPE_START_RESUME = 13;
+/** PDU type: Stop/Freeze. */
+export const PDU_TYPE_STOP_FREEZE = 14;
+/** PDU type: Electromagnetic Emission. */
+export const PDU_TYPE_ELECTROMAGNETIC_EMISSION = 23;
+/** PDU type: Transmitter. */
+export const PDU_TYPE_TRANSMITTER = 25;
+/** Electromagnetic Emission protocol family. */
+export const PROTOCOL_FAMILY_ELECTROMAGNETIC_EMISSION = 6;
+/** Radio Communications protocol family. */
+export const PROTOCOL_FAMILY_RADIO_COMMUNICATIONS = 4;
+/** Start/Resume PDU total length on wire (bytes). */
+export const START_RESUME_PDU_LENGTH = 44;
+/** Stop/Freeze PDU total length on wire (bytes). */
+export const STOP_FREEZE_PDU_LENGTH = 40;
+/** Create Entity PDU total length on wire (bytes). */
+export const CREATE_ENTITY_PDU_LENGTH = 28;
+/** Remove Entity PDU total length on wire (bytes). */
+export const REMOVE_ENTITY_PDU_LENGTH = 28;
+/** Entity State PDU fixed portion in bytes (144). Total = 144 + 16*N for N variable parameters. */
+export const ENTITY_STATE_PDU_FIXED_LENGTH = 144;
+/** Variable parameter record size in bytes. */
+export const ENTITY_STATE_VARIABLE_PARAMETER_RECORD_LENGTH = 16;
+/** Transmitter PDU fixed portion in bytes (104). Total = 104 + M + A + sum of variable record sizes. */
+export const TRANSMITTER_PDU_FIXED_LENGTH = 104;

package/dist/dis7/createEntityPdu.d.ts

@@ -0,0 +1,13 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+import type { EntityId } from "../core/entityId.js";
+import type { PduHeader } from "./pduHeader.js";
+/** Create Entity PDU (224 bits). Table 149. */
+export interface CreateEntityPdu {
+    header: PduHeader;
+    originatingId: EntityId;
+    receivingId: EntityId;
+    requestId: number;
+}
+export declare function decodeCreateEntityPdu(reader: BinaryReader): CreateEntityPdu;
+export declare function encodeCreateEntityPdu(writer: BinaryWriter, pdu: CreateEntityPdu): void;

package/dist/dis7/createEntityPdu.js

@@ -0,0 +1,17 @@
+import { decodeEntityId, encodeEntityId } from "../core/entityId.js";
+import { decodePduHeader, encodePduHeader } from "./pduHeader.js";
+export function decodeCreateEntityPdu(reader) {
+    return {
+        header: decodePduHeader(reader),
+        originatingId: decodeEntityId(reader),
+        receivingId: decodeEntityId(reader),
+        requestId: reader.readUint32(),
+    };
+}
+export function encodeCreateEntityPdu(writer, pdu) {
+    encodePduHeader(writer, pdu.header);
+    encodeEntityId(writer, pdu.originatingId);
+    encodeEntityId(writer, pdu.receivingId);
+    writer.writeUint32(pdu.requestId);
+    writer.patchUint16(8, writer.getOffset());
+}

package/dist/dis7/electromagneticEmissionPdu.d.ts

@@ -0,0 +1,72 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+import type { EntityId } from "../core/entityId.js";
+import type { EventId } from "../core/eventId.js";
+import type { PduHeader } from "./pduHeader.js";
+/** Fundamental parameter data for one beam (five float32s). */
+export interface FundamentalParameterData {
+    frequency: number;
+    frequencyRange: number;
+    effectiveRadiatedPower: number;
+    pulseRepetitionFrequency: number;
+    pulseWidth: number;
+}
+/** Beam data group (azimuth/elevation center and sweep, sync). */
+export interface BeamDataGroup {
+    beamAzimuthCenter: number;
+    beamAzimuthSweep: number;
+    beamElevationCenter: number;
+    beamElevationSweep: number;
+    beamSweepSync: number;
+}
+/** Beam data record (repeats M_i times per emitter system). */
+export interface BeamData {
+    beamDataLength: number;
+    beamNumber: number;
+    beamParameterIndex: number;
+    fundamentalParameterData: FundamentalParameterData;
+    beamData: BeamDataGroup;
+    beamFunction: number;
+    numberOfTargets: number;
+    highDensityTrackJam: number;
+    beamStatus: number;
+}
+/** Emitter system (name, function, number) and location. */
+export interface EmitterSystemRecord {
+    emitterName: number;
+    emitterFunction: number;
+    emitterNumber: number;
+}
+/** Location with respect to entity (x, y, z float32). */
+export interface Location {
+    x: number;
+    y: number;
+    z: number;
+}
+/** One emitter system: fixed fields plus M beams. */
+export interface EmitterSystemData {
+    systemDataLength: number;
+    numberOfBeams: number;
+    padding: number;
+    emitterSystem: EmitterSystemRecord;
+    location: Location;
+    beams: BeamData[];
+}
+/**
+ * Electromagnetic Emission (EE) PDU (Table 161).
+ * Header (96 bits), emitting entity ID, event ID, state/count, then N emitter system data blocks.
+ */
+export interface ElectromagneticEmissionPdu {
+    header: PduHeader;
+    emittingEntityId: EntityId;
+    eventId: EventId;
+    /** 8-bit enumeration. */
+    stateUpdateIndicator: number;
+    /** Number of emitter systems (N). */
+    numberOfSystems: number;
+    /** 16-bit padding. */
+    padding: number;
+    emitterSystems: EmitterSystemData[];
+}
+export declare function decodeElectromagneticEmissionPdu(reader: BinaryReader): ElectromagneticEmissionPdu;
+export declare function encodeElectromagneticEmissionPdu(writer: BinaryWriter, pdu: ElectromagneticEmissionPdu): void;

package/dist/dis7/electromagneticEmissionPdu.js

@@ -0,0 +1,133 @@
+import { decodeEntityId, encodeEntityId } from "../core/entityId.js";
+import { decodeEventId, encodeEventId } from "../core/eventId.js";
+import { decodePduHeader, encodePduHeader } from "./pduHeader.js";
+function decodeFundamentalParameterData(reader) {
+    return {
+        frequency: reader.readFloat32(),
+        frequencyRange: reader.readFloat32(),
+        effectiveRadiatedPower: reader.readFloat32(),
+        pulseRepetitionFrequency: reader.readFloat32(),
+        pulseWidth: reader.readFloat32(),
+    };
+}
+function encodeFundamentalParameterData(writer, data) {
+    writer.writeFloat32(data.frequency);
+    writer.writeFloat32(data.frequencyRange);
+    writer.writeFloat32(data.effectiveRadiatedPower);
+    writer.writeFloat32(data.pulseRepetitionFrequency);
+    writer.writeFloat32(data.pulseWidth);
+}
+function decodeBeamDataGroup(reader) {
+    return {
+        beamAzimuthCenter: reader.readFloat32(),
+        beamAzimuthSweep: reader.readFloat32(),
+        beamElevationCenter: reader.readFloat32(),
+        beamElevationSweep: reader.readFloat32(),
+        beamSweepSync: reader.readFloat32(),
+    };
+}
+function encodeBeamDataGroup(writer, data) {
+    writer.writeFloat32(data.beamAzimuthCenter);
+    writer.writeFloat32(data.beamAzimuthSweep);
+    writer.writeFloat32(data.beamElevationCenter);
+    writer.writeFloat32(data.beamElevationSweep);
+    writer.writeFloat32(data.beamSweepSync);
+}
+function decodeBeamData(reader) {
+    return {
+        beamDataLength: reader.readUint8(),
+        beamNumber: reader.readUint8(),
+        beamParameterIndex: reader.readUint16(),
+        fundamentalParameterData: decodeFundamentalParameterData(reader),
+        beamData: decodeBeamDataGroup(reader),
+        beamFunction: reader.readUint8(),
+        numberOfTargets: reader.readUint8(),
+        highDensityTrackJam: reader.readUint8(),
+        beamStatus: reader.readUint8(),
+    };
+}
+function encodeBeamData(writer, beam) {
+    writer.writeUint8(beam.beamDataLength);
+    writer.writeUint8(beam.beamNumber);
+    writer.writeUint16(beam.beamParameterIndex);
+    encodeFundamentalParameterData(writer, beam.fundamentalParameterData);
+    encodeBeamDataGroup(writer, beam.beamData);
+    writer.writeUint8(beam.beamFunction);
+    writer.writeUint8(beam.numberOfTargets);
+    writer.writeUint8(beam.highDensityTrackJam);
+    writer.writeUint8(beam.beamStatus);
+}
+function decodeEmitterSystemData(reader) {
+    const systemDataLength = reader.readUint8();
+    const numberOfBeams = reader.readUint8();
+    const padding = reader.readUint16();
+    const emitterSystem = {
+        emitterName: reader.readUint16(),
+        emitterFunction: reader.readUint8(),
+        emitterNumber: reader.readUint8(),
+    };
+    const location = {
+        x: reader.readFloat32(),
+        y: reader.readFloat32(),
+        z: reader.readFloat32(),
+    };
+    const beams = [];
+    for (let j = 0; j < numberOfBeams; j++) {
+        beams.push(decodeBeamData(reader));
+    }
+    return {
+        systemDataLength,
+        numberOfBeams,
+        padding,
+        emitterSystem,
+        location,
+        beams,
+    };
+}
+function encodeEmitterSystemData(writer, sys) {
+    writer.writeUint8(sys.systemDataLength);
+    writer.writeUint8(sys.numberOfBeams);
+    writer.writeUint16(sys.padding);
+    writer.writeUint16(sys.emitterSystem.emitterName);
+    writer.writeUint8(sys.emitterSystem.emitterFunction);
+    writer.writeUint8(sys.emitterSystem.emitterNumber);
+    writer.writeFloat32(sys.location.x);
+    writer.writeFloat32(sys.location.y);
+    writer.writeFloat32(sys.location.z);
+    for (const beam of sys.beams) {
+        encodeBeamData(writer, beam);
+    }
+}
+export function decodeElectromagneticEmissionPdu(reader) {
+    const header = decodePduHeader(reader);
+    const emittingEntityId = decodeEntityId(reader);
+    const eventId = decodeEventId(reader);
+    const stateUpdateIndicator = reader.readUint8();
+    const numberOfSystems = reader.readUint8();
+    const padding = reader.readUint16();
+    const emitterSystems = [];
+    for (let i = 0; i < numberOfSystems; i++) {
+        emitterSystems.push(decodeEmitterSystemData(reader));
+    }
+    return {
+        header,
+        emittingEntityId,
+        eventId,
+        stateUpdateIndicator,
+        numberOfSystems,
+        padding,
+        emitterSystems,
+    };
+}
+export function encodeElectromagneticEmissionPdu(writer, pdu) {
+    encodePduHeader(writer, pdu.header);
+    encodeEntityId(writer, pdu.emittingEntityId);
+    encodeEventId(writer, pdu.eventId);
+    writer.writeUint8(pdu.stateUpdateIndicator);
+    writer.writeUint8(pdu.numberOfSystems);
+    writer.writeUint16(pdu.padding);
+    for (const sys of pdu.emitterSystems) {
+        encodeEmitterSystemData(writer, sys);
+    }
+    writer.patchUint16(8, writer.getOffset());
+}

package/dist/dis7/entityStatePdu.d.ts

@@ -0,0 +1,80 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+import type { EntityId } from "../core/entityId.js";
+import type { PduHeader } from "./pduHeader.js";
+/** Entity type (64 bits): kind, domain, country, category, subcategory, specific, extra. */
+export interface EntityType {
+    kind: number;
+    domain: number;
+    country: number;
+    category: number;
+    subcategory: number;
+    specific: number;
+    extra: number;
+}
+/** Three-component vector (float32). */
+export interface Vector3Float {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Three-component vector (float64). */
+export interface Vector3Double {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Entity orientation: psi, theta, phi (radians, float32). */
+export interface Orientation {
+    psi: number;
+    theta: number;
+    phi: number;
+}
+/** Dead reckoning parameters (320 bits). */
+export interface DeadReckoningParameters {
+    /** 8-bit enumeration. */
+    deadReckoningAlgorithm: number;
+    /** Other parameters, 120 bits (15 bytes). */
+    otherParameters: Uint8Array;
+    entityLinearAcceleration: Vector3Float;
+    entityAngularVelocity: Vector3Float;
+}
+/** Entity marking: character set plus 11 characters (96 bits). */
+export interface EntityMarking {
+    /** 8-bit enumeration. */
+    characterSet: number;
+    /** 11 bytes (88 bits). */
+    characters: Uint8Array;
+}
+/** Variable parameter record (128 bits). */
+export interface VariableParameter {
+    /** 8-bit enumeration. */
+    recordType: number;
+    /** Record-specific fields, 120 bits (15 bytes). */
+    recordSpecific: Uint8Array;
+}
+/**
+ * Entity State PDU (Table 134).
+ * Fixed part 1152 bits (144 bytes), then N variable parameter records of 128 bits (16 bytes) each.
+ */
+export interface EntityStatePdu {
+    header: PduHeader;
+    entityId: EntityId;
+    /** 8-bit enumeration (e.g. Friendly, Opposing, Neutral). */
+    forceId: number;
+    numberOfVariableParameterRecords: number;
+    entityType: EntityType;
+    alternateEntityType: EntityType;
+    entityLinearVelocity: Vector3Float;
+    entityLocation: Vector3Double;
+    entityOrientation: Orientation;
+    /** 32-bit record. */
+    entityAppearance: number;
+    deadReckoningParameters: DeadReckoningParameters;
+    entityMarking: EntityMarking;
+    /** 32-bit record. */
+    capabilities: number;
+    variableParameters: VariableParameter[];
+}
+export declare function decodeEntityStatePdu(reader: BinaryReader): EntityStatePdu;
+export declare function encodeEntityStatePdu(writer: BinaryWriter, pdu: EntityStatePdu): void;

package/dist/dis7/entityStatePdu.js

@@ -0,0 +1,149 @@
+import { decodeEntityId, encodeEntityId } from "../core/entityId.js";
+import { decodePduHeader, encodePduHeader } from "./pduHeader.js";
+const DEAD_RECKONING_OTHER_BYTES = 15;
+const ENTITY_MARKING_CHARACTERS_BYTES = 11;
+const VARIABLE_PARAM_RECORD_SPECIFIC_BYTES = 15;
+function decodeEntityType(reader) {
+    return {
+        kind: reader.readUint8(),
+        domain: reader.readUint8(),
+        country: reader.readUint16(),
+        category: reader.readUint8(),
+        subcategory: reader.readUint8(),
+        specific: reader.readUint8(),
+        extra: reader.readUint8(),
+    };
+}
+function encodeEntityType(writer, e) {
+    writer.writeUint8(e.kind);
+    writer.writeUint8(e.domain);
+    writer.writeUint16(e.country);
+    writer.writeUint8(e.category);
+    writer.writeUint8(e.subcategory);
+    writer.writeUint8(e.specific);
+    writer.writeUint8(e.extra);
+}
+function decodeVector3Float(reader) {
+    return {
+        x: reader.readFloat32(),
+        y: reader.readFloat32(),
+        z: reader.readFloat32(),
+    };
+}
+function encodeVector3Float(writer, v) {
+    writer.writeFloat32(v.x);
+    writer.writeFloat32(v.y);
+    writer.writeFloat32(v.z);
+}
+function decodeVector3Double(reader) {
+    return {
+        x: reader.readFloat64(),
+        y: reader.readFloat64(),
+        z: reader.readFloat64(),
+    };
+}
+function encodeVector3Double(writer, v) {
+    writer.writeFloat64(v.x);
+    writer.writeFloat64(v.y);
+    writer.writeFloat64(v.z);
+}
+function decodeOrientation(reader) {
+    return {
+        psi: reader.readFloat32(),
+        theta: reader.readFloat32(),
+        phi: reader.readFloat32(),
+    };
+}
+function encodeOrientation(writer, o) {
+    writer.writeFloat32(o.psi);
+    writer.writeFloat32(o.theta);
+    writer.writeFloat32(o.phi);
+}
+function decodeDeadReckoningParameters(reader) {
+    return {
+        deadReckoningAlgorithm: reader.readUint8(),
+        otherParameters: reader.readBytes(DEAD_RECKONING_OTHER_BYTES),
+        entityLinearAcceleration: decodeVector3Float(reader),
+        entityAngularVelocity: decodeVector3Float(reader),
+    };
+}
+function encodeDeadReckoningParameters(writer, d) {
+    writer.writeUint8(d.deadReckoningAlgorithm);
+    writer.writeBytes(d.otherParameters);
+    encodeVector3Float(writer, d.entityLinearAcceleration);
+    encodeVector3Float(writer, d.entityAngularVelocity);
+}
+function decodeEntityMarking(reader) {
+    return {
+        characterSet: reader.readUint8(),
+        characters: reader.readBytes(ENTITY_MARKING_CHARACTERS_BYTES),
+    };
+}
+function encodeEntityMarking(writer, m) {
+    writer.writeUint8(m.characterSet);
+    writer.writeBytes(m.characters);
+}
+function decodeVariableParameter(reader) {
+    return {
+        recordType: reader.readUint8(),
+        recordSpecific: reader.readBytes(VARIABLE_PARAM_RECORD_SPECIFIC_BYTES),
+    };
+}
+function encodeVariableParameter(writer, v) {
+    writer.writeUint8(v.recordType);
+    writer.writeBytes(v.recordSpecific);
+}
+export function decodeEntityStatePdu(reader) {
+    const header = decodePduHeader(reader);
+    const entityId = decodeEntityId(reader);
+    const forceId = reader.readUint8();
+    const numberOfVariableParameterRecords = reader.readUint8();
+    const entityType = decodeEntityType(reader);
+    const alternateEntityType = decodeEntityType(reader);
+    const entityLinearVelocity = decodeVector3Float(reader);
+    const entityLocation = decodeVector3Double(reader);
+    const entityOrientation = decodeOrientation(reader);
+    const entityAppearance = reader.readUint32();
+    const deadReckoningParameters = decodeDeadReckoningParameters(reader);
+    const entityMarking = decodeEntityMarking(reader);
+    const capabilities = reader.readUint32();
+    const variableParameters = [];
+    for (let i = 0; i < numberOfVariableParameterRecords; i++) {
+        variableParameters.push(decodeVariableParameter(reader));
+    }
+    return {
+        header,
+        entityId,
+        forceId,
+        numberOfVariableParameterRecords,
+        entityType,
+        alternateEntityType,
+        entityLinearVelocity,
+        entityLocation,
+        entityOrientation,
+        entityAppearance,
+        deadReckoningParameters,
+        entityMarking,
+        capabilities,
+        variableParameters,
+    };
+}
+export function encodeEntityStatePdu(writer, pdu) {
+    encodePduHeader(writer, pdu.header);
+    encodeEntityId(writer, pdu.entityId);
+    writer.writeUint8(pdu.forceId);
+    writer.writeUint8(pdu.numberOfVariableParameterRecords);
+    encodeEntityType(writer, pdu.entityType);
+    encodeEntityType(writer, pdu.alternateEntityType);
+    encodeVector3Float(writer, pdu.entityLinearVelocity);
+    encodeVector3Double(writer, pdu.entityLocation);
+    encodeOrientation(writer, pdu.entityOrientation);
+    writer.writeUint32(pdu.entityAppearance);
+    encodeDeadReckoningParameters(writer, pdu.deadReckoningParameters);
+    encodeEntityMarking(writer, pdu.entityMarking);
+    writer.writeUint32(pdu.capabilities);
+    for (const vp of pdu.variableParameters) {
+        encodeVariableParameter(writer, vp);
+    }
+    writer.patchUint16(8, writer.getOffset());
+}

package/dist/dis7/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * DIS 7 codecs and constants. Version is in the path; names stay clean for dis8/ etc.
+ */
+export { PROTOCOL_VERSION, PROTOCOL_FAMILY_ENTITY_INFORMATION, PROTOCOL_FAMILY_SIMULATION_MANAGEMENT, PROTOCOL_FAMILY_ELECTROMAGNETIC_EMISSION, PDU_TYPE_ENTITY_STATE, PDU_TYPE_CREATE_ENTITY, PDU_TYPE_REMOVE_ENTITY, PDU_TYPE_START_RESUME, PDU_TYPE_STOP_FREEZE, PDU_TYPE_ELECTROMAGNETIC_EMISSION, PDU_TYPE_TRANSMITTER, PROTOCOL_FAMILY_RADIO_COMMUNICATIONS, START_RESUME_PDU_LENGTH, STOP_FREEZE_PDU_LENGTH, CREATE_ENTITY_PDU_LENGTH, REMOVE_ENTITY_PDU_LENGTH, ENTITY_STATE_PDU_FIXED_LENGTH, ENTITY_STATE_VARIABLE_PARAMETER_RECORD_LENGTH, TRANSMITTER_PDU_FIXED_LENGTH, } from "./constants.js";
+export { type PduHeader, decodePduHeader, encodePduHeader, } from "./pduHeader.js";
+export { type EntityStatePdu, type EntityType, type Vector3Float, type Vector3Double, type Orientation, type DeadReckoningParameters, type EntityMarking, type VariableParameter, decodeEntityStatePdu, encodeEntityStatePdu, } from "./entityStatePdu.js";
+export { type CreateEntityPdu, decodeCreateEntityPdu, encodeCreateEntityPdu, } from "./createEntityPdu.js";
+export { type RemoveEntityPdu, decodeRemoveEntityPdu, encodeRemoveEntityPdu, } from "./removeEntityPdu.js";
+export { type StartResumePdu, decodeStartResumePdu, encodeStartResumePdu, } from "./startResumePdu.js";
+export { type StopFreezePdu, decodeStopFreezePdu, encodeStopFreezePdu, } from "./stopFreezePdu.js";
+export { type ElectromagneticEmissionPdu, type EmitterSystemData, type BeamData, type FundamentalParameterData, type BeamDataGroup, type EmitterSystemRecord, type Location, decodeElectromagneticEmissionPdu, encodeElectromagneticEmissionPdu, } from "./electromagneticEmissionPdu.js";
+export { type TransmitterPdu, type RadioType, type ModulationType, type BeamAntennaPattern, type VariableTransmitterParameter, BEAM_ANTENNA_PATTERN_LENGTH, decodeTransmitterPdu, encodeTransmitterPdu, } from "./transmitterPdu.js";

package/dist/dis7/index.js

@@ -0,0 +1,12 @@
+/**
+ * DIS 7 codecs and constants. Version is in the path; names stay clean for dis8/ etc.
+ */
+export { PROTOCOL_VERSION, PROTOCOL_FAMILY_ENTITY_INFORMATION, PROTOCOL_FAMILY_SIMULATION_MANAGEMENT, PROTOCOL_FAMILY_ELECTROMAGNETIC_EMISSION, PDU_TYPE_ENTITY_STATE, PDU_TYPE_CREATE_ENTITY, PDU_TYPE_REMOVE_ENTITY, PDU_TYPE_START_RESUME, PDU_TYPE_STOP_FREEZE, PDU_TYPE_ELECTROMAGNETIC_EMISSION, PDU_TYPE_TRANSMITTER, PROTOCOL_FAMILY_RADIO_COMMUNICATIONS, START_RESUME_PDU_LENGTH, STOP_FREEZE_PDU_LENGTH, CREATE_ENTITY_PDU_LENGTH, REMOVE_ENTITY_PDU_LENGTH, ENTITY_STATE_PDU_FIXED_LENGTH, ENTITY_STATE_VARIABLE_PARAMETER_RECORD_LENGTH, TRANSMITTER_PDU_FIXED_LENGTH, } from "./constants.js";
+export { decodePduHeader, encodePduHeader, } from "./pduHeader.js";
+export { decodeEntityStatePdu, encodeEntityStatePdu, } from "./entityStatePdu.js";
+export { decodeCreateEntityPdu, encodeCreateEntityPdu, } from "./createEntityPdu.js";
+export { decodeRemoveEntityPdu, encodeRemoveEntityPdu, } from "./removeEntityPdu.js";
+export { decodeStartResumePdu, encodeStartResumePdu, } from "./startResumePdu.js";
+export { decodeStopFreezePdu, encodeStopFreezePdu, } from "./stopFreezePdu.js";
+export { decodeElectromagneticEmissionPdu, encodeElectromagneticEmissionPdu, } from "./electromagneticEmissionPdu.js";
+export { BEAM_ANTENNA_PATTERN_LENGTH, decodeTransmitterPdu, encodeTransmitterPdu, } from "./transmitterPdu.js";

package/dist/dis7/pduHeader.d.ts

@@ -0,0 +1,18 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+/**
+ * Standard PDU header (12 bytes). Layout is version-specific; this module is DIS 7.
+ */
+export interface PduHeader {
+    protocolVersion: number;
+    exerciseId: number;
+    pduType: number;
+    protocolFamily: number;
+    timestamp: number;
+    /** Total PDU size in bytes, including this header. */
+    length: number;
+    pduStatus: number;
+    padding: number;
+}
+export declare function decodePduHeader(reader: BinaryReader): PduHeader;
+export declare function encodePduHeader(writer: BinaryWriter, header: PduHeader): void;

package/dist/dis7/pduHeader.js

@@ -0,0 +1,22 @@
+export function decodePduHeader(reader) {
+    return {
+        protocolVersion: reader.readUint8(),
+        exerciseId: reader.readUint8(),
+        pduType: reader.readUint8(),
+        protocolFamily: reader.readUint8(),
+        timestamp: reader.readUint32(),
+        length: reader.readUint16(),
+        pduStatus: reader.readUint8(),
+        padding: reader.readUint8(),
+    };
+}
+export function encodePduHeader(writer, header) {
+    writer.writeUint8(header.protocolVersion);
+    writer.writeUint8(header.exerciseId);
+    writer.writeUint8(header.pduType);
+    writer.writeUint8(header.protocolFamily);
+    writer.writeUint32(header.timestamp);
+    writer.writeUint16(header.length);
+    writer.writeUint8(header.pduStatus);
+    writer.writeUint8(header.padding);
+}

package/dist/dis7/removeEntityPdu.d.ts

@@ -0,0 +1,13 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+import type { EntityId } from "../core/entityId.js";
+import type { PduHeader } from "./pduHeader.js";
+/** Remove Entity PDU (224 bits). Table 150. */
+export interface RemoveEntityPdu {
+    header: PduHeader;
+    originatingId: EntityId;
+    receivingId: EntityId;
+    requestId: number;
+}
+export declare function decodeRemoveEntityPdu(reader: BinaryReader): RemoveEntityPdu;
+export declare function encodeRemoveEntityPdu(writer: BinaryWriter, pdu: RemoveEntityPdu): void;

package/dist/dis7/removeEntityPdu.js

@@ -0,0 +1,17 @@
+import { decodeEntityId, encodeEntityId } from "../core/entityId.js";
+import { decodePduHeader, encodePduHeader } from "./pduHeader.js";
+export function decodeRemoveEntityPdu(reader) {
+    return {
+        header: decodePduHeader(reader),
+        originatingId: decodeEntityId(reader),
+        receivingId: decodeEntityId(reader),
+        requestId: reader.readUint32(),
+    };
+}
+export function encodeRemoveEntityPdu(writer, pdu) {
+    encodePduHeader(writer, pdu.header);
+    encodeEntityId(writer, pdu.originatingId);
+    encodeEntityId(writer, pdu.receivingId);
+    writer.writeUint32(pdu.requestId);
+    writer.patchUint16(8, writer.getOffset());
+}

package/dist/dis7/startResumePdu.d.ts

@@ -0,0 +1,16 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+import type { EntityId } from "../core/entityId.js";
+import type { ClockTime } from "../dis/clockTime.js";
+import type { PduHeader } from "./pduHeader.js";
+/** Start/Resume PDU (352 bits). */
+export interface StartResumePdu {
+    header: PduHeader;
+    originatingId: EntityId;
+    receivingId: EntityId;
+    realWorldTime: ClockTime;
+    simulationTime: ClockTime;
+    requestId: number;
+}
+export declare function decodeStartResumePdu(reader: BinaryReader): StartResumePdu;
+export declare function encodeStartResumePdu(writer: BinaryWriter, pdu: StartResumePdu): void;

package/dist/dis7/startResumePdu.js

@@ -0,0 +1,22 @@
+import { decodeEntityId, encodeEntityId } from "../core/entityId.js";
+import { decodeClockTime, encodeClockTime } from "../dis/clockTime.js";
+import { decodePduHeader, encodePduHeader } from "./pduHeader.js";
+export function decodeStartResumePdu(reader) {
+    return {
+        header: decodePduHeader(reader),
+        originatingId: decodeEntityId(reader),
+        receivingId: decodeEntityId(reader),
+        realWorldTime: decodeClockTime(reader),
+        simulationTime: decodeClockTime(reader),
+        requestId: reader.readUint32(),
+    };
+}
+export function encodeStartResumePdu(writer, pdu) {
+    encodePduHeader(writer, pdu.header);
+    encodeEntityId(writer, pdu.originatingId);
+    encodeEntityId(writer, pdu.receivingId);
+    encodeClockTime(writer, pdu.realWorldTime);
+    encodeClockTime(writer, pdu.simulationTime);
+    writer.writeUint32(pdu.requestId);
+    writer.patchUint16(8, writer.getOffset());
+}

package/dist/dis7/stopFreezePdu.d.ts

@@ -0,0 +1,21 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+import type { EntityId } from "../core/entityId.js";
+import type { ClockTime } from "../dis/clockTime.js";
+import type { PduHeader } from "./pduHeader.js";
+/** Stop/Freeze PDU (320 bits). */
+export interface StopFreezePdu {
+    header: PduHeader;
+    originatingId: EntityId;
+    receivingId: EntityId;
+    realWorldTime: ClockTime;
+    /** 8-bit enumeration: why the entity/exercise was stopped or frozen. */
+    reason: number;
+    /** 8-bit record: internal behavior and appearance while frozen. */
+    frozenBehavior: number;
+    /** 16-bit padding (unused on wire). */
+    padding: number;
+    requestId: number;
+}
+export declare function decodeStopFreezePdu(reader: BinaryReader): StopFreezePdu;
+export declare function encodeStopFreezePdu(writer: BinaryWriter, pdu: StopFreezePdu): void;