@freqhole/haruspex 0.0.0

package/dist/webauthn/codec.test.js

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { arrayBufferToBase64, base64ToUint8Array, isWebAuthnAvailable, prepareAuthenticationOptions, prepareRegistrationOptions, serializeAuthenticationCredential, serializeRegistrationCredential, uint8ArrayToBase64, } from "./codec.js";
+describe("base64url round-trip", () => {
+    it("round-trips arbitrary bytes, including values that need + / and padding", () => {
+        const bytes = new Uint8Array([0, 1, 2, 62, 63, 64, 251, 252, 253, 254, 255]);
+        const encoded = uint8ArrayToBase64(bytes);
+        expect(encoded).not.toMatch(/[+/=]/);
+        expect(base64ToUint8Array(encoded)).toEqual(bytes);
+    });
+    it("arrayBufferToBase64 matches uint8ArrayToBase64 for the same bytes", () => {
+        const bytes = new Uint8Array([10, 20, 30]);
+        expect(arrayBufferToBase64(bytes.buffer)).toBe(uint8ArrayToBase64(bytes));
+    });
+});
+describe("prepareRegistrationOptions", () => {
+    it("converts base64url challenge/user-id/excludeCredentials to raw bytes", () => {
+        const challengeBytes = new Uint8Array([1, 2, 3]);
+        const userIdBytes = new Uint8Array([9, 9]);
+        const excludeIdBytes = new Uint8Array([5]);
+        const challenge = {
+            publicKey: {
+                rp: { name: "freqhole" },
+                user: {
+                    id: uint8ArrayToBase64(userIdBytes),
+                    name: "alice",
+                    displayName: "Alice",
+                },
+                challenge: uint8ArrayToBase64(challengeBytes),
+                pubKeyCredParams: [{ type: "public-key", alg: -7 }],
+                excludeCredentials: [
+                    { id: uint8ArrayToBase64(excludeIdBytes), type: "public-key" },
+                ],
+            },
+        };
+        const options = prepareRegistrationOptions(challenge);
+        const publicKey = options.publicKey;
+        expect(publicKey.challenge).toEqual(challengeBytes);
+        expect(publicKey.user.id).toEqual(userIdBytes);
+        expect(publicKey.excludeCredentials[0].id).toEqual(excludeIdBytes);
+        expect(publicKey.rp).toEqual({ name: "freqhole" });
+    });
+    it("omits excludeCredentials when the server did not send any", () => {
+        const challenge = {
+            publicKey: {
+                rp: { name: "freqhole" },
+                user: { id: "AA", name: "alice", displayName: "Alice" },
+                challenge: "AQ",
+                pubKeyCredParams: [{ type: "public-key", alg: -7 }],
+            },
+        };
+        const options = prepareRegistrationOptions(challenge);
+        expect(options.publicKey.excludeCredentials).toBeUndefined();
+    });
+});
+describe("prepareAuthenticationOptions", () => {
+    it("converts base64url challenge/allowCredentials to raw bytes", () => {
+        const challengeBytes = new Uint8Array([4, 5, 6]);
+        const allowIdBytes = new Uint8Array([7]);
+        const challenge = {
+            publicKey: {
+                challenge: uint8ArrayToBase64(challengeBytes),
+                allowCredentials: [
+                    { id: uint8ArrayToBase64(allowIdBytes), type: "public-key" },
+                ],
+            },
+        };
+        const options = prepareAuthenticationOptions(challenge);
+        const publicKey = options.publicKey;
+        expect(publicKey.challenge).toEqual(challengeBytes);
+        expect(publicKey.allowCredentials[0].id).toEqual(allowIdBytes);
+    });
+});
+/** builds a fake PublicKeyCredential-shaped object for registration; only
+ *  the fields serializeRegistrationCredential reads are present. */
+function fakeRegistrationCredential() {
+    return {
+        id: "cred-id",
+        rawId: new Uint8Array([1, 2, 3]).buffer,
+        response: {
+            attestationObject: new Uint8Array([4, 5]).buffer,
+            clientDataJSON: new Uint8Array([6, 7]).buffer,
+        },
+    };
+}
+/** builds a fake PublicKeyCredential-shaped object for authentication. */
+function fakeAuthenticationCredential(withUserHandle) {
+    return {
+        id: "cred-id",
+        rawId: new Uint8Array([1, 2, 3]).buffer,
+        response: {
+            authenticatorData: new Uint8Array([8]).buffer,
+            clientDataJSON: new Uint8Array([9]).buffer,
+            signature: new Uint8Array([10]).buffer,
+            userHandle: withUserHandle ? new Uint8Array([11]).buffer : null,
+        },
+    };
+}
+describe("serializeRegistrationCredential", () => {
+    it("serializes a credential into the server wire format", () => {
+        const serialized = serializeRegistrationCredential(fakeRegistrationCredential());
+        expect(serialized).toEqual({
+            id: "cred-id",
+            rawId: uint8ArrayToBase64(new Uint8Array([1, 2, 3])),
+            type: "public-key",
+            response: {
+                attestationObject: uint8ArrayToBase64(new Uint8Array([4, 5])),
+                clientDataJSON: uint8ArrayToBase64(new Uint8Array([6, 7])),
+            },
+        });
+    });
+});
+describe("serializeAuthenticationCredential", () => {
+    it("serializes a credential with a user handle", () => {
+        const serialized = serializeAuthenticationCredential(fakeAuthenticationCredential(true));
+        expect(serialized.response.userHandle).toBe(uint8ArrayToBase64(new Uint8Array([11])));
+    });
+    it("omits userHandle when the authenticator did not send one (discoverable flow)", () => {
+        const serialized = serializeAuthenticationCredential(fakeAuthenticationCredential(false));
+        expect(serialized.response.userHandle).toBeUndefined();
+    });
+});
+describe("isWebAuthnAvailable", () => {
+    it("is false when navigator is absent (node/vitest environment)", () => {
+        expect(isWebAuthnAvailable()).toBe(false);
+    });
+});

