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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fishnet/rpc-definitions/index.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMM,CAAC"}

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

@@ -0,0 +1,112 @@
+/** Verified layouts for instantiated prefabs in the current build's default collection. */
+export declare const FISHNET_PREFAB_DEFINITIONS: readonly [{
+    readonly collectionId: 0;
+    readonly prefabId: 0;
+    readonly prefabName: "LootDrop";
+    readonly components: readonly [{
+        readonly index: 0;
+        readonly typeName: "LootDrop";
+    }];
+}, {
+    readonly collectionId: 0;
+    readonly prefabId: 1;
+    readonly prefabName: "PlayerClone";
+    readonly components: readonly [{
+        readonly index: 0;
+        readonly typeName: "PlayerController";
+    }, {
+        readonly index: 1;
+        readonly typeName: "MoveComponent";
+    }, {
+        readonly index: 2;
+        readonly typeName: "HealthComponent";
+    }, {
+        readonly index: 3;
+        readonly typeName: "CombatComponent";
+    }, {
+        readonly index: 4;
+        readonly typeName: "SkillsComponent";
+    }, {
+        readonly index: 5;
+        readonly typeName: "StatusComponent";
+    }, {
+        readonly index: 6;
+        readonly typeName: "SummoningComponent";
+    }, {
+        readonly index: 7;
+        readonly typeName: "PlayerSave";
+    }, {
+        readonly index: 8;
+        readonly typeName: "FishNet.Component.Transforming.NetworkTransform";
+    }];
+}, {
+    readonly collectionId: 0;
+    readonly prefabId: 2;
+    readonly prefabName: "SkillInstance";
+    readonly components: readonly [{
+        readonly index: 1;
+        readonly typeName: "FishNet.Component.Transforming.NetworkTransform";
+    }];
+}, {
+    readonly collectionId: 0;
+    readonly prefabId: 4;
+    readonly prefabName: "Player";
+    readonly components: readonly [{
+        readonly index: 0;
+        readonly typeName: "PlayerController";
+    }, {
+        readonly index: 1;
+        readonly typeName: "MoveComponent";
+    }, {
+        readonly index: 2;
+        readonly typeName: "HealthComponent";
+    }, {
+        readonly index: 3;
+        readonly typeName: "CombatComponent";
+    }, {
+        readonly index: 4;
+        readonly typeName: "SkillsComponent";
+    }, {
+        readonly index: 5;
+        readonly typeName: "StatusComponent";
+    }, {
+        readonly index: 6;
+        readonly typeName: "SummoningComponent";
+    }, {
+        readonly index: 7;
+        readonly typeName: "PlayerSave";
+    }, {
+        readonly index: 8;
+        readonly typeName: "FishNet.Component.Transforming.NetworkTransform";
+    }];
+}, {
+    readonly collectionId: 0;
+    readonly prefabId: 5;
+    readonly prefabName: "Monster";
+    readonly components: readonly [{
+        readonly index: 0;
+        readonly typeName: "MonsterController";
+    }, {
+        readonly index: 1;
+        readonly typeName: "FishNet.Component.Transforming.NetworkTransform";
+    }, {
+        readonly index: 2;
+        readonly typeName: "MoveComponent";
+    }, {
+        readonly index: 3;
+        readonly typeName: "HealthComponent";
+    }, {
+        readonly index: 4;
+        readonly typeName: "CombatComponent";
+    }, {
+        readonly index: 5;
+        readonly typeName: "SkillsComponent";
+    }, {
+        readonly index: 6;
+        readonly typeName: "StatusComponent";
+    }, {
+        readonly index: 7;
+        readonly typeName: "SummoningComponent";
+    }];
+}];
+//# sourceMappingURL=prefabs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefabs.d.ts","sourceRoot":"","sources":["../../../src/fishnet/rpc-definitions/prefabs.ts"],"names":[],"mappings":"AAcA,2FAA2F;AAC3F,eAAO,MAAM,0BAA0B;2BACrB,CAAC;uBAAY,CAAC;yBAAc,UAAU;;wBAC3C,CAAC;2BAAY,UAAU;;;2BAElB,CAAC;uBAAY,CAAC;yBAAc,aAAa;;wBAhBhD,CAAC;2BAAY,kBAAkB;;wBAC/B,CAAC;2BAAY,eAAe;;wBAC5B,CAAC;2BAAY,iBAAiB;;wBAC9B,CAAC;2BAAY,iBAAiB;;wBAC9B,CAAC;2BAAY,iBAAiB;;wBAC9B,CAAC;2BAAY,iBAAiB;;wBAC9B,CAAC;2BAAY,oBAAoB;;wBACjC,CAAC;2BAAY,YAAY;;wBACzB,CAAC;2BAAY,iDAAiD;;;2BASvD,CAAC;uBAAY,CAAC;yBAAc,eAAe;;wBAChD,CAAC;2BAAY,iDAAiD;;;2BAEzD,CAAC;uBAAY,CAAC;yBAAc,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BACpC,CAAC;uBAAY,CAAC;yBAAc,SAAS;;wBAC1C,CAAC;2BAAY,mBAAmB;;wBAChC,CAAC;2BAAY,iDAAiD;;wBAC9D,CAAC;2BAAY,eAAe;;wBAC5B,CAAC;2BAAY,iBAAiB;;wBAC9B,CAAC;2BAAY,iBAAiB;;wBAC9B,CAAC;2BAAY,iBAAiB;;wBAC9B,CAAC;2BAAY,iBAAiB;;wBAC9B,CAAC;2BAAY,oBAAoB;;EAES,CAAC"}

