@jsprismarine/auth 0.0.0-stage → 0.14.1

package/dist/OfflineAuthProvider.es.js

@@ -0,0 +1,185 @@
+import { createClientData } from "./ClientData.es.js";
+import { createSigner } from "fast-jwt";
+import { generateKeyPairSync, randomInt, randomUUID } from "node:crypto";
+// src/OfflineAuthProvider.ts
+/**
+* The curve Bedrock's identity keys use, and the JOSE algorithm that goes with it. Not
+* configurable: a server derives its encryption secret from this key, so both ends have to
+* agree, and the protocol fixes the answer.
+*/
+var CURVE = "secp384r1";
+var ALGORITHM = "ES384";
+/** How long a self-signed chain claims to be valid for. */
+var CHAIN_LIFETIME_SECONDS = 21600;
+/**
+* The first protocol whose servers want a multiplayer token rather than a certificate chain.
+*
+* 1.26.10 moved the offline identity out of the chain: what used to be a self-signed link
+* carrying `extraData` is now a self-signed OIDC token in a `Token` field beside a chain that
+* exists only to hold its place. A server at or past this refuses the old shape - and refuses
+* it by going quiet at the RakNet layer rather than by answering, which is why the version
+* this compares against is worth stating rather than discovering.
+*/
+var FIRST_TOKEN_PROTOCOL = 944;
+/** What the token says it is for. A server checks the audience even when it verifies nothing else. */
+var MULTIPLAYER_AUDIENCE = "api://auth-minecraft-services/multiplayer";
+/** The value naming a self-signed identity, as opposed to one Xbox Live vouched for. */
+var AUTHENTICATION_TYPE_SELF_SIGNED = 2;
+/**
+* A login identity that talks to nothing.
+*
+* The chain is a single JWT this provider signs with a key it just generated, which is
+* exactly what the real client sends when it is not signed in to Xbox Live. A server in
+* online mode refuses it - there is no XUID to check, and it says so - and a server with
+* `online-mode` off accepts it, which covers JSPrismarine itself, a LAN game, and the
+* whole of the bot harness.
+*
+* The key is generated per instance rather than per login. It is the identity: reusing one
+* across two concurrent connections would have them claim to be the same client, and the
+* encryption handshake would derive the same secret for both.
+*
+* @example
+* ```typescript
+* const auth = new OfflineAuthProvider({ displayName: 'Steve' });
+* const credentials = await auth.createLoginCredentials({ serverAddress: '127.0.0.1:19132', protocolVersion: 748 });
+* ```
+*/
+var OfflineAuthProvider = class {
+	options;
+	name = "offline";
+	identity;
+	privateKeyPem;
+	publicKeyDer;
+	clientRandomId;
+	constructor(options) {
+		this.options = options;
+		const { publicKey, privateKey } = generateKeyPairSync("ec", { namedCurve: CURVE });
+		this.publicKeyDer = publicKey.export({
+			type: "spki",
+			format: "der"
+		}).toString("base64");
+		this.privateKeyPem = privateKey.export({
+			type: "pkcs8",
+			format: "pem"
+		}).toString();
+		this.identity = {
+			xuid: "",
+			identity: options.identity ?? randomUUID(),
+			displayName: options.displayName
+		};
+		this.clientRandomId = randomInt(0, 2147483647);
+	}
+	async getIdentity() {
+		return this.identity;
+	}
+	async getIdentityPublicKey() {
+		return this.publicKeyDer;
+	}
+	async getIdentityPrivateKey() {
+		return this.privateKeyPem;
+	}
+	async createLoginCredentials(request) {
+		return {
+			chainData: request.protocolVersion >= FIRST_TOKEN_PROTOCOL ? this.signTokenRequest() : JSON.stringify({ chain: [this.signChainLink()] }),
+			clientData: this.signClientData(request)
+		};
+	}
+	/**
+	* The identity as a server from 1.26.10 on wants it.
+	*
+	* The chain is one empty string. That is not a placeholder for something missing: the
+	* field is still read, and an offline client has no certificate to put in it, so it holds
+	* a link that says nothing while the `Token` beside it carries the identity. `Certificate`
+	* is a *string* of JSON rather than an object, which is the shape the server parses.
+	*/
+	signTokenRequest() {
+		return JSON.stringify({
+			Certificate: JSON.stringify({ chain: [""] }),
+			AuthenticationType: AUTHENTICATION_TYPE_SELF_SIGNED,
+			Token: this.signMultiplayerToken()
+		});
+	}
+	/**
+	* The self-signed token that replaced the chain link.
+	*
+	* The claim names are short and unobvious because they are an identity provider's, not
+	* Minecraft's: `cpk` is the key the encryption handshake will use, `xid` the Xbox id an
+	* offline player does not have, `leguuid` the uuid that has to stand in for it. The
+	* PlayFab fields are sent empty rather than omitted, because a real client always sends
+	* them and a field that is present-and-empty is the smaller departure from that.
+	*/
+	signMultiplayerToken() {
+		const now = Math.floor(Date.now() / 1e3);
+		return createSigner({
+			algorithm: ALGORITHM,
+			key: this.privateKeyPem,
+			header: {
+				alg: ALGORITHM,
+				x5u: this.publicKeyDer
+			}
+		})({
+			aud: MULTIPLAYER_AUDIENCE,
+			nbf: now - CHAIN_LIFETIME_SECONDS,
+			exp: now + CHAIN_LIFETIME_SECONDS,
+			iat: now,
+			ipt: "",
+			mid: "",
+			tid: "",
+			cpk: this.publicKeyDer,
+			xid: this.identity.xuid,
+			xname: this.identity.displayName,
+			leguuid: this.identity.identity
+		});
+	}
+	/**
+	* The one link an unauthenticated chain has: self-signed, and vouching for nothing but
+	* itself.
+	*
+	* The `x5u` header and the `identityPublicKey` claim are the same key, which is how a
+	* verifier knows the token signed itself. An authenticated chain has Mojang's key in
+	* `x5u` and this one in the claim, and the difference between the two is the whole of
+	* what online mode checks.
+	*/
+	signChainLink() {
+		const now = Math.floor(Date.now() / 1e3);
+		return createSigner({
+			algorithm: ALGORITHM,
+			key: this.privateKeyPem,
+			header: {
+				alg: ALGORITHM,
+				x5u: this.publicKeyDer
+			}
+		})({
+			nbf: now - 60,
+			exp: now + CHAIN_LIFETIME_SECONDS,
+			iat: now,
+			identityPublicKey: this.publicKeyDer,
+			extraData: {
+				XUID: this.identity.xuid,
+				identity: this.identity.identity,
+				displayName: this.identity.displayName,
+				titleId: this.identity.titleId ?? ""
+			}
+		});
+	}
+	signClientData(request) {
+		return createSigner({
+			algorithm: ALGORITHM,
+			key: this.privateKeyPem,
+			header: {
+				alg: ALGORITHM,
+				x5u: this.publicKeyDer
+			},
+			noTimestamp: true
+		})(createClientData({
+			...this.options.clientData,
+			serverAddress: request.serverAddress,
+			clientRandomId: this.clientRandomId,
+			selfSignedId: this.identity.identity,
+			displayName: this.identity.displayName
+		}));
+	}
+};
+export { OfflineAuthProvider as default };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"OfflineAuthProvider.es.js","names":[],"sources":["../src/OfflineAuthProvider.ts"],"sourcesContent":["import { createSigner } from 'fast-jwt';\nimport { generateKeyPairSync, randomInt, randomUUID } from 'node:crypto';\nimport type { ClientDataOptions } from './ClientData';\nimport { createClientData } from './ClientData';\n\nimport type { IAuthProvider, Identity, LoginCredentials, LoginRequest } from './IAuthProvider';\n\n/**\n * The curve Bedrock's identity keys use, and the JOSE algorithm that goes with it. Not\n * configurable: a server derives its encryption secret from this key, so both ends have to\n * agree, and the protocol fixes the answer.\n */\nconst CURVE = 'secp384r1';\nconst ALGORITHM = 'ES384';\n\n/** How long a self-signed chain claims to be valid for. */\nconst CHAIN_LIFETIME_SECONDS = 6 * 60 * 60;\n\n/**\n * The first protocol whose servers want a multiplayer token rather than a certificate chain.\n *\n * 1.26.10 moved the offline identity out of the chain: what used to be a self-signed link\n * carrying `extraData` is now a self-signed OIDC token in a `Token` field beside a chain that\n * exists only to hold its place. A server at or past this refuses the old shape - and refuses\n * it by going quiet at the RakNet layer rather than by answering, which is why the version\n * this compares against is worth stating rather than discovering.\n */\nconst FIRST_TOKEN_PROTOCOL = 944;\n\n/** What the token says it is for. A server checks the audience even when it verifies nothing else. */\nconst MULTIPLAYER_AUDIENCE = 'api://auth-minecraft-services/multiplayer';\n\n/** The value naming a self-signed identity, as opposed to one Xbox Live vouched for. */\nconst AUTHENTICATION_TYPE_SELF_SIGNED = 2;\n\nexport interface OfflineAuthOptions {\n    /** The name that shows up in chat and the player list. */\n    readonly displayName: string;\n    /**\n     * The uuid the server knows this player by, stable across reconnects if you supply it.\n     *\n     * Worth supplying for a client with a world to come back to, and worth *not* supplying\n     * for a bot fleet, where five hundred connections each need their own.\n     */\n    readonly identity?: string;\n    readonly clientData?: Partial<ClientDataOptions>;\n}\n\n/**\n * A login identity that talks to nothing.\n *\n * The chain is a single JWT this provider signs with a key it just generated, which is\n * exactly what the real client sends when it is not signed in to Xbox Live. A server in\n * online mode refuses it - there is no XUID to check, and it says so - and a server with\n * `online-mode` off accepts it, which covers JSPrismarine itself, a LAN game, and the\n * whole of the bot harness.\n *\n * The key is generated per instance rather than per login. It is the identity: reusing one\n * across two concurrent connections would have them claim to be the same client, and the\n * encryption handshake would derive the same secret for both.\n *\n * @example\n * ```typescript\n * const auth = new OfflineAuthProvider({ displayName: 'Steve' });\n * const credentials = await auth.createLoginCredentials({ serverAddress: '127.0.0.1:19132', protocolVersion: 748 });\n * ```\n */\nexport default class OfflineAuthProvider implements IAuthProvider {\n    public readonly name = 'offline';\n\n    private readonly identity: Identity;\n    private readonly privateKeyPem: string;\n    private readonly publicKeyDer: string;\n    private readonly clientRandomId: number;\n\n    public constructor(private readonly options: OfflineAuthOptions) {\n        const { publicKey, privateKey } = generateKeyPairSync('ec', { namedCurve: CURVE });\n\n        // DER inside base64, which is the form both the `x5u` header and the\n        // `identityPublicKey` claim carry - not PEM, and not a JWK.\n        this.publicKeyDer = publicKey.export({ type: 'spki', format: 'der' }).toString('base64');\n        this.privateKeyPem = privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();\n\n        this.identity = {\n            // Empty, and that is the point: an XUID is what an offline client cannot have,\n            // and it is what a server in online mode checks for.\n            xuid: '',\n            identity: options.identity ?? randomUUID(),\n            displayName: options.displayName\n        };\n\n        // Mojang's is a signed 32 bit value the client picks once per session and the\n        // server stores against the player; nothing derives from it.\n        this.clientRandomId = randomInt(0, 0x7fffffff);\n    }\n\n    public async getIdentity(): Promise<Identity> {\n        return this.identity;\n    }\n\n    public async getIdentityPublicKey(): Promise<string> {\n        return this.publicKeyDer;\n    }\n\n    public async getIdentityPrivateKey(): Promise<string> {\n        return this.privateKeyPem;\n    }\n\n    public async createLoginCredentials(request: LoginRequest): Promise<LoginCredentials> {\n        return {\n            chainData:\n                request.protocolVersion >= FIRST_TOKEN_PROTOCOL\n                    ? this.signTokenRequest()\n                    : JSON.stringify({ chain: [this.signChainLink()] }),\n            clientData: this.signClientData(request)\n        };\n    }\n\n    /**\n     * The identity as a server from 1.26.10 on wants it.\n     *\n     * The chain is one empty string. That is not a placeholder for something missing: the\n     * field is still read, and an offline client has no certificate to put in it, so it holds\n     * a link that says nothing while the `Token` beside it carries the identity. `Certificate`\n     * is a *string* of JSON rather than an object, which is the shape the server parses.\n     */\n    private signTokenRequest(): string {\n        return JSON.stringify({\n            Certificate: JSON.stringify({ chain: [''] }),\n            AuthenticationType: AUTHENTICATION_TYPE_SELF_SIGNED,\n            Token: this.signMultiplayerToken()\n        });\n    }\n\n    /**\n     * The self-signed token that replaced the chain link.\n     *\n     * The claim names are short and unobvious because they are an identity provider's, not\n     * Minecraft's: `cpk` is the key the encryption handshake will use, `xid` the Xbox id an\n     * offline player does not have, `leguuid` the uuid that has to stand in for it. The\n     * PlayFab fields are sent empty rather than omitted, because a real client always sends\n     * them and a field that is present-and-empty is the smaller departure from that.\n     */\n    private signMultiplayerToken(): string {\n        const now = Math.floor(Date.now() / 1000);\n        const sign = createSigner({\n            algorithm: ALGORITHM,\n            key: this.privateKeyPem,\n            header: { alg: ALGORITHM, x5u: this.publicKeyDer }\n        });\n\n        return sign({\n            aud: MULTIPLAYER_AUDIENCE,\n            nbf: now - CHAIN_LIFETIME_SECONDS,\n            exp: now + CHAIN_LIFETIME_SECONDS,\n            iat: now,\n            ipt: '',\n            mid: '',\n            tid: '',\n            cpk: this.publicKeyDer,\n            xid: this.identity.xuid,\n            xname: this.identity.displayName,\n            leguuid: this.identity.identity\n        });\n    }\n\n    /**\n     * The one link an unauthenticated chain has: self-signed, and vouching for nothing but\n     * itself.\n     *\n     * The `x5u` header and the `identityPublicKey` claim are the same key, which is how a\n     * verifier knows the token signed itself. An authenticated chain has Mojang's key in\n     * `x5u` and this one in the claim, and the difference between the two is the whole of\n     * what online mode checks.\n     */\n    private signChainLink(): string {\n        const now = Math.floor(Date.now() / 1000);\n        const sign = createSigner({\n            algorithm: ALGORITHM,\n            key: this.privateKeyPem,\n            header: { alg: ALGORITHM, x5u: this.publicKeyDer }\n        });\n\n        return sign({\n            nbf: now - 60,\n            exp: now + CHAIN_LIFETIME_SECONDS,\n            iat: now,\n            identityPublicKey: this.publicKeyDer,\n            extraData: {\n                XUID: this.identity.xuid,\n                identity: this.identity.identity,\n                displayName: this.identity.displayName,\n                titleId: this.identity.titleId ?? ''\n            }\n        });\n    }\n\n    private signClientData(request: LoginRequest): string {\n        const sign = createSigner({\n            algorithm: ALGORITHM,\n            key: this.privateKeyPem,\n            header: { alg: ALGORITHM, x5u: this.publicKeyDer },\n            noTimestamp: true\n        });\n\n        return sign(\n            createClientData({\n                ...this.options.clientData,\n                serverAddress: request.serverAddress,\n                clientRandomId: this.clientRandomId,\n                selfSignedId: this.identity.identity,\n                displayName: this.identity.displayName\n            })\n        );\n    }\n}\n"],"mappings":";;;;;;;;;AAYA,IAAM,QAAQ;AACd,IAAM,YAAY;;AAGlB,IAAM,yBAAyB;;;;;;;;;;AAW/B,IAAM,uBAAuB;;AAG7B,IAAM,uBAAuB;;AAG7B,IAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;AAkCxC,IAAqB,sBAArB,MAAkE;CAQ1B;CAPpC,OAAuB;CAEvB;CACA;CACA;CACA;CAEA,YAAmB,SAA8C;EAA7B,KAAA,UAAA;EAChC,MAAM,EAAE,WAAW,eAAe,oBAAoB,MAAM,EAAE,YAAY,MAAM,CAAC;EAIjF,KAAK,eAAe,UAAU,OAAO;GAAE,MAAM;GAAQ,QAAQ;EAAM,CAAC,CAAC,CAAC,SAAS,QAAQ;EACvF,KAAK,gBAAgB,WAAW,OAAO;GAAE,MAAM;GAAS,QAAQ;EAAM,CAAC,CAAC,CAAC,SAAS;EAElF,KAAK,WAAW;GAGZ,MAAM;GACN,UAAU,QAAQ,YAAY,WAAW;GACzC,aAAa,QAAQ;EACzB;EAIA,KAAK,iBAAiB,UAAU,GAAG,UAAU;CACjD;CAEA,MAAa,cAAiC;EAC1C,OAAO,KAAK;CAChB;CAEA,MAAa,uBAAwC;EACjD,OAAO,KAAK;CAChB;CAEA,MAAa,wBAAyC;EAClD,OAAO,KAAK;CAChB;CAEA,MAAa,uBAAuB,SAAkD;EAClF,OAAO;GACH,WACI,QAAQ,mBAAmB,uBACrB,KAAK,iBAAiB,IACtB,KAAK,UAAU,EAAE,OAAO,CAAC,KAAK,cAAc,CAAC,EAAE,CAAC;GAC1D,YAAY,KAAK,eAAe,OAAO;EAC3C;CACJ;;;;;;;;;CAUA,mBAAmC;EAC/B,OAAO,KAAK,UAAU;GAClB,aAAa,KAAK,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC;GAC3C,oBAAoB;GACpB,OAAO,KAAK,qBAAqB;EACrC,CAAC;CACL;;;;;;;;;;CAWA,uBAAuC;EACnC,MAAM,MAAM,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI;EAOxC,OANa,aAAa;GACtB,WAAW;GACX,KAAK,KAAK;GACV,QAAQ;IAAE,KAAK;IAAW,KAAK,KAAK;GAAa;EACrD,CAEO,CAAA,CAAK;GACR,KAAK;GACL,KAAK,MAAM;GACX,KAAK,MAAM;GACX,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK,KAAK;GACV,KAAK,KAAK,SAAS;GACnB,OAAO,KAAK,SAAS;GACrB,SAAS,KAAK,SAAS;EAC3B,CAAC;CACL;;;;;;;;;;CAWA,gBAAgC;EAC5B,MAAM,MAAM,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI;EAOxC,OANa,aAAa;GACtB,WAAW;GACX,KAAK,KAAK;GACV,QAAQ;IAAE,KAAK;IAAW,KAAK,KAAK;GAAa;EACrD,CAEO,CAAA,CAAK;GACR,KAAK,MAAM;GACX,KAAK,MAAM;GACX,KAAK;GACL,mBAAmB,KAAK;GACxB,WAAW;IACP,MAAM,KAAK,SAAS;IACpB,UAAU,KAAK,SAAS;IACxB,aAAa,KAAK,SAAS;IAC3B,SAAS,KAAK,SAAS,WAAW;GACtC;EACJ,CAAC;CACL;CAEA,eAAuB,SAA+B;EAQlD,OAPa,aAAa;GACtB,WAAW;GACX,KAAK,KAAK;GACV,QAAQ;IAAE,KAAK;IAAW,KAAK,KAAK;GAAa;GACjD,aAAa;EACjB,CAEO,CAAA,CACH,iBAAiB;GACb,GAAG,KAAK,QAAQ;GAChB,eAAe,QAAQ;GACvB,gBAAgB,KAAK;GACrB,cAAc,KAAK,SAAS;GAC5B,aAAa,KAAK,SAAS;EAC/B,CAAC,CACL;CACJ;AACJ"}

