@kar-mi/spirit-vale-tools-capture 2.4.1

package/dist/fishnet/builtin-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-maps.d.ts","sourceRoot":"","sources":["../../src/fishnet/builtin-maps.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAMhD,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEA,CAAC;AAEX,MAAM,MAAM,8BAA8B,GAAG,MAAM,OAAO,IAAI,CAAC;AAE/D,wBAAgB,wBAAwB,CACtC,gBAAgB,GAAE,MAAuC,GACxD,aAAa,CAQf"}

package/dist/fishnet/character-data-schema.d.ts

@@ -0,0 +1,3 @@
+import type { FishNetRpcParameter } from "./types.ts";
+export declare function characterDataParameter(): FishNetRpcParameter;
+//# sourceMappingURL=character-data-schema.d.ts.map

package/dist/fishnet/character-data-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-data-schema.d.ts","sourceRoot":"","sources":["../../src/fishnet/character-data-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAItD,wBAAgB,sBAAsB,IAAI,mBAAmB,CAS5D"}

package/dist/fishnet/decoder.d.ts

@@ -0,0 +1,12 @@
+import { FishNetProtocolError } from "./protocol.ts";
+import { FishNetSessionDecoder } from "./session-decoder.ts";
+import type { DecodedFishNetPacket, FishNetDecodeOptions, FishNetRpcMap } from "./types.ts";
+export { FishNetProtocolError, FishNetSessionDecoder };
+/** Decodes one FishNet message with its transport tick. */
+export declare function decodeFishNetPayload(payload: Buffer, options?: {
+    reliable: boolean;
+    rpcMap?: FishNetRpcMap;
+}): DecodedFishNetPacket;
+/** Decodes all safely-delimited messages in one FishNet transport payload. */
+export declare function decodeFishNetBundle(payload: Buffer, options?: FishNetDecodeOptions): DecodedFishNetPacket[];
+//# sourceMappingURL=decoder.d.ts.map

package/dist/fishnet/decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../src/fishnet/decoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,oBAAoB,EAAoB,MAAM,eAAe,CAAC;AAEvF,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EAEd,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;AAEvD,2DAA2D;AAC3D,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,aAAa,CAAA;CAAwB,GAC3E,oBAAoB,CAiDtB;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAA0C,GAClD,oBAAoB,EAAE,CAExB"}

package/dist/fishnet/definitions/codecs.d.ts

@@ -0,0 +1,12 @@
+export type FishNetWireCodec = "boolean" | "uint8" | "int8" | "uint16" | "int16" | "uint32" | "int32" | "float32" | "float64" | "packedInt32" | "packedInt64" | "packedInt32Array" | "packedUInt64" | "stringUtf8Packed" | "vector3IntPacked" | "vector2" | "vector3" | "quaternion";
+export type FishNetDecodedValue = boolean | number | string | number[] | null;
+export interface FishNetDecodedField {
+    name: string;
+    typeName?: string;
+    /** `nullable` identifies the generated reference-value wrapper rather than a leaf codec. */
+    codec: FishNetWireCodec | "nullable";
+    value: FishNetDecodedValue;
+    /** Public game-data label resolved for known IDs (currently mapId). */
+    resolvedName?: string;
+}
+//# sourceMappingURL=codecs.d.ts.map

package/dist/fishnet/definitions/codecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../../src/fishnet/definitions/codecs.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,OAAO,GACP,MAAM,GACN,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,aAAa,GACb,aAAa,GACb,kBAAkB,GAClB,cAAc,GACd,kBAAkB,GAClB,kBAAkB,GAClB,SAAS,GACT,SAAS,GACT,YAAY,CAAC;AAEjB,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;AAE9E,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4FAA4F;IAC5F,KAAK,EAAE,gBAAgB,GAAG,UAAU,CAAC;IACrC,KAAK,EAAE,mBAAmB,CAAC;IAC3B,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/dist/fishnet/definitions/protocol.d.ts