package/dist/fishnet/rpc-resolution.d.ts

@@ -0,0 +1,65 @@
+import type { RpcLinkRegistrationState } from "./protocol.ts";
+import type { DecodedFishNetPacket, FishNetRpcMap, FishNetRpcPacketName, FishNetRpcParameter, FishNetRpcResolution } from "./types.ts";
+export interface RpcLookup {
+    resolution: FishNetRpcResolution;
+    wireHash?: number;
+    methodName?: string;
+    parameters?: readonly FishNetRpcParameter[];
+    /** Candidate behaviour type names, when `resolution` is `"ambiguous"`. */
+    ambiguousBehaviourTypes?: readonly string[];
+}
+export declare function bindBehaviourTypes(registrations: Array<[number, RpcLinkRegistrationState]>, map: FishNetRpcMap | undefined): Array<[string, string]>;
+/** Recovers component bindings from build-scoped prefab metadata when a spawn omits some or all RPC Link registrations. */
+export declare function bindPrefabBehaviourTypes(collectionId: number, prefabId: number, objectId: number, verifiedBindings: readonly [string, string][], map: FishNetRpcMap | undefined): Array<[string, string]>;
+export declare function inferBehaviourType(map: FishNetRpcMap | undefined, packetName: FishNetRpcPacketName, hash8: number, hash16: number | undefined): string | undefined;
+export declare function lookupRpc(map: FishNetRpcMap | undefined, networkBehaviourType: string | undefined, packetName: FishNetRpcPacketName, hash8: number, hash16: number | undefined): RpcLookup;
+/**
+ * Narrows an ambiguous behaviour-type match using the invariant that a NetworkObject has at most
+ * one instance of each behaviour type. If every candidate but one is already bound to a *different*
+ * component index on the same object, the remaining candidate must be this component's real type —
+ * even though its own RPC signature alone can't distinguish it (e.g. `HealthComponent.Recover_C` vs.
+ * `SkillsComponent.Recover_C`, which share the same wire hash and packet kind).
+ */
+export declare function eliminateBoundBehaviourTypes(components: ReadonlyMap<string, string>, objectId: number, componentIndex: number, candidates: readonly string[]): string | undefined;
+/**
+ * Recovers a component's behaviour type for an object whose spawn was never captured, using the
+ * bindings already verified on that same object.
+ *
+ * A capture that attaches mid-session never sees the local player's spawn, so nothing registers its
+ * component layout and every packet on its other components stays unresolved for the whole session.
+ * What is available is the object's own verified bindings: they narrow which prefab layouts the
+ * object could possibly be, and where every surviving candidate names the same type for the wanted
+ * index, that type holds for all of them and is not a guess.
+ *
+ * The bar is deliberately high. Recovery needs at least one already-verified binding to narrow
+ * from, every candidate must define the wanted index, and they must all agree on it. A layout that
+ * contradicts a known binding is discarded rather than tolerated, and a single candidate that
+ * leaves the index blank abandons the whole attempt.
+ */
+export declare function recoverComponentFromPrefabLayouts(map: FishNetRpcMap | undefined, components: ReadonlyMap<string, string>, objectId: number, componentIndex: number): string | undefined;
+/**
+ * Narrows an ambiguous behaviour-type match by testing the payload against each candidate's
+ * signature. This complements `eliminateBoundBehaviourTypes`, which can only narrow once *something*
+ * else on the object is already bound: an object whose spawn was never captured has no bindings at
+ * all, so a shared hash (e.g. observersRpc 0, claimed by both `CombatComponent.Attack_C` and
+ * `HealthComponent.ApplyDamage_C`) stays ambiguous for that object's entire life and every packet on
+ * it is dropped.
+ *
+ * A candidate survives only when its parameters consume the payload *exactly* - both a short read
+ * and leftover bytes disqualify it. Candidates whose signature this decoder cannot evaluate (array
+ * or opaque parameters) are indeterminate rather than misfits, and their presence blocks the whole
+ * pass: eliminating one because it could not be checked is how a confident wrong answer gets made.
+ */
+export declare function eliminateByPayloadShape(map: FishNetRpcMap | undefined, candidates: readonly string[], packetName: FishNetRpcPacketName, hash8: number, hash16: number | undefined, payload: Buffer): string | undefined;
+/** True when `applyRpcLookup` refused a match it was handed. Callers must not learn bindings from it. */
+export declare function rejectedByPayload(packet: DecodedFishNetPacket, lookup: RpcLookup): boolean;
+export declare function applyRpcLookup(packet: DecodedFishNetPacket, lookup: RpcLookup): void;
+export declare function findBroadcast(map: FishNetRpcMap | undefined, wireHash: number): import("./types.ts").FishNetBroadcastDefinition | undefined;
+export declare function findSyncType(map: FishNetRpcMap | undefined, typeName: string | undefined, index: number): import("./types.ts").FishNetSyncTypeDefinition | undefined;
+/**
+ * Resolves a spawn's collection and prefab IDs to the build's prefab layout. Prefab IDs are wire
+ * values reassigned between builds, so consumers must match on `prefabName` through this rather
+ * than on a hardcoded numeric ID.
+ */
+export declare function findPrefab(map: FishNetRpcMap | undefined, collectionId: number, prefabId: number): import("./types.ts").FishNetPrefabDefinition | undefined;
+//# sourceMappingURL=rpc-resolution.d.ts.map

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

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

