@freqhole/haruspex 0.0.0

package/dist/share/codec.test.js

@@ -0,0 +1,150 @@
+import { describe, expect, it } from "vitest";
+import { decodeShareToken, encodeShareToken, extractShareToken, shareFragment, } from "./codec.js";
+const NODE_ID = "ab".repeat(32);
+const OTHER_NODE_ID = "cd".repeat(32);
+describe("encodeShareToken / decodeShareToken (current wire)", () => {
+    it("round-trips a node payload", () => {
+        const payload = { kind: "node", nodeId: NODE_ID, title: "my node" };
+        const token = encodeShareToken(payload);
+        expect(decodeShareToken(token)).toEqual(payload);
+    });
+    it("round-trips a doc payload with mode + title", () => {
+        const payload = {
+            kind: "doc",
+            nodeId: NODE_ID,
+            docId: "automerge:abc123",
+            title: "shared playlist",
+            mode: "knock",
+        };
+        const token = encodeShareToken(payload);
+        expect(decodeShareToken(token)).toEqual(payload);
+    });
+    it("round-trips a doc payload with no optional fields", () => {
+        const payload = { kind: "doc", nodeId: NODE_ID, docId: "automerge:xyz" };
+        const token = encodeShareToken(payload);
+        expect(decodeShareToken(token)).toEqual(payload);
+    });
+    it("round-trips an entity payload", () => {
+        const payload = {
+            kind: "entity",
+            source: { nodeId: NODE_ID, httpOrigin: "https://music.example.com" },
+            entityKind: "album",
+            entityId: "album-1",
+            parentId: "artist-1",
+            title: "a great album",
+            artist: "someone",
+            album: "a great album",
+        };
+        const token = encodeShareToken(payload);
+        expect(decodeShareToken(token)).toEqual(payload);
+    });
+    it("round-trips unicode titles", () => {
+        const payload = {
+            kind: "doc",
+            nodeId: NODE_ID,
+            docId: "automerge:abc",
+            title: "\u65e5\u672c\u8a9e \ud83c\udfb5",
+        };
+        const token = encodeShareToken(payload);
+        expect(decodeShareToken(token)).toEqual(payload);
+    });
+    it("wraps the token in a #share/ fragment and decodes it back", () => {
+        const payload = { kind: "node", nodeId: NODE_ID };
+        const fragment = shareFragment(payload);
+        expect(fragment.startsWith("#share/")).toBe(true);
+        expect(decodeShareToken(fragment)).toEqual(payload);
+    });
+    it("decodes a token embedded in a full url", () => {
+        const payload = { kind: "node", nodeId: NODE_ID };
+        const token = encodeShareToken(payload);
+        const url = `https://example.com/app/${shareFragment(payload)}`;
+        expect(decodeShareToken(url)).toEqual(payload);
+        expect(extractShareToken(url)).toBe(token);
+    });
+});
+describe("decodeShareToken (legacy shapes)", () => {
+    it("decodes the legacy versioned doc shape {v:1,n,d,t,m}", () => {
+        const legacy = { v: 1, n: NODE_ID, d: "automerge:legacy", t: "old link", m: "public" };
+        const token = btoa(JSON.stringify(legacy))
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=+$/, "");
+        expect(decodeShareToken(token)).toEqual({
+            kind: "doc",
+            nodeId: NODE_ID,
+            docId: "automerge:legacy",
+            title: "old link",
+            mode: "public",
+        });
+    });
+    it("decodes the bare, unversioned doc shape {n,d}", () => {
+        const legacy = { n: NODE_ID, d: "automerge:bare" };
+        const token = btoa(JSON.stringify(legacy));
+        expect(decodeShareToken(token)).toEqual({
+            kind: "doc",
+            nodeId: NODE_ID,
+            docId: "automerge:bare",
+        });
+    });
+    it("decodes the legacy entity permalink shape {v:1,s:{n,h},k,i,...}", () => {
+        const legacy = {
+            v: 1,
+            s: { n: NODE_ID, h: "https://spume.example.com" },
+            k: "song",
+            i: "song-1",
+            p: "album-1",
+            t: "a song",
+            a: "an artist",
+            al: "an album",
+        };
+        const json = JSON.stringify(legacy);
+        let bin = "";
+        for (const byte of new TextEncoder().encode(json))
+            bin += String.fromCharCode(byte);
+        const token = btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+        expect(decodeShareToken(token)).toEqual({
+            kind: "entity",
+            source: { nodeId: NODE_ID, httpOrigin: "https://spume.example.com" },
+            entityKind: "song",
+            entityId: "song-1",
+            parentId: "album-1",
+            title: "a song",
+            artist: "an artist",
+            album: "an album",
+        });
+    });
+    it("decodes a legacy token behind #share/ and share/ prefixes", () => {
+        const legacy = { n: NODE_ID, d: OTHER_NODE_ID };
+        const token = btoa(JSON.stringify(legacy));
+        expect(decodeShareToken(`#share/${token}`)).toEqual({
+            kind: "doc",
+            nodeId: NODE_ID,
+            docId: OTHER_NODE_ID,
+        });
+        expect(decodeShareToken(`share/${token}`)).toEqual({
+            kind: "doc",
+            nodeId: NODE_ID,
+            docId: OTHER_NODE_ID,
+        });
+    });
+});
+describe("decodeShareToken (invalid input)", () => {
+    it("returns null for empty input", () => {
+        expect(decodeShareToken("")).toBeNull();
+        expect(decodeShareToken("   ")).toBeNull();
+    });
+    it("returns null for non-base64 garbage", () => {
+        expect(decodeShareToken("not a token!!! ###")).toBeNull();
+    });
+    it("returns null for valid base64 that isn't json", () => {
+        expect(decodeShareToken(btoa("just a string"))).toBeNull();
+    });
+    it("returns null for json that matches no known shape", () => {
+        const token = btoa(JSON.stringify({ foo: "bar" }));
+        expect(decodeShareToken(token)).toBeNull();
+    });
+    it("returns null for a wire payload with an unsupported version", () => {
+        const token = btoa(JSON.stringify({ v: 99, k: "node", n: NODE_ID }));
+        expect(decodeShareToken(token)).toBeNull();
+    });
+});

