@flow-industries/id 0.21.2 → 0.22.1

package/dist/sdk/client/study-search.js

@@ -0,0 +1,116 @@
+export function normalizeSearchText(text) {
+    return text
+        .normalize("NFD")
+        .replace(/\p{M}+/gu, "")
+        .toLowerCase()
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/** 4 exact, 3 prefix, 2 a later word's prefix, 1 substring, 0 no match.
+ * Both sides are normalized here so callers can pass raw labels. */
+export function matchScore(query, candidate) {
+    const normalizedQuery = normalizeSearchText(query);
+    const normalizedCandidate = normalizeSearchText(candidate);
+    if (!normalizedQuery || !normalizedCandidate)
+        return 0;
+    if (normalizedCandidate === normalizedQuery)
+        return 4;
+    if (normalizedCandidate.startsWith(normalizedQuery))
+        return 3;
+    if (normalizedCandidate.includes(` ${normalizedQuery}`))
+        return 2;
+    if (normalizedCandidate.includes(normalizedQuery))
+        return 1;
+    return 0;
+}
+export function catalogFieldIndex(catalog) {
+    const index = new Map();
+    for (const category of catalog.categories) {
+        for (const field of category.fields) {
+            index.set(field.slug, { category, field });
+        }
+    }
+    return index;
+}
+/** Live subjects newest-used first; auth stamps `lastUsedAt` at creation, so
+ * a subject never studied sorts by when it was added. */
+export function recentSubjects(subjects, limit = 5) {
+    return [...subjects]
+        .sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt))
+        .slice(0, limit);
+}
+/** Catalog fields the user already keeps under the field's own name are
+ * hidden from results — the subject hit covers them and picking the field
+ * again would only re-create the same subject. A renamed subject ("Math for
+ * my test" under Algebra) leaves the field visible for a second subject. */
+export function fieldsCoveredBySubjects(subjects, index) {
+    const covered = new Set();
+    for (const subject of subjects) {
+        if (!subject.field)
+            continue;
+        const ref = index.get(subject.field);
+        if (!ref)
+            continue;
+        if (normalizeSearchText(subject.name) === normalizeSearchText(ref.field.label)) {
+            covered.add(subject.field);
+        }
+    }
+    return covered;
+}
+function bestAliasMatch(query, field) {
+    let best = null;
+    for (const alias of field.aliases ?? []) {
+        const score = matchScore(query, alias);
+        if (score > (best?.score ?? 0))
+            best = { alias, score };
+    }
+    return best;
+}
+export function searchStudy(query, options) {
+    const { catalog, subjects, limit = 12 } = options;
+    if (!normalizeSearchText(query))
+        return [];
+    const index = catalogFieldIndex(catalog);
+    const covered = fieldsCoveredBySubjects(subjects, index);
+    const hits = [];
+    for (const subject of subjects) {
+        const ref = subject.field ? (index.get(subject.field) ?? null) : null;
+        let score = matchScore(query, subject.name);
+        if (ref) {
+            score = Math.max(score, matchScore(query, ref.field.label));
+            const alias = bestAliasMatch(query, ref.field);
+            if (alias)
+                score = Math.max(score, alias.score);
+        }
+        if (score > 0) {
+            hits.push({ kind: "subject", id: subject.id, subject, ref, score });
+        }
+    }
+    for (const ref of index.values()) {
+        if (covered.has(ref.field.slug))
+            continue;
+        const labelScore = matchScore(query, ref.field.label);
+        const alias = bestAliasMatch(query, ref.field);
+        const score = Math.max(labelScore, alias?.score ?? 0);
+        if (score === 0)
+            continue;
+        hits.push({
+            kind: "field",
+            id: ref.field.slug,
+            ref,
+            alias: alias && alias.score > labelScore ? alias.alias : null,
+            score,
+        });
+    }
+    hits.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        if (a.kind !== b.kind)
+            return a.kind === "subject" ? -1 : 1;
+        return hitLabel(a).localeCompare(hitLabel(b));
+    });
+    return hits.slice(0, limit);
+}
+export function hitLabel(hit) {
+    return hit.kind === "subject" ? hit.subject.name : hit.ref.field.label;
+}

package/dist/sdk/contracts/http.d.ts