package/dist/fishnet/semantic-definitions.d.ts

@@ -0,0 +1,40 @@
+export declare class FishNetSemanticDefinitions {
+    private constructor();
+    static readonly currentRecoveryStyles: readonly [{
+        readonly networkBehaviourType: "HealthComponent";
+        readonly rpcName: "Recover_C";
+        readonly undecodedPayloadHex: "0000ac0200000000";
+        readonly style: "standard";
+    }, {
+        readonly networkBehaviourType: "HealthComponent";
+        readonly rpcName: "Recover_C";
+        readonly undecodedPayloadHex: "00010000000000";
+        readonly style: "passive-regeneration";
+    }, {
+        readonly networkBehaviourType: "HealthComponent";
+        readonly rpcName: "Recover_C";
+        readonly undecodedPayloadHex: "0001ab020000403f";
+        readonly style: "drain";
+    }];
+    static readonly currentMap: {
+        readonly buildFingerprint: "53305f369c4176d4b7644d06ad7f0cdc5c9bda6563144d0ce8cff3d12c520158";
+        readonly verifiedSkillLabels: readonly [];
+        readonly recoveryStyles: readonly [{
+            readonly networkBehaviourType: "HealthComponent";
+            readonly rpcName: "Recover_C";
+            readonly undecodedPayloadHex: "0000ac0200000000";
+            readonly style: "standard";
+        }, {
+            readonly networkBehaviourType: "HealthComponent";
+            readonly rpcName: "Recover_C";
+            readonly undecodedPayloadHex: "00010000000000";
+            readonly style: "passive-regeneration";
+        }, {
+            readonly networkBehaviourType: "HealthComponent";
+            readonly rpcName: "Recover_C";
+            readonly undecodedPayloadHex: "0001ab020000403f";
+            readonly style: "drain";
+        }];
+    };
+}
+//# sourceMappingURL=semantic-definitions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-definitions.d.ts","sourceRoot":"","sources":["../../src/fishnet/semantic-definitions.ts"],"names":[],"mappings":"AAMA,qBAAa,0BAA0B;IACrC,OAAO,eAAiB;IAExB,MAAM,CAAC,QAAQ,CAAC,qBAAqB;uCAEX,iBAAiB;0BAC9B,WAAW;sCACC,kBAAkB;wBAChC,UAAU;;uCAGK,iBAAiB;0BAC9B,WAAW;sCACC,gBAAgB;wBAC9B,sBAAsB;;uCAGP,iBAAiB;0BAC9B,WAAW;sCACC,kBAAkB;wBAChC,OAAO;OAE6C;IAE/D,MAAM,CAAC,QAAQ,CAAC,UAAU;;;;2CAnBA,iBAAiB;8BAC9B,WAAW;0CACC,kBAAkB;4BAChC,UAAU;;2CAGK,iBAAiB;8BAC9B,WAAW;0CACC,gBAAgB;4BAC9B,sBAAsB;;2CAGP,iBAAiB;8BAC9B,WAAW;0CACC,kBAAkB;4BAChC,OAAO;;MAQsB;CACzC"}