package/dist/share/detect.d.ts

@@ -0,0 +1,24 @@
+import type { ShareTokenPayload } from "./codec.js";
+/**
+ * classification of a raw string: a bare node id, a share token
+ * (optionally embedded in a url fragment), or neither.
+ */
+export type ShareInputDetection = {
+    kind: "node_id";
+    nodeId: string;
+} | {
+    kind: "share_token";
+    token: string;
+    payload: ShareTokenPayload;
+} | {
+    kind: "invalid";
+};
+/**
+ * classify raw input as a node id, a share token, or neither. node id
+ * detection reuses extractNodeIdStrict so this never diverges from
+ * parsePeerAddress's own notion of a valid peer address; share-token
+ * detection reuses decodeShareToken/extractShareToken so a full url with
+ * the token in its fragment classifies the same way a bare token does.
+ */
+export declare function detectShareInput(input: string): ShareInputDetection;
+//# sourceMappingURL=detect.d.ts.map

package/dist/share/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../src/share/detect.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpD;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,iBAAiB,CAAA;CAAE,GAClE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAExB;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAcnE"}

package/dist/share/detect.js

@@ -0,0 +1,25 @@
+// classification of raw strings a user might paste or type into a
+// peer-address / share-link input box.
+import { decodeShareToken, extractShareToken } from "./codec.js";
+import { extractNodeIdStrict } from "./peer-addr.js";
+/**
+ * classify raw input as a node id, a share token, or neither. node id
+ * detection reuses extractNodeIdStrict so this never diverges from
+ * parsePeerAddress's own notion of a valid peer address; share-token
+ * detection reuses decodeShareToken/extractShareToken so a full url with
+ * the token in its fragment classifies the same way a bare token does.
+ */
+export function detectShareInput(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return { kind: "invalid" };
+    const nodeId = extractNodeIdStrict(trimmed);
+    if (nodeId) {
+        return { kind: "node_id", nodeId };
+    }
+    const token = extractShareToken(trimmed);
+    const payload = decodeShareToken(token);
+    if (!payload)
+        return { kind: "invalid" };
+    return { kind: "share_token", token, payload };
+}