@@ -0,0 +1,101 @@
+import type { CapturedLiteNetLibPacket } from "../../litenetlib/types.ts";
+import type { FishNetDecodedField } from "./codecs.ts";
+import type { FishNetRpcMap } from "./rpc-map.ts";
+import type { DecodedNetworkTransform } from "../network-transform-decoder.ts";
+export type FishNetPacketName = "unset" | "authenticated" | "split" | "objectSpawn" | "objectDespawn" | "predictedSpawnResult" | "syncType" | "serverRpc" | "observersRpc" | "targetRpc" | "ownershipChange" | "broadcast" | "bulkSpawnOrDespawn" | "pingPong" | "replicate" | "reconcile" | "disconnect" | "timingUpdate" | "unused2" | "stateUpdate" | "version" | "rpcLink" | "unknown";
+export type FishNetRpcPacketName = "serverRpc" | "observersRpc" | "targetRpc" | "reconcile";
+export type FishNetRpcResolution = "verified" | "recovered" | "ambiguous" | "unresolved";
+export interface FishNetDecodeOptions {
+    reliable: boolean;
+    rpcMap?: FishNetRpcMap;
+    /** Stable identifier for one transport connection. Defaults to a single shared session. */
+    connectionId?: string | number;
+    /** Split reassembly is isolated by direction and channel. */
+    direction?: "inbound" | "outbound" | string;
+    channel?: number;
+    /** Optional reliable transport sequence, used to ignore duplicate split fragments. */
+    sequence?: number;
+}
+export interface FishNetRpcLinkRegistration {
+    linkId: number;
+    objectId: number;
+    componentIndex: number;
+    rpcHash: number;
+    packetName: FishNetRpcPacketName;
+    networkBehaviourType?: string;
+}
+/** One SyncType written into a length-delimited body, identified by its per-behaviour index. */
+export interface FishNetSyncEntry {
+    index: number;
+    name: string;
+    fields: FishNetDecodedField[];
+}
+/** A SyncType carried inside an ObjectSpawn, which names the component it belongs to. */
+export interface FishNetSpawnSyncEntry extends FishNetSyncEntry {
+    componentIndex: number;
+    networkBehaviourType?: string;
+}
+export interface DecodedFishNetPacket {
+    tick: number;
+    packetId: number;
+    packetName: FishNetPacketName;
+    raw: Buffer;
+    payload: Buffer;
+    objectId?: number;
+    /** FishNet session-local owner connection ID; -1 denotes no owner. */
+    ownerConnectionId?: number;
+    networkBehaviourIndex?: number;
+    rpcPayloadLength?: number;
+    rpcHash?: number;
+    rpcHash16Candidate?: number;
+    rpcName?: string;
+    rpcResolution?: FishNetRpcResolution;
+    networkBehaviourType?: string;
+    decodedFields?: FishNetDecodedField[];
+    undecodedPayload?: Buffer;
+    bundleIndex?: number;
+    linkId?: number;
+    linkedPacketName?: FishNetRpcPacketName;
+    linkResolved?: boolean;
+    registeredObjectId?: number;
+    registeredComponentIndex?: number;
+    registeredRpcHash?: number;
+    spawnType?: "scene" | "instantiated" | "predicted";
+    spawnCollectionId?: number;
+    spawnPrefabId?: number;
+    spawnSceneId?: bigint;
+    spawnNested?: boolean;
+    /** Game-defined WritePayload bytes embedded in an ObjectSpawn packet. */
+    spawnCustomPayload?: Buffer;
+    /** Initial per-behaviour SyncType bytes embedded in an ObjectSpawn packet. */
+    spawnSyncPayload?: Buffer;
+    /** SyncTypes decoded from {@link spawnSyncPayload}, in wire order. */
+    spawnSyncEntries?: FishNetSpawnSyncEntry[];
+    /** World position the object spawned at, when the spawn carries the position flag. */
+    spawnLocalPosition?: readonly [number, number, number];
+    /** Spawn rotation as `[x, y, z, w]`, decoded from whichever quaternion packing the spawn carried. */
+    spawnLocalRotation?: readonly [number, number, number, number];
+    /** Yaw (radians, about the world up axis) derived from {@link spawnLocalRotation}. */
+    spawnHeading?: number;
+    /** Spawn scale, when the spawn carries the scale flag. */
+    spawnLocalScale?: readonly [number, number, number];
+    rpcLinkRegistrations?: FishNetRpcLinkRegistration[];
+    syncPayload?: Buffer;
+    /** First SyncType index in the length-delimited body. */
+    syncIndex?: number;
+    syncName?: string;
+    /** Every SyncType entry decoded from the body, in wire order. */
+    syncEntries?: FishNetSyncEntry[];
+    broadcastHash?: number;
+    broadcastName?: string;
+    /** Movement decoded from a NetworkTransform update RPC. */
+    networkTransform?: DecodedNetworkTransform;
+    /** Set when split reassembly was abandoned and the accumulated bundle was dropped. */
+    splitDropReason?: "header" | "chunk-count" | "size-cap";
+}
+export interface CapturedFishNetPacket extends DecodedFishNetPacket {
+    liteNetPacket: CapturedLiteNetLibPacket;
+    /** Transport connection this packet was decoded from (endpoints + LiteNetLib connection number). */
+    connectionId: string;
+}
+//# sourceMappingURL=protocol.d.ts.map