@@ -0,0 +1,155 @@
+import { z } from "zod";
+export declare const httpOperations: {
+    readonly startAction: {
+        readonly path: "/api/actions/start";
+        readonly request: z.ZodObject<{
+            sub: z.ZodString;
+            sessionId: z.ZodString;
+            source: z.ZodString;
+            showTimer: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly eventAction: {
+        readonly path: "/api/actions/event";
+        readonly request: z.ZodObject<{
+            sessionId: z.ZodString;
+            kind: z.ZodEnum<{
+                pause: "pause";
+                resume: "resume";
+                focus_lost: "focus_lost";
+                focus_gained: "focus_gained";
+            }>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            recorded: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly finishAction: {
+        readonly path: "/api/actions/finish";
+        readonly request: z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            xpGranted: z.ZodNullable<z.ZodObject<{
+                granted: z.ZodBoolean;
+                amount: z.ZodNumber;
+                totalXp: z.ZodNumber;
+                flowScore: z.ZodNumber;
+                level: z.ZodNumber;
+                tier: z.ZodNumber;
+                xpIntoLevel: z.ZodNumber;
+                xpForNextLevel: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly reportStateTime: {
+        readonly path: "/api/actions/state-time";
+        readonly request: z.ZodObject<{
+            sub: z.ZodString;
+            day: z.ZodString;
+            states: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly reportXp: {
+        readonly path: "/api/xp/events";
+        readonly request: z.ZodObject<{
+            sub: z.ZodString;
+            source: z.ZodString;
+            durationSeconds: z.ZodOptional<z.ZodNumber>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            granted: z.ZodBoolean;
+            amount: z.ZodNumber;
+            totalXp: z.ZodNumber;
+            flowScore: z.ZodNumber;
+            level: z.ZodNumber;
+            tier: z.ZodNumber;
+            xpIntoLevel: z.ZodNumber;
+            xpForNextLevel: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly reportPresence: {
+        readonly path: "/api/rooms/presence/report";
+        readonly request: z.ZodObject<{
+            channel: z.ZodEnum<{
+                game: "game";
+                voice: "voice";
+                text: "text";
+            }>;
+            rooms: z.ZodArray<z.ZodObject<{
+                roomId: z.ZodString;
+                occupants: z.ZodArray<z.ZodObject<{
+                    sub: z.ZodString;
+                }, z.core.$loose>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly reportPosition: {
+        readonly path: "/api/rooms/position/report";
+        readonly request: z.ZodObject<{
+            positions: z.ZodArray<z.ZodObject<{
+                roomId: z.ZodString;
+                sub: z.ZodString;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                z: z.ZodNumber;
+                yaw: z.ZodNumber;
+                worldId: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            stored: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+};
+export declare const jwtClaimsSchema: z.ZodObject<{
+    sub: z.ZodString;
+    aud: z.ZodString;
+    iss: z.ZodString;
+    iat: z.ZodNumber;
+    exp: z.ZodNumber;
+    guest: z.ZodBoolean;
+    username: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const sessionResponseSchema: z.ZodObject<{
+    jwt: z.ZodString;
+    refreshToken: z.ZodString;
+    user: z.ZodObject<{
+        id: z.ZodString;
+        username: z.ZodString;
+        isGuest: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>;
+    credential: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        publicKey: z.ZodString;
+    }, z.core.$strip>>;
+    additionalSessions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        audience: z.ZodString;
+        jwt: z.ZodString;
+        refreshToken: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$loose>;
+export declare const jwksSchema: z.ZodObject<{
+    keys: z.ZodArray<z.ZodObject<{
+        kid: z.ZodString;
+        kty: z.ZodLiteral<"OKP">;
+        crv: z.ZodLiteral<"Ed25519">;
+        x: z.ZodString;
+        alg: z.ZodOptional<z.ZodLiteral<"EdDSA">>;
+        use: z.ZodOptional<z.ZodLiteral<"sig">>;
+        d: z.ZodOptional<z.ZodNever>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/sdk/contracts/http.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { actionEventSchema, actionFinishSchema, actionStartSchema, positionReportSchema, presenceReportSchema, stateTimeSchema, xpEventSchema, } from "./reports";
+const okResponseSchema = z.object({ ok: z.literal(true) });
+const xpGrantResponseSchema = z.object({
+    granted: z.boolean(),
+    amount: z.number(),
+    totalXp: z.number(),
+    flowScore: z.number(),
+    level: z.number(),
+    tier: z.number(),
+    xpIntoLevel: z.number(),
+    xpForNextLevel: z.number(),
+});
+export const httpOperations = {
+    startAction: {
+        path: "/api/actions/start",
+        request: actionStartSchema,
+        response: okResponseSchema,
+    },
+    eventAction: {
+        path: "/api/actions/event",
+        request: actionEventSchema,
+        response: okResponseSchema.extend({ recorded: z.boolean() }),
+    },
+    finishAction: {
+        path: "/api/actions/finish",
+        request: actionFinishSchema,
+        response: okResponseSchema.extend({
+            xpGranted: xpGrantResponseSchema.nullable(),
+        }),
+    },
+    reportStateTime: {
+        path: "/api/actions/state-time",
+        request: stateTimeSchema,
+        response: okResponseSchema,
+    },
+    reportXp: {
+        path: "/api/xp/events",
+        request: xpEventSchema,
+        response: xpGrantResponseSchema,
+    },
+    reportPresence: {
+        path: "/api/rooms/presence/report",
+        request: presenceReportSchema,
+        response: okResponseSchema,
+    },
+    reportPosition: {
+        path: "/api/rooms/position/report",
+        request: positionReportSchema,
+        response: okResponseSchema.extend({ stored: z.number() }),
+    },
+};
+export const jwtClaimsSchema = z.looseObject({
+    sub: z.string().min(1),
+    aud: z.string().min(1),
+    iss: z.string().min(1),
+    iat: z.number().int(),
+    exp: z.number().int(),
+    guest: z.boolean(),
+    username: z.string().optional(),
+});
+export const sessionResponseSchema = z.looseObject({
+    jwt: z.string().min(1),
+    refreshToken: z.string().min(1),
+    user: z.looseObject({
+        id: z.string(),
+        username: z.string(),
+        isGuest: z.boolean().optional(),
+    }),
+    credential: z.object({ id: z.string(), publicKey: z.string() }).nullable(),
+    additionalSessions: z
+        .array(z.object({
+        audience: z.string(),
+        jwt: z.string(),
+        refreshToken: z.string(),
+    }))
+        .optional(),
+});
+export const jwksSchema = z.object({
+    keys: z
+        .array(z.object({
+        kid: z.string().min(1),
+        kty: z.literal("OKP"),
+        crv: z.literal("Ed25519"),
+        x: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
+        alg: z.literal("EdDSA").optional(),
+        use: z.literal("sig").optional(),
+        d: z.never().optional(),
+    }))
+        .min(1),
+});

package/dist/sdk/contracts/reports.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+/** Game server → auth: a reportable XP event. */
+export declare const xpEventSchema: z.ZodObject<{
+    sub: z.ZodString;
+    source: z.ZodString;
+    durationSeconds: z.ZodOptional<z.ZodNumber>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Talk and the game report a full snapshot of every active room they hold. */
+export declare const presenceReportSchema: z.ZodObject<{
+    channel: z.ZodEnum<{
+        game: "game";
+        voice: "voice";
+        text: "text";
+    }>;
+    rooms: z.ZodArray<z.ZodObject<{
+        roomId: z.ZodString;
+        occupants: z.ZodArray<z.ZodObject<{
+            sub: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The game server checkpoints each tracked player's last grounded footing. */
+export declare const positionReportSchema: z.ZodObject<{
+    positions: z.ZodArray<z.ZodObject<{
+        roomId: z.ZodString;
+        sub: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+        yaw: z.ZodNumber;
+        worldId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const actionStartSchema: z.ZodObject<{
+    sub: z.ZodString;
+    sessionId: z.ZodString;
+    source: z.ZodString;
+    showTimer: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const actionFinishSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, z.core.$strip>;
+export declare const actionEventSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    kind: z.ZodEnum<{
+        pause: "pause";
+        resume: "resume";
+        focus_lost: "focus_lost";
+        focus_gained: "focus_gained";
+    }>;
+}, z.core.$strip>;
+export declare const stateTimeSchema: z.ZodObject<{
+    sub: z.ZodString;
+    day: z.ZodString;
+    states: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export declare const xpDevSchema: z.ZodObject<{
+    sub: z.ZodString;
+    op: z.ZodEnum<{
+        add: "add";
+        set_total: "set_total";
+        set_level: "set_level";
+    }>;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+export declare const reportSchemas: {
+    xpEvent: z.ZodObject<{
+        sub: z.ZodString;
+        source: z.ZodString;
+        durationSeconds: z.ZodOptional<z.ZodNumber>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    presenceReport: z.ZodObject<{
+        channel: z.ZodEnum<{
+            game: "game";
+            voice: "voice";
+            text: "text";
+        }>;
+        rooms: z.ZodArray<z.ZodObject<{
+            roomId: z.ZodString;
+            occupants: z.ZodArray<z.ZodObject<{
+                sub: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    positionReport: z.ZodObject<{
+        positions: z.ZodArray<z.ZodObject<{
+            roomId: z.ZodString;
+            sub: z.ZodString;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            yaw: z.ZodNumber;
+            worldId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    actionStart: z.ZodObject<{
+        sub: z.ZodString;
+        sessionId: z.ZodString;
+        source: z.ZodString;
+        showTimer: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    actionEvent: z.ZodObject<{
+        sessionId: z.ZodString;
+        kind: z.ZodEnum<{
+            pause: "pause";
+            resume: "resume";
+            focus_lost: "focus_lost";
+            focus_gained: "focus_gained";
+        }>;
+    }, z.core.$strip>;
+    actionFinish: z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strip>;
+    stateTime: z.ZodObject<{
+        sub: z.ZodString;
+        day: z.ZodString;
+        states: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+    xpDev: z.ZodObject<{
+        sub: z.ZodString;
+        op: z.ZodEnum<{
+            add: "add";
+            set_total: "set_total";
+            set_level: "set_level";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>;
+};

package/dist/sdk/contracts/reports.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+/** Game server → auth: a reportable XP event. */
+export const xpEventSchema = z.object({
+    sub: z.string(),
+    source: z.string(),
+    durationSeconds: z.number().finite().optional(),
+    idempotencyKey: z.string().optional(),
+});
+/** Talk and the game report a full snapshot of every active room they hold. */
+export const presenceReportSchema = z.object({
+    channel: z.enum(["game", "voice", "text"]),
+    rooms: z.array(z.object({
+        roomId: z.string(),
+        occupants: z.array(z.looseObject({ sub: z.string() })),
+    })),
+});
+const POSITION_VALUE_LIMIT = 1_000_000;
+const WORLD_ID_MAX_LENGTH = 64;
+const positionValue = z
+    .number()
+    .min(-POSITION_VALUE_LIMIT)
+    .max(POSITION_VALUE_LIMIT);
+/** The game server checkpoints each tracked player's last grounded footing. */
+export const positionReportSchema = z.object({
+    positions: z.array(z.object({
+        roomId: z.string(),
+        sub: z.string(),
+        x: positionValue,
+        y: positionValue,
+        z: positionValue,
+        yaw: positionValue,
+        worldId: z.string().max(WORLD_ID_MAX_LENGTH),
+    })),
+});
+export const actionStartSchema = z.object({
+    sub: z.string(),
+    sessionId: z.string(),
+    source: z.string(),
+    showTimer: z.boolean().optional(),
+});
+export const actionFinishSchema = z.object({
+    sessionId: z.string(),
+});
+export const actionEventSchema = z.object({
+    sessionId: z.string(),
+    kind: z.enum(["pause", "resume", "focus_lost", "focus_gained"]),
+});
+export const stateTimeSchema = z.object({
+    sub: z.string(),
+    day: z.string(),
+    states: z.record(z.string(), z.number()),
+});
+export const xpDevSchema = z.object({
+    sub: z.string(),
+    op: z.enum(["add", "set_total", "set_level"]),
+    value: z.number().finite(),
+});
+export const reportSchemas = {
+    xpEvent: xpEventSchema,
+    presenceReport: presenceReportSchema,
+    positionReport: positionReportSchema,
+    actionStart: actionStartSchema,
+    actionEvent: actionEventSchema,
+    actionFinish: actionFinishSchema,
+    stateTime: stateTimeSchema,
+    xpDev: xpDevSchema,
+};

package/dist/sdk/dialog/remote/Messenger.d.ts

@@ -12,6 +12,9 @@ export declare function from(messenger: Messenger): Messenger;
  * isolation that prevents arbitrary pages from injecting messages.
  */
 export declare function fromWindow(w: Window, options?: FromWindowOptions): Messenger;
+export declare class BridgeDestroyedError extends Error {
+    constructor();
+}
 /**
  * Combines two Messengers into a bidirectional bridge: `from` is read-side
  * (inbound messages), `to` is write-side (outbound). Adds a "ready"

package/dist/sdk/dialog/remote/Messenger.js

@@ -87,6 +87,12 @@ export function fromWindow(w, options = {}) {
         },
     });
 }
+export class BridgeDestroyedError extends Error {
+    constructor() {
+        super("Message bridge destroyed before the peer was ready");
+        this.name = "BridgeDestroyedError";
+    }
+}
 /**
  * Combines two Messengers into a bidirectional bridge: `from` is read-side
  * (inbound messages), `to` is write-side (outbound). Adds a "ready"
@@ -109,19 +115,19 @@ export function bridge(parameters) {
             from_.destroy();
             to.destroy();
             if (pending)
-                rejectReady();
+                rejectReady(new BridgeDestroyedError());
         },
         on(topic, listener, id) {
             return from_.on(topic, listener, id);
         },
         async send(topic, payload, targetOrigin) {
-            pending = true;
+            pending = waitForReady;
             if (waitForReady)
                 await readyPromise.finally(() => (pending = false));
             return to.send(topic, payload, targetOrigin);
         },
         async sendAsync(topic, payload, targetOrigin) {
-            pending = true;
+            pending = waitForReady;
             if (waitForReady)
                 await readyPromise.finally(() => (pending = false));
             return to.sendAsync(topic, payload, targetOrigin);

package/dist/sdk/react/use-cooldown.d.ts

@@ -0,0 +1 @@
+export declare function useCooldown(initial: number): [number, (next: number) => void];

package/dist/sdk/react/use-cooldown.js

@@ -0,0 +1,12 @@
+import { useEffect, useState } from "react";
+export function useCooldown(initial) {
+    const [cooldown, setCooldown] = useState(initial);
+    const cooldownActive = cooldown > 0;
+    useEffect(() => {
+        if (!cooldownActive)
+            return;
+        const timer = setInterval(() => setCooldown((c) => (c <= 1 ? 0 : c - 1)), 1000);
+        return () => clearInterval(timer);
+    }, [cooldownActive]);
+    return [cooldown, setCooldown];
+}

package/dist/sdk/types/auth.d.ts

@@ -160,3 +160,15 @@ export type VerifiedFlowJWT = JWTPayload & {
      */
     guest?: boolean;
 };
+export type PasskeyEnrollment = {
+    userId: string;
+    username: string;
+    credential: FlowCredential;
+};
+export type AccountRegistration = {
+    username: string;
+    email: string;
+    subscribedToNews: boolean;
+    walletAddress: string | null;
+    credential: FlowCredential | null;
+};

package/dist/sdk/types/dialog.d.ts

@@ -1,3 +1,4 @@
+import type { RpcRequest } from "./protocol";
 /**
  * Async view state for a dialog panel — the three states every fetched
  * section renders (spinner / retry row / content), so "empty" stays
@@ -89,3 +90,27 @@ export type DialogState = {
     customFeatures?: DialogCustomFeatures;
     customLabels?: DialogCustomLabels;
 };
+export type SignUpProps = {
+    request: RpcRequest;
+    rpId: string;
+    accessKeyHash?: string | undefined;
+    guestToken?: string | undefined;
+    onHome: () => void;
+    onSignIn: () => void;
+};
+export type SignInWithEmailProps = {
+    request: RpcRequest;
+    onBack: () => void;
+    onHome: () => void;
+};
+/** Cookie-authoritative identity for account data operations. */
+export type AccountDataIdentity = {
+    id: string;
+    username: string;
+    isGuest: boolean;
+};
+/** Validated export file and any collections capped by the server. */
+export type AccountDataDownload = {
+    blob: Blob;
+    truncated: string[];
+};