package/dist/share/detect.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=detect.test.d.ts.map

package/dist/share/detect.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.test.d.ts","sourceRoot":"","sources":["../../src/share/detect.test.ts"],"names":[],"mappings":""}

package/dist/share/detect.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { detectShareInput } from "./detect.js";
+import { encodeShareToken, shareFragment } from "./codec.js";
+const NODE_ID = "ab".repeat(32);
+describe("detectShareInput", () => {
+    it("classifies a bare 64-hex node id", () => {
+        expect(detectShareInput(NODE_ID)).toEqual({ kind: "node_id", nodeId: NODE_ID });
+    });
+    it("classifies a json endpoint blob as a node id", () => {
+        const blob = JSON.stringify({ node_id: NODE_ID, relay_url: "https://relay.example" });
+        expect(detectShareInput(blob)).toEqual({ kind: "node_id", nodeId: NODE_ID });
+    });
+    it("classifies a bare share token", () => {
+        const payload = { kind: "doc", nodeId: NODE_ID, docId: "automerge:abc" };
+        const token = encodeShareToken(payload);
+        expect(detectShareInput(token)).toEqual({ kind: "share_token", token, payload });
+    });
+    it("classifies a url with the token in its fragment", () => {
+        const payload = { kind: "doc", nodeId: NODE_ID, docId: "automerge:xyz" };
+        const token = encodeShareToken(payload);
+        const url = `https://example.com/app/${shareFragment(payload)}`;
+        expect(detectShareInput(url)).toEqual({ kind: "share_token", token, payload });
+    });
+    it("classifies empty input as invalid", () => {
+        expect(detectShareInput("")).toEqual({ kind: "invalid" });
+        expect(detectShareInput("   ")).toEqual({ kind: "invalid" });
+    });
+    it("classifies garbage as invalid", () => {
+        expect(detectShareInput("not a node id or a token")).toEqual({ kind: "invalid" });
+    });
+});

package/dist/share/index.d.ts

@@ -0,0 +1,7 @@
+export { extractNodeId, extractNodeIdStrict, isValidNodeId, parsePeerAddress, } from "./peer-addr.js";
+export type { PeerTarget } from "./peer-addr.js";
+export type { DocSharePayload, EntitySharePayload, NodeSharePayload, ShareTokenPayload, } from "./codec.js";
+export { decodeShareToken, encodeShareToken, extractShareToken, shareFragment, } from "./codec.js";
+export type { ShareInputDetection } from "./detect.js";
+export { detectShareInput } from "./detect.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/share/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}

package/dist/share/index.js

@@ -0,0 +1,3 @@
+export { extractNodeId, extractNodeIdStrict, isValidNodeId, parsePeerAddress, } from "./peer-addr.js";
+export { decodeShareToken, encodeShareToken, extractShareToken, shareFragment, } from "./codec.js";
+export { detectShareInput } from "./detect.js";

package/dist/share/peer-addr.d.ts