package/dist/fishnet/definitions/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../src/fishnet/definitions/protocol.ts"],"names":[],"mappings":"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"}

package/dist/fishnet/definitions/rpc-map.d.ts

@@ -0,0 +1,61 @@
+import type { FishNetWireCodec } from "./codecs.ts";
+import type { FishNetRpcPacketName } from "./protocol.ts";
+export interface FishNetRpcParameter {
+    readonly name: string;
+    readonly typeName?: string;
+    /** Generated reference-type writer prefixes the structured value with FishNet's null flag. */
+    readonly nullable?: boolean;
+    /** Present only when the generated writer call established the exact wire codec. */
+    readonly codec?: FishNetWireCodec;
+    /** Ordered fields for a generated structured writer. Leaf fields carry codecs. */
+    readonly fields?: readonly FishNetRpcParameter[];
+    /** The fields are a verified leading prefix; additional trailing bytes remain explicitly undecoded. */
+    readonly prefix?: boolean;
+    /** This field is a `List<T>`/array: a packed signed count, then that many elements, each shaped by this same parameter's `codec`/`nullable`/`fields`. */
+    readonly repeated?: boolean;
+    readonly dictionaryKey?: "stringUtf8Packed";
+}
+export interface FishNetRpcDefinition {
+    readonly wireHash: number;
+    readonly packetKind: FishNetRpcPacketName;
+    readonly methodName: string;
+    readonly parameters?: readonly FishNetRpcParameter[];
+}
+export interface FishNetSyncTypeDefinition {
+    readonly index: number;
+    readonly name: string;
+    readonly typeName?: string;
+    readonly codec?: FishNetWireCodec;
+    /** Ordered fields for a structured SyncType value. Leaf fields carry codecs. */
+    readonly fields?: readonly FishNetRpcParameter[];
+}
+export interface FishNetBehaviourDefinition {
+    readonly typeName: string;
+    readonly rpcs: readonly FishNetRpcDefinition[];
+    readonly syncTypes?: readonly FishNetSyncTypeDefinition[];
+}
+export interface FishNetBroadcastDefinition {
+    readonly wireHash: number;
+    readonly typeName: string;
+    readonly fields?: readonly FishNetRpcParameter[];
+}
+export interface FishNetPrefabComponentDefinition {
+    readonly index: number;
+    readonly typeName: string;
+}
+/** A verified NetworkBehaviour layout for one entry in a FishNet spawnable-prefab collection. */
+export interface FishNetPrefabDefinition {
+    readonly collectionId: number;
+    readonly prefabId: number;
+    /** Serialized prefab name. */
+    readonly prefabName?: string;
+    readonly components: readonly FishNetPrefabComponentDefinition[];
+}
+export interface FishNetRpcMap {
+    readonly buildFingerprint: string;
+    readonly metadataVersion: number;
+    readonly behaviours: readonly FishNetBehaviourDefinition[];
+    readonly broadcasts?: readonly FishNetBroadcastDefinition[];
+    readonly prefabs?: readonly FishNetPrefabDefinition[];
+}
+//# sourceMappingURL=rpc-map.d.ts.map

package/dist/fishnet/definitions/rpc-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-map.d.ts","sourceRoot":"","sources":["../../../src/fishnet/definitions/rpc-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,8FAA8F;IAC9F,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,oFAAoF;IACpF,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACjD,uGAAuG;IACvG,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,yJAAyJ;IACzJ,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,kBAAkB,CAAC;CAC7C;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACtD;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,gFAAgF;IAChF,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAClD;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC/C,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,yBAAyB,EAAE,CAAC;CAC3D;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAClD;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,iGAAiG;AACjG,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8BAA8B;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,SAAS,gCAAgC,EAAE,CAAC;CAClE;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC3D,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC5D,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAC;CACvD"}