package/dist/index.cjs.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_DefaultSkin = require("./DefaultSkin.cjs.cjs");
+const require_ClientData = require("./ClientData.cjs.cjs");
+const require_OfflineAuthProvider = require("./OfflineAuthProvider.cjs.cjs");
+exports.DEFAULT_SKIN_RESOURCE_PATCH = require_DefaultSkin.DEFAULT_SKIN_RESOURCE_PATCH;
+exports.OfflineAuthProvider = require_OfflineAuthProvider.default;
+exports.SKIN_HEIGHT = require_DefaultSkin.SKIN_HEIGHT;
+exports.SKIN_WIDTH = require_DefaultSkin.SKIN_WIDTH;
+exports.createClientData = require_ClientData.createClientData;
+exports.createDefaultSkinImage = require_DefaultSkin.createDefaultSkinImage;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { createClientData } from './ClientData';
+import { DEFAULT_SKIN_RESOURCE_PATCH, createDefaultSkinImage } from './DefaultSkin';
+import OfflineAuthProvider from './OfflineAuthProvider';
+export { DEFAULT_SKIN_RESOURCE_PATCH, OfflineAuthProvider, createClientData, createDefaultSkinImage };
+export type * from './IAuthProvider';
+export type { AnimatedImage, ClientDataOptions, ClientDataPayload } from './ClientData';
+export type { OfflineAuthOptions } from './OfflineAuthProvider';
+export { SKIN_HEIGHT, SKIN_WIDTH } from './DefaultSkin';
+//# 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,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,2BAA2B,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AAExD,OAAO,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,CAAC;AAEtG,mBAAmB,iBAAiB,CAAC;AACrC,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACxF,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.es.js