package/dist/webauthn/index.d.ts

@@ -0,0 +1,7 @@
+export type { RegisterPublicKeyCredential, AuthenticationPublicKeyCredential, ServerCredentialDescriptor, RegistrationChallenge, AuthenticationChallenge, } from "./types.js";
+export { AuthenticatorAttestationResponseSchema, RegisterPublicKeyCredentialSchema, AuthenticatorAssertionResponseSchema, AuthenticationPublicKeyCredentialSchema, } from "./types.js";
+export { arrayBufferToBase64, base64ToUint8Array, isWebAuthnAvailable, prepareAuthenticationOptions, prepareRegistrationOptions, serializeAuthenticationCredential, serializeRegistrationCredential, uint8ArrayToBase64, } from "./codec.js";
+export type { AuthOutcome, ChallengeResponse, FinishRequest, LoginStartRequest, RegisterStartRequest, TransportFailure, TransportResult, TransportSuccess, WebauthnTransport, WhoamiOutcome, } from "./transport.js";
+export type { AuthenticateArgs, CeremonyFailure, CeremonyResult, CreateCredentialFn, GetCredentialFn, LoginPasskeyArgs, PasskeyCeremonyDeps, RegisterPasskeyArgs, } from "./ceremony.js";
+export { authenticate, loginWithPasskey, registerWithPasskey, whoami, } from "./ceremony.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/webauthn/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/webauthn/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,sCAAsC,EACtC,iCAAiC,EACjC,oCAAoC,EACpC,uCAAuC,GACxC,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,4BAA4B,EAC5B,0BAA0B,EAC1B,iCAAiC,EACjC,+BAA+B,EAC/B,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,GACd,MAAM,gBAAgB,CAAC;AAExB,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EACnB,MAAM,GACP,MAAM,eAAe,CAAC"}

package/dist/webauthn/index.js