package/dist/fishnet/eternal-tower-tracker.d.ts

@@ -0,0 +1,24 @@
+import type { CapturedFishNetPacket } from "./types.ts";
+export interface FishNetEternalTowerSnapshot {
+    /** False until a DrawTitle/ClientInstancedMapReady with the "et" binding slot has been observed. */
+    known: boolean;
+    inTower: boolean;
+    floor?: number;
+    /** The tower's own display name, e.g. "The Echoing Spire" - the prefix of the DrawTitle banner. */
+    towerName?: string;
+    instanceId?: number;
+    instancedMapId?: string;
+    source?: "DrawTitle" | "ClientInstancedMapReady";
+    updatedTick?: number;
+}
+export declare class FishNetEternalTowerTracker {
+    private snapshot;
+    /** Returns true only when this packet changed the exposed tower state. */
+    consume(packet: CapturedFishNetPacket): boolean;
+    current(): FishNetEternalTowerSnapshot;
+    reset(): boolean;
+    private consumeDrawTitle;
+    private consumeMapReady;
+    private replace;
+}
+//# sourceMappingURL=eternal-tower-tracker.d.ts.map

package/dist/fishnet/eternal-tower-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eternal-tower-tracker.d.ts","sourceRoot":"","sources":["../../src/fishnet/eternal-tower-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAuB,MAAM,YAAY,CAAC;AAE7E,MAAM,WAAW,2BAA2B;IAC1C,oGAAoG;IACpG,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mGAAmG;IACnG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,GAAG,yBAAyB,CAAC;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAOD,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAA6C;IAE7D,0EAA0E;IAC1E,OAAO,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAK9C;IAED,OAAO,IAAI,2BAA2B,CAErC;IAED,KAAK,IAAI,OAAO,CAIf;IAED,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,OAAO;CAKhB"}

package/dist/fishnet/field-decoder.d.ts

@@ -0,0 +1,19 @@
+import type { DecodedFishNetPacket, FishNetDecodedField, FishNetRpcParameter } from "./types.ts";
+export declare function applyDecodedFields(packet: DecodedFishNetPacket, parameters: readonly FishNetRpcParameter[] | undefined, startOffset?: number): void;
+/** Fields decoded from one entry, with the offset the next entry starts at. */
+export interface FieldDecodeRun {
+    fields: FishNetDecodedField[];
+    consumed: number;
+    complete: boolean;
+}
+/** Decodes one parameter list and reports where it ended, so a caller walking several concatenated entries in one payload can find the next boundary. */
+export declare function decodeFieldRun(payload: Buffer, parameters: readonly FishNetRpcParameter[] | undefined, startOffset?: number): FieldDecodeRun;
+/** Decode result for callers that need to know whether a payload actually *fits* a signature rather than just how much of it could be read. */
+export interface FieldDecodeFit {
+    consumed: number;
+    complete: boolean;
+    undecodable: boolean;
+}
+/** Strict, non-mutating decode of one payload against one parameter list. */
+export declare function tryDecodeFields(payload: Buffer, parameters: readonly FishNetRpcParameter[] | undefined, startOffset?: number): FieldDecodeFit;
+//# sourceMappingURL=field-decoder.d.ts.map

package/dist/fishnet/field-decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-decoder.d.ts","sourceRoot":"","sources":["../../src/fishnet/field-decoder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EAEnB,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,oBAAoB,EAC5B,UAAU,EAAE,SAAS,mBAAmB,EAAE,GAAG,SAAS,EACtD,WAAW,SAAI,GACd,IAAI,CAMN;AAED,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,yJAAyJ;AACzJ,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,SAAS,mBAAmB,EAAE,GAAG,SAAS,EACtD,WAAW,SAAI,GACd,cAAc,CAOhB;AAED,+IAA+I;AAC/I,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,6EAA6E;AAC7E,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,SAAS,mBAAmB,EAAE,GAAG,SAAS,EACtD,WAAW,SAAI,GACd,cAAc,CAOhB"}

package/dist/fishnet/map-definitions/current-build.d.ts