package/dist/fishnet/semantic-map.d.ts

@@ -0,0 +1,23 @@
+export interface FishNetSkillLabel {
+    readonly networkBehaviourType: string;
+    readonly rpcName: string;
+    readonly field: string;
+    readonly value: string;
+    readonly label: string;
+    readonly confidence: string;
+    readonly repetitions: number;
+}
+export type FishNetRecoveryStyle = "standard" | "passive-regeneration" | "drain" | "unknown";
+export interface FishNetRecoveryStyleDefinition {
+    readonly networkBehaviourType: string;
+    readonly rpcName: string;
+    readonly undecodedPayloadHex: string;
+    readonly style: Exclude<FishNetRecoveryStyle, "unknown">;
+}
+export interface FishNetSemanticMap {
+    readonly buildFingerprint: string;
+    readonly verifiedSkillLabels: readonly FishNetSkillLabel[];
+    readonly recoveryStyles?: readonly FishNetRecoveryStyleDefinition[];
+}
+export declare function loadBundledFishNetSemanticMap(buildFingerprint?: string): FishNetSemanticMap;
+//# sourceMappingURL=semantic-map.d.ts.map

package/dist/fishnet/semantic-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-map.d.ts","sourceRoot":"","sources":["../../src/fishnet/semantic-map.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,sBAAsB,GAAG,OAAO,GAAG,SAAS,CAAC;AAE7F,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,mBAAmB,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC3D,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,8BAA8B,EAAE,CAAC;CACrE;AAMD,wBAAgB,6BAA6B,CAC3C,gBAAgB,GAAE,MAAuC,GACxD,kBAAkB,CAKpB"}

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

@@ -0,0 +1,19 @@
+import type { DecodedFishNetPacket, FishNetDecodeOptions, FishNetRpcMap } from "./types.ts";
+/** Stateful decoder for RPC-link registration, despawn cleanup, and split reassembly. */
+export declare class FishNetSessionDecoder {
+    private readonly rpcMap?;
+    private readonly connections;
+    private readonly splits;
+    private splitClock;
+    constructor(rpcMap?: FishNetRpcMap | undefined);
+    decode(payload: Buffer, options?: FishNetDecodeOptions): DecodedFishNetPacket[];
+    /** Clears one connection, or all decoder state when no identifier is supplied. */
+    reset(connectionId?: string | number): void;
+    private getConnection;
+    private dropSplit;
+    private clearConnectionSplits;
+    private evictOldestConnectionSplit;
+    private decodeSplit;
+    private decodeMessages;
+}
+//# sourceMappingURL=session-decoder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-decoder.d.ts","sourceRoot":"","sources":["../../src/fishnet/session-decoder.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAc5F,yFAAyF;AACzF,qBAAa,qBAAqB;IAKpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAJpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsC;IAClE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,UAAU,CAAK;IAEvB,YAA6B,MAAM,CAAC,EAAE,aAAa,YAAA,EAAI;IAEvD,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,oBAA0C,GAAG,oBAAoB,EAAE,CAiBnG;IAED,kFAAkF;IAClF,KAAK,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAS1C;IAED,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,0BAA0B;IAQlC,OAAO,CAAC,WAAW;IA2CnB,OAAO,CAAC,cAAc;CA8CvB"}

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