@@ -0,0 +1,3 @@
+export { AuthenticatorAttestationResponseSchema, RegisterPublicKeyCredentialSchema, AuthenticatorAssertionResponseSchema, AuthenticationPublicKeyCredentialSchema, } from "./types.js";
+export { arrayBufferToBase64, base64ToUint8Array, isWebAuthnAvailable, prepareAuthenticationOptions, prepareRegistrationOptions, serializeAuthenticationCredential, serializeRegistrationCredential, uint8ArrayToBase64, } from "./codec.js";
+export { authenticate, loginWithPasskey, registerWithPasskey, whoami, } from "./ceremony.js";

package/dist/webauthn/transport.d.ts

@@ -0,0 +1,58 @@
+import type { AuthenticationChallenge, AuthenticationPublicKeyCredential, RegisterPublicKeyCredential, RegistrationChallenge } from "./types.js";
+export interface TransportSuccess<T> {
+    success: true;
+    data: T;
+}
+export interface TransportFailure {
+    success: false;
+    error: string;
+}
+export type TransportResult<T> = TransportSuccess<T> | TransportFailure;
+export interface RegisterStartRequest {
+    username: string;
+    /** the caller's origin, forwarded so the server can derive its rp id. */
+    origin: string;
+    /** required unless the caller already has an authenticated device link
+     *  to the target identity (adding a second passkey via node-based auth). */
+    inviteCode?: string;
+}
+export interface LoginStartRequest {
+    /** omit for the discoverable-credential flow (authenticator picks). */
+    username?: string;
+    origin: string;
+}
+/**
+ * a start call's response: the challenge to feed the browser, plus a round
+ * -trip token identifying it server-side. `nonce` is present for a p2p
+ * remote and absent for an http remote, which instead carries the
+ * challenge state in a session cookie.
+ */
+export interface ChallengeResponse<TChallenge> {
+    nonce?: string;
+    challenge: TChallenge;
+}
+export interface FinishRequest<TCredential> {
+    nonce?: string;
+    origin: string;
+    credential: TCredential;
+}
+export interface AuthOutcome {
+    userId?: string;
+    username?: string;
+    role?: string;
+}
+export interface WhoamiOutcome {
+    authenticated: boolean;
+    userId?: string;
+    username?: string;
+    role?: string;
+}
+/** the four ceremony calls plus a caller-identity check, bound to one remote. */
+export interface WebauthnTransport {
+    registerStart(req: RegisterStartRequest): Promise<TransportResult<ChallengeResponse<RegistrationChallenge>>>;
+    registerFinish(req: FinishRequest<RegisterPublicKeyCredential>): Promise<TransportResult<AuthOutcome>>;
+    loginStart(req: LoginStartRequest): Promise<TransportResult<ChallengeResponse<AuthenticationChallenge>>>;
+    loginFinish(req: FinishRequest<AuthenticationPublicKeyCredential>): Promise<TransportResult<AuthOutcome>>;
+    whoami(): Promise<WhoamiOutcome>;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/webauthn/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/webauthn/transport.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,uBAAuB,EACvB,iCAAiC,EACjC,2BAA2B,EAC3B,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,CAAC,CAAC;CACT;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC;AAExE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf;gFAC4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB,CAAC,UAAU;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,UAAU,CAAC;CACvB;AAED,MAAM,WAAW,aAAa,CAAC,WAAW;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,WAAW,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,iFAAiF;AACjF,MAAM,WAAW,iBAAiB;IAChC,aAAa,CACX,GAAG,EAAE,oBAAoB,GACxB,OAAO,CAAC,eAAe,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;IACtE,cAAc,CACZ,GAAG,EAAE,aAAa,CAAC,2BAA2B,CAAC,GAC9C,OAAO,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC;IACzC,UAAU,CACR,GAAG,EAAE,iBAAiB,GACrB,OAAO,CAAC,eAAe,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC;IACxE,WAAW,CACT,GAAG,EAAE,aAAa,CAAC,iCAAiC,CAAC,GACpD,OAAO,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC;IACzC,MAAM,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;CAClC"}

package/dist/webauthn/transport.js

@@ -0,0 +1,6 @@
+// the transport surface a webauthn ceremony runs against - an injected
+// dependency so the same ceremony logic serves an http remote (ceremony
+// state carried in a session cookie) and a p2p remote (ceremony state
+// threaded through an explicit nonce) alike. concrete transports (http
+// fetch, p2p client bindings) live with the consuming app.
+export {};

package/dist/webauthn/types.d.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+export declare const AuthenticatorAttestationResponseSchema: z.ZodObject<{
+    attestationObject: z.ZodString;
+    clientDataJSON: z.ZodString;
+}, z.core.$strip>;
+export declare const RegisterPublicKeyCredentialSchema: z.ZodObject<{
+    id: z.ZodString;
+    rawId: z.ZodString;
+    type: z.ZodLiteral<"public-key">;
+    response: z.ZodObject<{
+        attestationObject: z.ZodString;
+        clientDataJSON: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AuthenticatorAssertionResponseSchema: z.ZodObject<{
+    authenticatorData: z.ZodString;
+    clientDataJSON: z.ZodString;
+    signature: z.ZodString;
+    userHandle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AuthenticationPublicKeyCredentialSchema: z.ZodObject<{
+    id: z.ZodString;
+    rawId: z.ZodString;
+    type: z.ZodLiteral<"public-key">;
+    response: z.ZodObject<{
+        authenticatorData: z.ZodString;
+        clientDataJSON: z.ZodString;
+        signature: z.ZodString;
+        userHandle: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RegisterPublicKeyCredential = z.infer<typeof RegisterPublicKeyCredentialSchema>;
+export type AuthenticationPublicKeyCredential = z.infer<typeof AuthenticationPublicKeyCredentialSchema>;
+/** a base64url-encoded credential descriptor, as sent by the server. */
+export interface ServerCredentialDescriptor {
+    id: string;
+    type: "public-key";
+    transports?: AuthenticatorTransport[];
+}
+/**
+ * the server's registration challenge, ready to feed into
+ * `prepareRegistrationOptions`. base64url fields (challenge, user.id,
+ * excludeCredentials[].id) are still strings at this point - the browser
+ * needs raw bytes, which prepareRegistrationOptions converts.
+ */
+export interface RegistrationChallenge {
+    publicKey: {
+        rp: {
+            id?: string;
+            name: string;
+        };
+        user: {
+            id: string;
+            name: string;
+            displayName: string;
+        };
+        challenge: string;
+        pubKeyCredParams: PublicKeyCredentialParameters[];
+        timeout?: number;
+        excludeCredentials?: ServerCredentialDescriptor[];
+        authenticatorSelection?: AuthenticatorSelectionCriteria;
+        attestation?: AttestationConveyancePreference;
+    };
+}
+/**
+ * the server's authentication challenge, ready to feed into
+ * `prepareAuthenticationOptions`.
+ */
+export interface AuthenticationChallenge {
+    publicKey: {
+        challenge: string;
+        timeout?: number;
+        rpId?: string;
+        allowCredentials?: ServerCredentialDescriptor[];
+        userVerification?: UserVerificationRequirement;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/webauthn/types.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sCAAsC;;;iBAGjD,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;iBAK5C,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;iBAK/C,CAAC;AAEH,eAAO,MAAM,uCAAuC;;;;;;;;;;iBAKlD,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAC;AAEF,wEAAwE;AACxE,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,UAAU,CAAC,EAAE,sBAAsB,EAAE,CAAC;CACvC;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE;QACT,EAAE,EAAE;YAAE,EAAE,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;QAClC,IAAI,EAAE;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAE,CAAC;QACxD,SAAS,EAAE,MAAM,CAAC;QAClB,gBAAgB,EAAE,6BAA6B,EAAE,CAAC;QAClD,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,kBAAkB,CAAC,EAAE,0BAA0B,EAAE,CAAC;QAClD,sBAAsB,CAAC,EAAE,8BAA8B,CAAC;QACxD,WAAW,CAAC,EAAE,+BAA+B,CAAC;KAC/C,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE;QACT,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,gBAAgB,CAAC,EAAE,0BAA0B,EAAE,CAAC;QAChD,gBAAgB,CAAC,EAAE,2BAA2B,CAAC;KAChD,CAAC;CACH"}

package/dist/webauthn/types.js

@@ -0,0 +1,29 @@
+// wire shapes for the webauthn passkey ceremony: the credential blobs the
+// browser hands back from navigator.credentials.create()/get() (serialized
+// to base64url strings for transport), and the server's challenge shapes fed
+// into those calls. field names are camelCase, matching the friendz
+// protocol's wire convention and the shapes webauthn-rs (the rust side's
+// ceremony implementation) serializes.
+import { z } from "zod";
+export const AuthenticatorAttestationResponseSchema = z.object({
+    attestationObject: z.string(),
+    clientDataJSON: z.string(),
+});
+export const RegisterPublicKeyCredentialSchema = z.object({
+    id: z.string(),
+    rawId: z.string(),
+    type: z.literal("public-key"),
+    response: AuthenticatorAttestationResponseSchema,
+});
+export const AuthenticatorAssertionResponseSchema = z.object({
+    authenticatorData: z.string(),
+    clientDataJSON: z.string(),
+    signature: z.string(),
+    userHandle: z.string().optional(),
+});
+export const AuthenticationPublicKeyCredentialSchema = z.object({
+    id: z.string(),
+    rawId: z.string(),
+    type: z.literal("public-key"),
+    response: AuthenticatorAssertionResponseSchema,
+});

package/package.json

@@ -0,0 +1,83 @@
+{
+    "name": "@freqhole/haruspex",
+    "version": "0.0.0",
+    "private": false,
+    "type": "module",
+    "description": "freqhole auth domain: identity, webauthn, knock + friendz protocols, permissions",
+    "license": "UNLICENSED",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/freqhole/tomb"
+    },
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./identity": {
+            "types": "./dist/identity/index.d.ts",
+            "import": "./dist/identity/index.js"
+        },
+        "./webauthn": {
+            "types": "./dist/webauthn/index.d.ts",
+            "import": "./dist/webauthn/index.js"
+        },
+        "./knock": {
+            "types": "./dist/knock/index.d.ts",
+            "import": "./dist/knock/index.js"
+        },
+        "./share": {
+            "types": "./dist/share/index.d.ts",
+            "import": "./dist/share/index.js"
+        },
+        "./flows": {
+            "types": "./dist/flows/index.d.ts",
+            "import": "./dist/flows/index.js"
+        },
+        "./permissions": {
+            "types": "./dist/permissions/index.d.ts",
+            "import": "./dist/permissions/index.js"
+        },
+        "./protocol": {
+            "types": "./dist/protocol/index.d.ts",
+            "import": "./dist/protocol/index.js"
+        },
+        "./state": {
+            "types": "./dist/state/index.d.ts",
+            "import": "./dist/state/index.js"
+        },
+        "./solid": {
+            "types": "./dist/solid/index.d.ts",
+            "import": "./dist/solid/index.js"
+        },
+        "./testing": {
+            "types": "./dist/testing/index.d.ts",
+            "import": "./dist/testing/index.js"
+        }
+    },
+    "scripts": {
+        "build": "tsc -p tsconfig.json",
+        "typecheck": "tsc --noEmit",
+        "test": "vitest run"
+    },
+    "peerDependencies": {
+        "solid-js": "^1.9.0",
+        "zod": "^4.3.5"
+    },
+    "peerDependenciesMeta": {
+        "solid-js": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@types/node": "^26.1.1",
+        "fake-indexeddb": "^6.0.0",
+        "solid-js": "^1.9.0",
+        "typescript": "^5.6.0",
+        "vitest": "^2.1.0",
+        "zod": "^4.3.5"
+    }
+}