@@ -0,0 +1,3 @@
+/** Generated from the matched current-build static map catalog. */
+export declare const CURRENT_BUILD_MAP_NAMES: Readonly<Record<number, string>>;
+//# sourceMappingURL=current-build.d.ts.map

package/dist/fishnet/map-definitions/current-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-build.d.ts","sourceRoot":"","sources":["../../../src/fishnet/map-definitions/current-build.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYpE,CAAC"}

package/dist/fishnet/map-definitions/index.d.ts

@@ -0,0 +1,3 @@
+/** Returns the public display name for a current-build FishNet map ID. */
+export declare function resolveBundledMapName(mapId: number, buildFingerprint?: string): string | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/fishnet/map-definitions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fishnet/map-definitions/index.ts"],"names":[],"mappings":"AAOA,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAuC,GAAG,MAAM,GAAG,SAAS,CAElI"}

package/dist/fishnet/message-parser.d.ts

@@ -0,0 +1,17 @@
+import type { RpcLinkRegistrationState } from "./protocol.ts";
+import type { DecodedFishNetPacket, FishNetDecodeOptions } from "./types.ts";
+export interface ConnectionState {
+    links: Map<number, RpcLinkRegistrationState>;
+    components: Map<string, string>;
+    staleLinks: Map<number, RpcLinkRegistrationState>;
+    staleComponents: Map<string, string>;
+}
+export interface ParsedMessage {
+    packet: DecodedFishNetPacket;
+    end: number;
+    stop: boolean;
+    registrations?: Array<[number, RpcLinkRegistrationState]>;
+    componentBindings?: Array<[string, string]>;
+}
+export declare function parseMessage(buffer: Buffer, start: number, tick: number, bundleIndex: number, state: ConnectionState, options: FishNetDecodeOptions): ParsedMessage;
+//# sourceMappingURL=message-parser.d.ts.map

package/dist/fishnet/message-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-parser.d.ts","sourceRoot":"","sources":["../../src/fishnet/message-parser.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAsB9D,OAAO,KAAK,EACV,oBAAoB,EAEpB,oBAAoB,EAKrB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;IAC7C,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;IAClD,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,oBAAoB,CAAC;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,OAAO,CAAC;IACd,aAAa,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC,CAAC;IAC1D,iBAAiB,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC7C;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,oBAAoB,GAC5B,aAAa,CAiIf"}

package/dist/fishnet/monster-directory.d.ts

@@ -0,0 +1,40 @@
+/** Tracks which monster type each spawned network object is, from the spawn and sync packets the server sends when a monster comes into view. */
+import type { DecodedFishNetPacket } from "./types.ts";
+export interface FishNetMonsterSpawn {
+    mobId: string;
+    level: number;
+    rank?: number;
+}
+export type FishNetMonsterDirectoryChange = {
+    operation: "upsert";
+    objectId: number;
+    spawn: FishNetMonsterSpawn;
+} | {
+    operation: "remove";
+    objectId: number;
+} | {
+    operation: "reset";
+};
+/** The spawn payload is scanned at arbitrary offsets, so a known mob's catalog level is what disambiguates a real match from a coincidental one. */
+export interface FishNetMonsterLevels {
+    get(mobId: string): {
+        readonly level: number;
+    } | undefined;
+}
+export declare class FishNetMonsterDirectory {
+    private readonly levels;
+    private readonly objects;
+    constructor(levels: FishNetMonsterLevels);
+    /** Returns the identity change caused by this packet, suppressing repeated identical syncs. */
+    consume(packet: DecodedFishNetPacket): FishNetMonsterDirectoryChange | undefined;
+    get(objectId: number): FishNetMonsterSpawn | undefined;
+    reset(): void;
+    private set;
+}
+/** Reads a monster's identity from its spawn's embedded `Data` (`MonsterDto`) SyncType entry, decoded structurally from the rpc map rather than scanned for. */
+export declare function decodeMonsterSpawn(packet: DecodedFishNetPacket, levels: FishNetMonsterLevels): {
+    mobId: string;
+    level: number;
+    rank?: number;
+} | undefined;
+//# sourceMappingURL=monster-directory.d.ts.map