@@ -0,0 +1,25 @@
+import type { RpcLinkRegistrationState } from "./protocol.ts";
+import type { FishNetRpcMap } from "./types.ts";
+export interface SpawnCandidate {
+    end: number;
+    objectId: number;
+    registrations: Array<[number, RpcLinkRegistrationState]>;
+    componentBindings: Array<[string, string]>;
+    spawnType: "scene" | "instantiated" | "predicted";
+    collectionId: number;
+    ownerConnectionId: number;
+    prefabId?: number;
+    sceneId?: bigint;
+    nested: boolean;
+    /** Game-defined WritePayload bytes preceding the RPC link and SyncType sections. */
+    customPayload: Buffer;
+    syncPayload: Buffer;
+    /** Spawn-time local position, present only when the spawn carries the position flag. */
+    localPosition?: readonly [number, number, number];
+    /** Spawn-time local rotation as `[x, y, z, w]`, decoded from whichever quaternion packing the spawn carried. */
+    localRotation?: readonly [number, number, number, number];
+    /** Spawn-time local scale, present only when the spawn carries the scale flag. */
+    localScale?: readonly [number, number, number];
+}
+export declare function parseObjectSpawn(buffer: Buffer, start: number, map: FishNetRpcMap | undefined): SpawnCandidate | undefined;
+//# sourceMappingURL=spawn-parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-parser.d.ts","sourceRoot":"","sources":["../../src/fishnet/spawn-parser.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAI9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC,CAAC;IACzD,iBAAiB,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3C,SAAS,EAAE,OAAO,GAAG,cAAc,GAAG,WAAW,CAAC;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,oFAAoF;IACpF,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,wFAAwF;IACxF,aAAa,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,gHAAgH;IAChH,aAAa,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1D,kFAAkF;IAClF,UAAU,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAChD;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,aAAa,GAAG,SAAS,GAC7B,cAAc,GAAG,SAAS,CAmI5B"}

package/dist/fishnet/types.d.ts

@@ -0,0 +1,5 @@
+export type { FishNetDecodedField, FishNetDecodedValue, FishNetWireCodec, } from "./definitions/codecs.ts";
+export type { FishNetBehaviourDefinition, FishNetBroadcastDefinition, FishNetPrefabComponentDefinition, FishNetPrefabDefinition, FishNetRpcDefinition, FishNetRpcMap, FishNetRpcParameter, FishNetSyncTypeDefinition, } from "./definitions/rpc-map.ts";
+export type { CapturedFishNetPacket, DecodedFishNetPacket, FishNetDecodeOptions, FishNetPacketName, FishNetRpcLinkRegistration, FishNetRpcPacketName, FishNetRpcResolution, FishNetSpawnSyncEntry, FishNetSyncEntry, } from "./definitions/protocol.ts";
+export type { DecodedNetworkTransform, NetworkTransformAxes, } from "./network-transform-decoder.ts";
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/fishnet/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,0BAA0B,EAC1B,0BAA0B,EAC1B,gCAAgC,EAChC,uBAAuB,EACvB,oBAAoB,EACpB,aAAa,EACb,mBAAmB,EACnB,yBAAyB,GAC1B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,gCAAgC,CAAC"}

package/dist/fishnet/wire-reader.d.ts