@@ -0,0 +1,4 @@
+import { DEFAULT_SKIN_RESOURCE_PATCH, SKIN_HEIGHT, SKIN_WIDTH, createDefaultSkinImage } from "./DefaultSkin.es.js";
+import { createClientData } from "./ClientData.es.js";
+import OfflineAuthProvider from "./OfflineAuthProvider.es.js";
+export { DEFAULT_SKIN_RESOURCE_PATCH, OfflineAuthProvider, SKIN_HEIGHT, SKIN_WIDTH, createClientData, createDefaultSkinImage };

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@jsprismarine/auth",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.14.1",
+  "description": "Minecraft: Bedrock Edition login identity: JWT chains, client data and Xbox Live",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "main": "./dist/index.cjs.cjs",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.es.js",
+      "module": "./dist/index.es.js",
+      "require": "./dist/index.cjs.cjs"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.es.js",
+      "module": "./dist/*.es.js",
+      "require": "./dist/*.cjs.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JSPrismarine/JSPrismarine.git"
+  },
+  "keywords": [
+    "minecraft",
+    "bedrock",
+    "authentication",
+    "xbox"
+  ],
+  "author": "JSPrismarine",
+  "license": "MIT",
+  "homepage": "https://github.com/JSPrismarine/JSPrismarine/tree/master/packages/auth",
+  "devDependencies": {
+    "@types/node": "24.13.6",
+    "glob": "13.0.6",
+    "rimraf": "6.1.3",
+    "typescript": "7.0.2",
+    "vite": "8.3.0",
+    "vitest": "5.0.1"
+  },
+  "dependencies": {
+    "@jsprismarine/minecraft": "0.14.2",
+    "fast-jwt": "6.3.3"
+  },
+  "scripts": {
+    "clean": "rimraf dist jsp *.tsbuildinfo vite.config.ts.timestamp-* .tsup .turbo",
+    "build": "vite build && node ../../scripts/emit-dts.mts",
+    "build:watch": "vite build --watch",
+    "typecheck": "tsc-ts --noEmit"
+  }
 }