package/dist/fishnet/monster-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monster-directory.d.ts","sourceRoot":"","sources":["../../src/fishnet/monster-directory.ts"],"names":[],"mappings":"AAAA,iJAAiJ;AAEjJ,OAAO,KAAK,EAAE,oBAAoB,EAAuB,MAAM,YAAY,CAAC;AAE5E,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,6BAA6B,GACrC;IAAE,SAAS,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,GACrE;IAAE,SAAS,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC;AAE3B,oJAAoJ;AACpJ,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;CAC5D;AAED,qBAAa,uBAAuB;IAGtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0C;IAElE,YAA6B,MAAM,EAAE,oBAAoB,EAAI;IAE7D,+FAA+F;IAC/F,OAAO,CAAC,MAAM,EAAE,oBAAoB,GAAG,6BAA6B,GAAG,SAAS,CA0B/E;IAED,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAGrD;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,OAAO,CAAC,GAAG;CAQZ;AAED,gKAAgK;AAChK,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAU7D"}

package/dist/fishnet/network-transform-decoder.d.ts

@@ -0,0 +1,25 @@
+import { type Quaternion } from "./quaternion-compression.ts";
+/** Axes carried by one update. */
+export interface NetworkTransformAxes {
+    x?: number;
+    y?: number;
+    z?: number;
+}
+export interface DecodedNetworkTransform {
+    position: NetworkTransformAxes;
+    scale?: NetworkTransformAxes;
+    /** Width in bytes of the rotation the update carried, when it carried one. */
+    rotationBytes?: number;
+    /** The rotation as `[x, y, z, w]`, decoded from whichever packing `rotationBytes` names. */
+    rotation?: Quaternion;
+    /** Yaw (radians, about the world up axis) derived from {@link rotation}. */
+    heading?: number;
+    /** True when the update also carried a parent NetworkBehaviour reference, which is not decoded. */
+    reparented?: boolean;
+    /** Bytes consumed from the start of the payload, including the segment's length prefix. */
+    consumed: number;
+}
+export declare function decodeNetworkTransformData(payload: Buffer): DecodedNetworkTransform | undefined;
+/** RPCs whose single `ArraySegment<byte>` parameter carries a NetworkTransform update. */
+export declare const NETWORK_TRANSFORM_RPC_NAMES: ReadonlySet<string>;
+//# sourceMappingURL=network-transform-decoder.d.ts.map

package/dist/fishnet/network-transform-decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-transform-decoder.d.ts","sourceRoot":"","sources":["../../src/fishnet/network-transform-decoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,KAAK,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAoB/F,kCAAkC;AAClC,MAAM,WAAW,oBAAoB;IACnC,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,KAAK,CAAC,EAAE,oBAAoB,CAAC;IAC7B,8EAA8E;IAC9E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,2FAA2F;IAC3F,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS,CAW/F;AAyGD,0FAA0F;AAC1F,eAAO,MAAM,2BAA2B,EAAE,WAAW,CAAC,MAAM,CAI1D,CAAC"}

package/dist/fishnet/protocol.d.ts

@@ -0,0 +1,21 @@
+import type { DecodedFishNetPacket, FishNetPacketName, FishNetRpcPacketName } from "./types.ts";
+export declare const STARTING_RPC_LINK_ID = 22;
+export declare const RPC_PACKET_NAMES: Set<FishNetPacketName>;
+export declare const LINKED_PACKET_NAMES: Map<number, FishNetRpcPacketName>;
+export interface RpcLinkRegistrationState {
+    objectId: number;
+    componentIndex: number;
+    rpcHash: number;
+    packetName: FishNetRpcPacketName;
+    networkBehaviourType?: string;
+}
+export declare class FishNetProtocolError extends Error {
+    constructor(message: string);
+}
+export declare function classifyPacket(packetId: number): FishNetPacketName;
+export declare function isPlausibleBoundary(buffer: Buffer, offset: number): boolean;
+export declare function componentKey(objectId: number, componentIndex: number): string;
+export declare function basePacket(buffer: Buffer, start: number, end: number, tick: number, bundleIndex: number, packetId: number, packetName: FishNetPacketName): DecodedFishNetPacket;
+export declare function opaquePacket(buffer: Buffer, start: number, tick: number, bundleIndex: number, packetName?: FishNetPacketName): DecodedFishNetPacket;
+export declare function unresolvedLinkPacket(buffer: Buffer, start: number, tick: number, bundleIndex: number, packetId: number): DecodedFishNetPacket;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/fishnet/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/fishnet/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAWpB,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,gBAAgB,wBAAyE,CAAC;AACvG,eAAO,MAAM,mBAAmB,mCAI9B,CAAC;AAEH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,oBAAoB,CAAC;IACjC,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAElE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAI3E;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,iBAAiB,GAC5B,oBAAoB,CAStB;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,UAAU,oBAA6C,GACtD,oBAAoB,CAEtB;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,oBAAoB,CAKtB"}