@@ -0,0 +1,28 @@
+export interface NetworkObjectReference {
+    objectId: number;
+    spawned: boolean;
+    nextOffset: number;
+}
+export interface NetworkBehaviourHeader {
+    objectId: number;
+    componentIndex: number;
+    nextOffset: number;
+}
+export declare function requireBytes(buffer: Buffer, offset: number, count: number, description: string): void;
+export declare function checkedEnd(buffer: Buffer, start: number, length: number): number;
+export declare function readUnsignedPackedWhole(buffer: Buffer, start: number): {
+    value: bigint;
+    nextOffset: number;
+};
+export declare function readSignedPackedWhole(buffer: Buffer, start: number): {
+    value: number;
+    nextOffset: number;
+};
+export declare function readNetworkObjectReference(buffer: Buffer, start: number): NetworkObjectReference;
+export declare function readNetworkBehaviourHeader(buffer: Buffer, start: number): NetworkBehaviourHeader;
+/** Reads `count` consecutive little-endian float32 values, as Unity serializes Vector3 and Quaternion. */
+export declare function readFloatVector(buffer: Buffer, start: number, count: number): {
+    value: number[];
+    nextOffset: number;
+};
+//# sourceMappingURL=wire-reader.d.ts.map

package/dist/fishnet/wire-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire-reader.d.ts","sourceRoot":"","sources":["../../src/fishnet/wire-reader.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAIrG;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAY5G;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAM1G;AAWD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAShG;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAWhG;AAED,0GAA0G;AAC1G,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAMrH"}

package/dist/fishnet/wire-reader.js