@@ -0,0 +1,32 @@
+/** true when `value` is a bare 64-hex node id. */
+export declare function isValidNodeId(value: string): boolean;
+/**
+ * extract the 64-hex node id from a `peer_addr` string (bare id or json
+ * endpoint blob). falls back to returning the raw value when it cannot
+ * be parsed.
+ */
+export declare function extractNodeId(peerAddr: string): string;
+/** strict variant: null when a 64-hex node id could not be derived. */
+export declare function extractNodeIdStrict(peerAddr: string): string | null;
+/** a classified peer target: p2p (addressed by node id / endpoint json)
+ *  or http (addressed by base url). */
+export type PeerTarget = {
+    type: "p2p";
+    peerAddr: string;
+} | {
+    type: "http";
+    url: string;
+};
+/**
+ * classify raw user input as a p2p peer address or an http url.
+ *
+ * - a bare 64-hex string is a node id (p2p)
+ * - a json blob with a string `id` or `node_id` field is a full endpoint (p2p)
+ * - anything else is treated as an http url, scheme-prefixed with
+ *   `defaultScheme` when missing and trailing-slash trimmed
+ *
+ * returns null for empty input. url VALIDITY is not checked here - the
+ * caller decides how to validate/normalize further.
+ */
+export declare function parsePeerAddress(input: string, defaultScheme?: "http" | "https"): PeerTarget | null;
+//# sourceMappingURL=peer-addr.d.ts.map

package/dist/share/peer-addr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer-addr.d.ts","sourceRoot":"","sources":["../../src/share/peer-addr.ts"],"names":[],"mappings":"AAQA,kDAAkD;AAClD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWtD;AAED,uEAAuE;AACvE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGnE;AAED;uCACuC;AACvC,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3F;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,aAAa,GAAE,MAAM,GAAG,OAAiB,GACxC,UAAU,GAAG,IAAI,CAyBnB"}

package/dist/share/peer-addr.js

@@ -0,0 +1,72 @@
+// peer-address helpers: classify and normalize the strings apps use to
+// address a peer. a `peer_addr` may be a bare 64-hex iroh node id, or a
+// json endpoint blob carrying the node id under `node_id` (full endpoint
+// dumps) or `id` (compact share forms); anything else is treated as an
+// http url.
+const NODE_ID_RE = /^[0-9a-f]{64}$/i;
+/** true when `value` is a bare 64-hex node id. */
+export function isValidNodeId(value) {
+    return NODE_ID_RE.test(value.trim());
+}
+/**
+ * extract the 64-hex node id from a `peer_addr` string (bare id or json
+ * endpoint blob). falls back to returning the raw value when it cannot
+ * be parsed.
+ */
+export function extractNodeId(peerAddr) {
+    const trimmed = peerAddr.trim();
+    if (NODE_ID_RE.test(trimmed))
+        return trimmed;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed?.node_id === "string")
+            return parsed.node_id;
+        if (typeof parsed?.id === "string")
+            return parsed.id;
+    }
+    catch {
+        // not json
+    }
+    return peerAddr;
+}
+/** strict variant: null when a 64-hex node id could not be derived. */
+export function extractNodeIdStrict(peerAddr) {
+    const id = extractNodeId(peerAddr);
+    return NODE_ID_RE.test(id) ? id : null;
+}
+/**
+ * classify raw user input as a p2p peer address or an http url.
+ *
+ * - a bare 64-hex string is a node id (p2p)
+ * - a json blob with a string `id` or `node_id` field is a full endpoint (p2p)
+ * - anything else is treated as an http url, scheme-prefixed with
+ *   `defaultScheme` when missing and trailing-slash trimmed
+ *
+ * returns null for empty input. url VALIDITY is not checked here - the
+ * caller decides how to validate/normalize further.
+ */
+export function parsePeerAddress(input, defaultScheme = "https") {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return null;
+    if (NODE_ID_RE.test(trimmed)) {
+        return { type: "p2p", peerAddr: trimmed };
+    }
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed?.id === "string" || typeof parsed?.node_id === "string") {
+                return { type: "p2p", peerAddr: trimmed };
+            }
+        }
+        catch {
+            // not valid json, fall through to url handling
+        }
+    }
+    let url = trimmed;
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+        url = `${defaultScheme}://${url}`;
+    }
+    url = url.replace(/\/+$/, "");
+    return { type: "http", url };
+}

package/dist/share/peer-addr.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=peer-addr.test.d.ts.map

package/dist/share/peer-addr.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer-addr.test.d.ts","sourceRoot":"","sources":["../../src/share/peer-addr.test.ts"],"names":[],"mappings":""}