package/dist/fishnet/quaternion-compression.d.ts

@@ -0,0 +1,6 @@
+/** A Unity quaternion as `[x, y, z, w]`. */
+export type Quaternion = readonly [number, number, number, number];
+export declare function decodeQuaternion(buffer: Buffer, start: number, widthBytes: 4 | 8 | 16): Quaternion | undefined;
+/** Yaw (rotation about the world up axis) in radians, derived from a Unity (Y-up) quaternion. */
+export declare function quaternionYaw(quaternion: Quaternion): number;
+//# sourceMappingURL=quaternion-compression.d.ts.map

package/dist/fishnet/quaternion-compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quaternion-compression.d.ts","sourceRoot":"","sources":["../../src/fishnet/quaternion-compression.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AA2DnE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,UAAU,GAAG,SAAS,CAI9G;AAED,iGAAiG;AACjG,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAG5D"}

package/dist/fishnet/recovery-style.d.ts

@@ -0,0 +1,5 @@
+import type { FishNetRecoveryStyle, FishNetSemanticMap } from "./semantic-map.ts";
+import type { DecodedFishNetPacket } from "./types.ts";
+/** Classifies the game-defined FloaterSettings trailing a HealthComponent.Recover_C payload. */
+export declare function classifyFishNetRecoveryStyle(packet: Pick<DecodedFishNetPacket, "networkBehaviourType" | "rpcName" | "undecodedPayload">, semanticMap: Pick<FishNetSemanticMap, "recoveryStyles"> | undefined): FishNetRecoveryStyle;
+//# sourceMappingURL=recovery-style.d.ts.map

package/dist/fishnet/recovery-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery-style.d.ts","sourceRoot":"","sources":["../../src/fishnet/recovery-style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,gGAAgG;AAChG,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,sBAAsB,GAAG,SAAS,GAAG,kBAAkB,CAAC,EAC3F,WAAW,EAAE,IAAI,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,GAAG,SAAS,GAClE,oBAAoB,CAUtB"}

package/dist/fishnet/rpc-definitions/broadcasts.d.ts

@@ -0,0 +1,23 @@
+export declare class FishNetBroadcastDefinitions {
+    private constructor();
+    static readonly definitions: readonly [{
+        readonly wireHash: 40743;
+        readonly typeName: "FishNet.Managing.Scened.ClientScenesLoadedBroadcast";
+    }, {
+        readonly wireHash: 37660;
+        readonly typeName: "FishNet.Managing.Scened.EmptyStartScenesBroadcast";
+    }, {
+        readonly wireHash: 24702;
+        readonly typeName: "FishNet.Managing.Scened.LoadScenesBroadcast";
+    }, {
+        readonly wireHash: 22762;
+        readonly typeName: "FishNet.Managing.Scened.UnloadScenesBroadcast";
+    }, {
+        readonly wireHash: 50655;
+        readonly typeName: "FishNet.Managing.Server.ClientConnectionChangeBroadcast";
+    }, {
+        readonly wireHash: 50053;
+        readonly typeName: "FishNet.Managing.Server.ConnectedClientsBroadcast";
+    }];
+}
+//# sourceMappingURL=broadcasts.d.ts.map

package/dist/fishnet/rpc-definitions/broadcasts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcasts.d.ts","sourceRoot":"","sources":["../../../src/fishnet/rpc-definitions/broadcasts.ts"],"names":[],"mappings":"AAEA,qBAAa,2BAA2B;IACtC,OAAO,eAAiB;IAExB,MAAM,CAAC,QAAQ,CAAC,WAAW;2BAEX,KAAK;2BACL,qDAAqD;;2BAGrD,KAAK;2BACL,mDAAmD;;2BAGnD,KAAK;2BACL,6CAA6C;;2BAG7C,KAAK;2BACL,+CAA+C;;2BAG/C,KAAK;2BACL,yDAAyD;;2BAGzD,KAAK;2BACL,mDAAmD;OAER;CAC5D"}