@@ -0,0 +1,140 @@
+// @bun
+// src/fishnet/protocol.ts
+var PACKET_NAMES = new Map([
+  [0, "unset"],
+  [1, "authenticated"],
+  [2, "split"],
+  [3, "objectSpawn"],
+  [4, "objectDespawn"],
+  [5, "predictedSpawnResult"],
+  [7, "syncType"],
+  [8, "serverRpc"],
+  [9, "observersRpc"],
+  [10, "targetRpc"],
+  [11, "ownershipChange"],
+  [12, "broadcast"],
+  [13, "bulkSpawnOrDespawn"],
+  [14, "pingPong"],
+  [15, "replicate"],
+  [16, "reconcile"],
+  [17, "disconnect"],
+  [18, "timingUpdate"],
+  [19, "unused2"],
+  [20, "stateUpdate"],
+  [21, "version"]
+]);
+var STARTING_RPC_LINK_ID = 22;
+var RPC_PACKET_NAMES = new Set(["serverRpc", "observersRpc", "targetRpc"]);
+var LINKED_PACKET_NAMES = new Map([
+  [9, "observersRpc"],
+  [10, "targetRpc"],
+  [16, "reconcile"]
+]);
+
+class FishNetProtocolError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FishNetProtocolError";
+  }
+}
+function classifyPacket(packetId) {
+  return PACKET_NAMES.get(packetId) ?? (packetId >= STARTING_RPC_LINK_ID ? "rpcLink" : "unknown");
+}
+function isPlausibleBoundary(buffer, offset) {
+  if (offset === buffer.length)
+    return true;
+  if (buffer.length - offset < 2)
+    return false;
+  return classifyPacket(buffer.readUInt16LE(offset)) !== "unknown";
+}
+function componentKey(objectId, componentIndex) {
+  return `${objectId}:${componentIndex}`;
+}
+function basePacket(buffer, start, end, tick, bundleIndex, packetId, packetName) {
+  return {
+    tick,
+    packetId,
+    packetName,
+    bundleIndex,
+    raw: buffer.subarray(start, end),
+    payload: buffer.subarray(start + 2, end)
+  };
+}
+function opaquePacket(buffer, start, tick, bundleIndex, packetName = classifyPacket(buffer.readUInt16LE(start))) {
+  return basePacket(buffer, start, buffer.length, tick, bundleIndex, buffer.readUInt16LE(start), packetName);
+}
+function unresolvedLinkPacket(buffer, start, tick, bundleIndex, packetId) {
+  const packet = opaquePacket(buffer, start, tick, bundleIndex, "rpcLink");
+  packet.linkId = packetId;
+  packet.linkResolved = false;
+  return packet;
+}
+
+// src/fishnet/wire-reader.ts
+function requireBytes(buffer, offset, count, description) {
+  if (buffer.length - offset < count) {
+    throw new FishNetProtocolError(`${description} needs ${count} bytes at byte ${offset}; ${buffer.length - offset} remain`);
+  }
+}
+function checkedEnd(buffer, start, length) {
+  if (!Number.isSafeInteger(length) || length < 0 || length > buffer.length - start) {
+    throw new FishNetProtocolError(`length ${length} exceeds ${buffer.length - start} remaining bytes`);
+  }
+  return start + length;
+}
+function readUnsignedPackedWhole(buffer, start) {
+  let value = 0n;
+  let shift = 0n;
+  let offset = start;
+  while (offset < buffer.length && offset - start < 10) {
+    const byte = buffer[offset] ?? 0;
+    offset += 1;
+    value |= BigInt(byte & 127) << shift;
+    if ((byte & 128) === 0)
+      return { value, nextOffset: offset };
+    shift += 7n;
+  }
+  throw new FishNetProtocolError(`unterminated packed integer at byte ${start}`);
+}
+function readSignedPackedWhole(buffer, start) {
+  const decoded = readUnsignedPackedWhole(buffer, start);
+  const signed = decoded.value >> 1n ^ -(decoded.value & 1n);
+  const value = Number(signed);
+  if (!Number.isSafeInteger(value))
+    throw new FishNetProtocolError("packed integer exceeds JavaScript's safe range");
+  return { value, nextOffset: decoded.nextOffset };
+}
+var NO_OBJECT_SENTINEL = 65535;
+function readNetworkObjectReference(buffer, start) {
+  const object = readSignedPackedWhole(buffer, start);
+  if (object.value === NO_OBJECT_SENTINEL)
+    return { objectId: object.value, spawned: false, nextOffset: object.nextOffset };
+  requireBytes(buffer, object.nextOffset, 1, "network object spawned flag");
+  const flag = buffer[object.nextOffset];
+  return { objectId: object.value, spawned: flag === 1, nextOffset: object.nextOffset + 1 };
+}
+function readNetworkBehaviourHeader(buffer, start) {
+  const reference = readNetworkObjectReference(buffer, start);
+  requireBytes(buffer, reference.nextOffset, 1, "network behaviour component");
+  return {
+    objectId: reference.objectId,
+    componentIndex: buffer[reference.nextOffset] ?? 0,
+    nextOffset: reference.nextOffset + 1
+  };
+}
+function readFloatVector(buffer, start, count) {
+  requireBytes(buffer, start, count * 4, "float vector");
+  return {
+    value: Array.from({ length: count }, (_, index) => buffer.readFloatLE(start + index * 4)),
+    nextOffset: start + count * 4
+  };
+}
+export {
+  checkedEnd,
+  readFloatVector,
+  readNetworkBehaviourHeader,
+  readNetworkObjectReference,
+  readSignedPackedWhole,
+  readUnsignedPackedWhole,
+  requireBytes
+};

package/dist/game-build.d.ts

@@ -0,0 +1,5 @@
+/** SHA-256 of the canonical current-build source manifest. */
+export declare const CURRENT_GAME_BUILD_FINGERPRINT = "53305f369c4176d4b7644d06ad7f0cdc5c9bda6563144d0ce8cff3d12c520158";
+export declare const BUNDLED_GAME_BUILD_FINGERPRINTS: readonly ["53305f369c4176d4b7644d06ad7f0cdc5c9bda6563144d0ce8cff3d12c520158"];
+export type GameBuildFingerprint = (typeof BUNDLED_GAME_BUILD_FINGERPRINTS)[number];
+//# sourceMappingURL=game-build.d.ts.map