package/dist/share/peer-addr.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { extractNodeId, extractNodeIdStrict, isValidNodeId, parsePeerAddress, } from "./peer-addr.js";
+const NODE_ID = "ab".repeat(32);
+describe("isValidNodeId", () => {
+    it("accepts a 64-hex id (either case, surrounding whitespace ok)", () => {
+        expect(isValidNodeId(NODE_ID)).toBe(true);
+        expect(isValidNodeId(` ${NODE_ID.toUpperCase()} `)).toBe(true);
+    });
+    it("rejects wrong lengths and non-hex", () => {
+        expect(isValidNodeId(NODE_ID.slice(1))).toBe(false);
+        expect(isValidNodeId("z".repeat(64))).toBe(false);
+        expect(isValidNodeId("")).toBe(false);
+    });
+});
+describe("extractNodeId", () => {
+    it("passes a bare id through", () => {
+        expect(extractNodeId(NODE_ID)).toBe(NODE_ID);
+    });
+    it("reads node_id or id out of a json endpoint blob", () => {
+        expect(extractNodeId(JSON.stringify({ node_id: NODE_ID, relay_url: "x" }))).toBe(NODE_ID);
+        expect(extractNodeId(JSON.stringify({ id: NODE_ID }))).toBe(NODE_ID);
+    });
+    it("falls back to the raw value when unparseable", () => {
+        expect(extractNodeId("not json")).toBe("not json");
+        expect(extractNodeIdStrict("not json")).toBeNull();
+        expect(extractNodeIdStrict(JSON.stringify({ id: NODE_ID }))).toBe(NODE_ID);
+    });
+});
+describe("parsePeerAddress", () => {
+    it("classifies a bare node id as p2p", () => {
+        expect(parsePeerAddress(` ${NODE_ID} `)).toEqual({ type: "p2p", peerAddr: NODE_ID });
+    });
+    it("classifies a json endpoint blob as p2p, keeping the blob intact", () => {
+        const blob = JSON.stringify({ id: NODE_ID, relay_url: "https://r.example" });
+        expect(parsePeerAddress(blob)).toEqual({ type: "p2p", peerAddr: blob });
+    });
+    it("json without an id field falls through to http", () => {
+        const result = parsePeerAddress('{"foo": 1}');
+        expect(result?.type).toBe("http");
+    });
+    it("normalizes http input: default scheme + trailing slash trim", () => {
+        expect(parsePeerAddress("music.example.com/")).toEqual({
+            type: "http",
+            url: "https://music.example.com",
+        });
+        expect(parsePeerAddress("music.example.com", "http")).toEqual({
+            type: "http",
+            url: "http://music.example.com",
+        });
+        expect(parsePeerAddress("https://music.example.com//")).toEqual({
+            type: "http",
+            url: "https://music.example.com",
+        });
+    });
+    it("returns null for empty input", () => {
+        expect(parsePeerAddress("   ")).toBeNull();
+    });
+});

package/dist/solid/auth-form.d.ts