package/dist/game-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-build.d.ts","sourceRoot":"","sources":["../src/game-build.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,eAAO,MAAM,8BAA8B,qEAAqE,CAAC;AAEjH,eAAO,MAAM,+BAA+B,+EAElC,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,+BAA+B,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export { BUNDLED_GAME_BUILD_FINGERPRINTS, CURRENT_GAME_BUILD_FINGERPRINT, } from "./game-build.ts";
+export type { GameBuildFingerprint } from "./game-build.ts";
+export { decodeLiteNetLibDatagram, LiteNetLibProtocolError } from "./litenetlib/decoder.ts";
+export { decodeFishNetBundle, decodeFishNetPayload, FishNetProtocolError, FishNetSessionDecoder, } from "./fishnet/decoder.ts";
+export { loadBundledFishNetRpcMap } from "./fishnet/builtin-maps.ts";
+export { findPrefab } from "./fishnet/rpc-resolution.ts";
+export { decodeFieldRun } from "./fishnet/field-decoder.ts";
+export type { FieldDecodeRun } from "./fishnet/field-decoder.ts";
+export { characterDataParameter } from "./fishnet/character-data-schema.ts";
+export { decodeNetworkTransformData, NETWORK_TRANSFORM_RPC_NAMES } from "./fishnet/network-transform-decoder.ts";
+export { resolveBundledMapName } from "./fishnet/map-definitions/index.ts";
+export { compact, count, warnings } from "./text-format.ts";
+export type { BundledFishNetBuildFingerprint } from "./fishnet/builtin-maps.ts";
+export { loadBundledFishNetSemanticMap } from "./fishnet/semantic-map.ts";
+export type { FishNetRecoveryStyle, FishNetRecoveryStyleDefinition, FishNetSemanticMap, FishNetSkillLabel, } from "./fishnet/semantic-map.ts";
+export { classifyFishNetRecoveryStyle } from "./fishnet/recovery-style.ts";
+export { FishNetEternalTowerTracker } from "./fishnet/eternal-tower-tracker.ts";
+export type { FishNetEternalTowerSnapshot } from "./fishnet/eternal-tower-tracker.ts";
+export { FishNetMonsterDirectory, decodeMonsterSpawn, } from "./fishnet/monster-directory.ts";
+export type { FishNetMonsterDirectoryChange, FishNetMonsterLevels, FishNetMonsterSpawn, } from "./fishnet/monster-directory.ts";
+export { decodeBossGravestone } from "./fishnet/boss-gravestone.ts";
+export type { BossGravestone } from "./fishnet/boss-gravestone.ts";
+export type { CaptureConfig, CaptureProtocol, CaptureState, CaptureTargetStatus, CapturedTcpPacket, CapturedTransportPacket, CapturedUdpPacket, } from "./types.ts";
+export type { CapturedLiteNetLibPacket, DecodedLiteNetLibPacket, LiteNetLibAckPacket, LiteNetLibChanneledPacket, LiteNetLibControlPacket, LiteNetLibFragment, LiteNetLibPacket, LiteNetLibPacketProperty, LiteNetLibPingPacket, LiteNetLibPongPacket, LiteNetLibUnreliablePacket, } from "./litenetlib/types.ts";
+export type { CapturedFishNetPacket, DecodedFishNetPacket, FishNetDecodeOptions, FishNetDecodedField, FishNetDecodedValue, FishNetBehaviourDefinition, FishNetBroadcastDefinition, FishNetPrefabComponentDefinition, FishNetPrefabDefinition, FishNetPacketName, FishNetRpcMap, FishNetRpcPacketName, FishNetRpcDefinition, FishNetRpcLinkRegistration, FishNetRpcParameter, FishNetRpcResolution, FishNetSpawnSyncEntry, FishNetSyncEntry, FishNetSyncTypeDefinition, FishNetWireCodec, DecodedNetworkTransform, NetworkTransformAxes, } from "./fishnet/types.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,8BAA8B,GAC/B,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAC5F,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,YAAY,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,wCAAwC,CAAC;AACjH,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5D,YAAY,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AAC1E,YAAY,EACV,oBAAoB,EACpB,8BAA8B,EAC9B,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,YAAY,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AACtF,OAAO,EACL,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,YAAY,EACV,6BAA6B,EAC7B,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,YAAY,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,YAAY,EACV,aAAa,EACb,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,wBAAwB,EACxB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,0BAA0B,EAC1B,gCAAgC,EAChC,uBAAuB,EACvB,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,gBAAgB,EAChB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC"}