@@ -0,0 +1,43 @@
+import { type Accessor, type Setter } from "solid-js";
+export type AuthMode = "login" | "register";
+export interface AuthFormData {
+    username: string;
+    inviteCode?: string;
+    mode: AuthMode;
+}
+export interface AuthFormDeps {
+    /** starting mode. defaults to "login". */
+    initialMode?: AuthMode;
+    /** reactive read of the current loading state (e.g. `() => isLoading()`).
+     *  while true, submit and passkey handlers no-op instead of firing
+     *  another request. defaults to `() => false`. */
+    loading?: () => boolean;
+    onSubmit?: (data: AuthFormData) => void | Promise<void>;
+    onPasskeyClick?: (data: AuthFormData) => void | Promise<void>;
+    onModeChange?: (mode: AuthMode) => void;
+}
+export interface AuthFormState {
+    mode: Accessor<AuthMode>;
+    username: Accessor<string>;
+    setUsername: Setter<string>;
+    inviteCode: Accessor<string>;
+    setInviteCode: Setter<string>;
+    /** true when the current field values don't satisfy submission
+     *  (blank username, or register mode with a blank invite code) or the
+     *  form is loading. */
+    isSubmitDisabled: Accessor<boolean>;
+    /** flips between login and register, notifying `onModeChange`. */
+    switchMode(): void;
+    /** builds the current `AuthFormData` and calls `onSubmit`. no-ops while
+     *  loading. `event?.preventDefault()` is called if an event is passed,
+     *  so this can be wired directly to a `<form onSubmit>`. */
+    handleSubmit(event?: {
+        preventDefault(): void;
+    }): Promise<void>;
+    /** same shape as `handleSubmit`, but calls `onPasskeyClick`. */
+    handlePasskeyClick(event?: {
+        preventDefault(): void;
+    }): Promise<void>;
+}
+export declare function createAuthForm(deps?: AuthFormDeps): AuthFormState;
+//# sourceMappingURL=auth-form.d.ts.map

package/dist/solid/auth-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-form.d.ts","sourceRoot":"","sources":["../../src/solid/auth-form.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgB,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAEpE,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,UAAU,CAAC;AAE5C,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,0CAA0C;IAC1C,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB;;sDAEkD;IAClD,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5B,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9B;;2BAEuB;IACvB,gBAAgB,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IACpC,kEAAkE;IAClE,UAAU,IAAI,IAAI,CAAC;IACnB;;gEAE4D;IAC5D,YAAY,CAAC,KAAK,CAAC,EAAE;QAAE,cAAc,IAAI,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE,gEAAgE;IAChE,kBAAkB,CAAC,KAAK,CAAC,EAAE;QAAE,cAAc,IAAI,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;AAED,wBAAgB,cAAc,CAAC,IAAI,GAAE,YAAiB,GAAG,aAAa,CAkDrE"}

package/dist/solid/auth-form.js

@@ -0,0 +1,55 @@
+// headless auth-form state: mode switching (login/register), field
+// signals, submit-disabled logic, and the submit/passkey handlers - all
+// with zero markup or styling opinions. consumers render whatever inputs/
+// buttons they like and wire them to the returned signals/handlers.
+import { createSignal } from "solid-js";
+export function createAuthForm(deps = {}) {
+    const isLoading = deps.loading ?? (() => false);
+    const [mode, setMode] = createSignal(deps.initialMode ?? "login");
+    const [username, setUsername] = createSignal("");
+    const [inviteCode, setInviteCode] = createSignal("");
+    function currentData() {
+        return {
+            username: username(),
+            inviteCode: mode() === "register" ? inviteCode() : undefined,
+            mode: mode(),
+        };
+    }
+    function isSubmitDisabled() {
+        if (isLoading())
+            return true;
+        if (!username().trim())
+            return true;
+        if (mode() === "register" && !inviteCode().trim())
+            return true;
+        return false;
+    }
+    function switchMode() {
+        const next = mode() === "login" ? "register" : "login";
+        setMode(next);
+        deps.onModeChange?.(next);
+    }
+    async function handleSubmit(event) {
+        event?.preventDefault();
+        if (isLoading())
+            return;
+        await deps.onSubmit?.(currentData());
+    }
+    async function handlePasskeyClick(event) {
+        event?.preventDefault();
+        if (isLoading())
+            return;
+        await deps.onPasskeyClick?.(currentData());
+    }
+    return {
+        mode,
+        username,
+        setUsername,
+        inviteCode,
+        setInviteCode,
+        isSubmitDisabled,
+        switchMode,
+        handleSubmit,
+        handlePasskeyClick,
+    };
+}

package/dist/solid/auth-form.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=auth-form.test.d.ts.map

package/dist/solid/auth-form.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-form.test.d.ts","sourceRoot":"","sources":["../../src/solid/auth-form.test.ts"],"names":[],"mappings":""}