castle-web-sdk 0.4.4 → 0.4.6

package/dist/storage.js

@@ -1,22 +1,22 @@
-import { getAuth, requireAuthToken } from "./auth";
-import { getDeckContext, requireDeckId } from "./context";
 import { CastleError } from "./errors";
-import { graphqlRequest } from "./graphql";
+import { hostRequest } from "./transport";
 const FLUSH_INTERVAL_MS = 2000;
+// Per-player private storage. The host stamps deckId/sessionId, so one deck
+// session = one stable blob: load once, then serve reads from cache and batch
+// writes on a 2s flush. Dirty writes overlay the server blob so an in-flight
+// write isn't clobbered by the flush response.
 class PrivateStorageImpl {
     cache = new Map();
     dirty = new Map();
     loadPromise = null;
-    loadedContextKey = null;
     flushTimer = null;
     async get(key) {
-        await this.ensureLoaded("Storage.get");
+        await this.ensureLoaded();
         return (this.cache.get(key) ?? null);
     }
     set(key, value) {
-        const encoded = encodeStorageValue(value, "Storage.set");
         this.cache.set(key, value);
-        this.dirty.set(key, encoded);
+        this.dirty.set(key, encodeStorageValue(value, "Storage.set"));
         this.scheduleFlush();
     }
     remove(key) {
@@ -24,51 +24,37 @@ class PrivateStorageImpl {
         this.dirty.set(key, null);
         this.scheduleFlush();
     }
-    async flush() {
-        if (this.dirty.size === 0)
-            return;
-        const context = await currentContext("Storage.flush");
-        const snapshot = new Map(this.dirty);
-        const data = await storageGraphql(UPDATE_DECK_STORAGE_MUTATION, {
-            deckId: context.deckId,
-            sessionId: context.sessionId,
-            updates: updatesFromDirty(snapshot),
-        }, "updateDeckStorage");
-        this.applyServerBlob(data.updateDeckStorage, contextKey(context.deckId, context.sessionId));
-        clearAcknowledgedDirty(this.dirty, snapshot);
-        this.overlayDirty();
-    }
-    ensureLoaded(operation) {
+    ensureLoaded() {
         if (!this.loadPromise) {
-            this.loadPromise = this.load(operation).catch((error) => {
+            this.loadPromise = this.load().catch((error) => {
                 this.loadPromise = null;
                 throw error;
             });
         }
         return this.loadPromise;
     }
-    async load(operation) {
-        const context = await currentContext(operation);
-        const key = contextKey(context.deckId, context.sessionId);
-        if (this.loadedContextKey === key)
-            return;
-        const data = await storageGraphql(DECK_STORAGE_QUERY, { deckId: context.deckId, sessionId: context.sessionId }, "deckStorage");
-        this.cache = decodeStorageBlob(data.deckStorage, operation);
-        this.loadedContextKey = key;
+    async load() {
+        const { blob } = await hostRequest("deckStorage.load", {});
+        this.cache = decodeStorageBlob(blob, "Storage.get");
         this.overlayDirty();
     }
-    applyServerBlob(blob, loadedContextKey) {
+    async flush() {
+        if (this.dirty.size === 0)
+            return;
+        const snapshot = new Map(this.dirty);
+        const { blob } = await hostRequest("deckStorage.update", {
+            updates: updatesFromDirty(snapshot),
+        });
         this.cache = decodeStorageBlob(blob, "Storage.flush");
-        this.loadedContextKey = loadedContextKey;
+        clearAcknowledgedDirty(this.dirty, snapshot);
+        this.overlayDirty();
     }
     overlayDirty() {
         for (const [key, encoded] of this.dirty) {
-            if (encoded === null) {
+            if (encoded === null)
                 this.cache.delete(key);
-            }
-            else {
+            else
                 this.cache.set(key, decodeStorageValue(encoded, "Storage.dirty"));
-            }
         }
     }
     scheduleFlush() {
@@ -80,71 +66,50 @@ class PrivateStorageImpl {
         }, FLUSH_INTERVAL_MS);
     }
 }
+// Cross-player storage. Writes always target the current player (the host
+// forces 'user'-scope writes to whoever is signed in), so dirty writes bucket
+// under a fixed key; reads of another player's 'user' bucket take an explicit
+// userId and never have pending writes. Reads coalesce per microtask into one
+// command with a keys[] array.
 class SharedStorageImpl {
     dirtyBuckets = new Map();
-    buckets = new Map();
     readBatches = new Map();
-    pendingWrites = new Set();
-    pendingWriteErrors = [];
     flushTimer = null;
     async get(scope, userOrKey, maybeKey) {
-        const bucket = await readBucket(scope, userOrKey, maybeKey, "SharedStorage.get");
+        assertScope(scope, "SharedStorage.get");
+        const userId = scope === "user" && maybeKey ? userOrKey : undefined;
         const key = maybeKey ?? userOrKey;
-        await this.awaitPendingWrites("SharedStorage.get");
-        const dirty = this.peekDirty(bucket, key);
+        const dirty = this.peekDirty(scope, userId, key);
         if (dirty !== undefined) {
             return (dirty === null ? null : decodeStorageValue(dirty, "SharedStorage.get"));
         }
-        return this.queueRead(bucket, key);
+        return this.queueRead(scope, userId, key);
     }
     set(scope, key, value) {
-        this.enqueueWrite(scope, key, encodeStorageValue(value, "SharedStorage.set"), "SharedStorage.set");
+        assertScope(scope, "SharedStorage.set");
+        this.write(scope, key, encodeStorageValue(value, "SharedStorage.set"));
     }
     remove(scope, key) {
-        this.enqueueWrite(scope, key, null, "SharedStorage.remove");
-    }
-    async flush() {
-        await this.awaitPendingWrites("SharedStorage.flush");
-        if (this.dirtyBuckets.size === 0)
-            return;
-        const tasks = Array.from(this.dirtyBuckets, ([bucketKey, dirty]) => this.flushBucket(bucketKey, new Map(dirty)));
-        await Promise.all(tasks);
+        assertScope(scope, "SharedStorage.remove");
+        this.write(scope, key, null);
     }
-    async write(scope, key, encoded, operation) {
-        const bucket = await writeBucket(scope, operation);
-        const bucketKey = makeBucketKey(bucket);
-        this.buckets.set(bucketKey, bucket);
+    write(scope, key, encoded) {
+        const bucketKey = writeBucketKey(scope);
         const dirty = this.dirtyBuckets.get(bucketKey) ?? new Map();
         dirty.set(key, encoded);
         this.dirtyBuckets.set(bucketKey, dirty);
         this.scheduleFlush();
     }
-    enqueueWrite(scope, key, encoded, operation) {
-        const pending = this.write(scope, key, encoded, operation)
-            .catch((error) => {
-            this.pendingWriteErrors.push(error);
-        })
-            .finally(() => {
-            this.pendingWrites.delete(pending);
-        });
-        this.pendingWrites.add(pending);
+    peekDirty(scope, userId, key) {
+        if (scope === "user" && userId)
+            return undefined;
+        return this.dirtyBuckets.get(writeBucketKey(scope))?.get(key);
     }
-    async awaitPendingWrites(operation) {
-        if (this.pendingWrites.size > 0) {
-            await Promise.all(this.pendingWrites);
-        }
-        const error = this.pendingWriteErrors.shift();
-        if (error instanceof Error)
-            throw error;
-        if (error) {
-            throw storageError("CASTLE_STORAGE_WRITE_FAILED", "Queued shared storage write failed.", operation);
-        }
-    }
-    async queueRead(bucket, key) {
-        const bucketKey = makeBucketKey(bucket);
+    queueRead(scope, userId, key) {
+        const bucketKey = readBucketKey(scope, userId);
         let batch = this.readBatches.get(bucketKey);
         if (!batch) {
-            batch = { bucket, reads: new Map(), scheduled: false };
+            batch = { bucketKey, scope, userId, reads: new Map(), scheduled: false };
             this.readBatches.set(bucketKey, batch);
         }
         const reads = batch.reads.get(key) ?? [];
@@ -154,11 +119,9 @@ class SharedStorageImpl {
         });
         if (!batch.scheduled) {
             batch.scheduled = true;
-            queueMicrotask(() => {
-                void this.flushReadBatch(bucketKey);
-            });
+            queueMicrotask(() => void this.flushReadBatch(bucketKey));
         }
-        return (await promise);
+        return promise;
     }
     async flushReadBatch(bucketKey) {
         const batch = this.readBatches.get(bucketKey);
@@ -167,9 +130,12 @@ class SharedStorageImpl {
         this.readBatches.delete(bucketKey);
         const keys = Array.from(batch.reads.keys());
         try {
-            const context = await currentContext("SharedStorage.get");
-            const data = await storageGraphql(SHARED_DECK_STORAGE_QUERY, sharedVariables(context.deckId, batch.bucket, { keys }), "sharedDeckStorage");
-            this.resolveReadBatch(batch, data.sharedDeckStorage);
+            const { blob } = await hostRequest("sharedDeckStorage.load", {
+                scope: batch.scope,
+                userId: batch.userId ?? null,
+                keys,
+            });
+            this.resolveReadBatch(batch, blob);
         }
         catch (error) {
             rejectReadBatch(batch, error);
@@ -177,7 +143,7 @@ class SharedStorageImpl {
     }
     resolveReadBatch(batch, blob) {
         for (const [key, reads] of batch.reads) {
-            const encoded = this.peekDirty(batch.bucket, key) ?? blob[key] ?? null;
+            const encoded = this.peekDirty(batch.scope, batch.userId, key) ?? blob[key] ?? null;
             const value = encoded === null
                 ? null
                 : decodeStorageValue(encoded, "SharedStorage.get");
@@ -185,16 +151,19 @@ class SharedStorageImpl {
                 read.resolve(value);
         }
     }
+    async flush() {
+        if (this.dirtyBuckets.size === 0)
+            return;
+        const tasks = Array.from(this.dirtyBuckets, ([bucketKey, dirty]) => this.flushBucket(bucketKey, new Map(dirty)));
+        await Promise.all(tasks);
+    }
     async flushBucket(bucketKey, snapshot) {
         if (snapshot.size === 0)
             return;
-        const bucket = this.buckets.get(bucketKey);
-        if (!bucket)
-            return;
-        const context = await currentContext("SharedStorage.flush");
-        await storageGraphql(UPDATE_SHARED_DECK_STORAGE_MUTATION, sharedVariables(context.deckId, bucket, {
+        await hostRequest("sharedDeckStorage.update", {
+            scope: scopeFromWriteKey(bucketKey),
             updates: updatesFromDirty(snapshot),
-        }), "updateSharedDeckStorage");
+        });
         const dirty = this.dirtyBuckets.get(bucketKey);
         if (!dirty)
             return;
@@ -202,112 +171,29 @@ class SharedStorageImpl {
         if (dirty.size === 0)
             this.dirtyBuckets.delete(bucketKey);
     }
-    peekDirty(bucket, key) {
-        return this.dirtyBuckets.get(makeBucketKey(bucket))?.get(key);
-    }
     scheduleFlush() {
         if (this.flushTimer)
             return;
         this.flushTimer = setTimeout(() => {
             this.flushTimer = null;
-            void this.flush();
+            void this.flush().catch(reportSharedStorageError);
         }, FLUSH_INTERVAL_MS);
     }
 }
 export const Storage = new PrivateStorageImpl();
 export const SharedStorage = new SharedStorageImpl();
-const DECK_STORAGE_QUERY = `
-  query CastleDeckStorage($deckId: ID!, $sessionId: ID) {
-    deckStorage(deckId: $deckId, sessionId: $sessionId)
-  }
-`;
-const UPDATE_DECK_STORAGE_MUTATION = `
-  mutation CastleUpdateDeckStorage(
-    $deckId: ID!,
-    $updates: [DeckStorageUpdateInput!]!,
-    $sessionId: ID
-  ) {
-    updateDeckStorage(deckId: $deckId, updates: $updates, sessionId: $sessionId)
-  }
-`;
-const SHARED_DECK_STORAGE_QUERY = `
-  query CastleSharedDeckStorage(
-    $deckId: ID!,
-    $keys: [String!]!,
-    $sessionId: ID,
-    $userId: ID
-  ) {
-    sharedDeckStorage(deckId: $deckId, keys: $keys, sessionId: $sessionId, userId: $userId)
-  }
-`;
-const UPDATE_SHARED_DECK_STORAGE_MUTATION = `
-  mutation CastleUpdateSharedDeckStorage(
-    $deckId: ID!,
-    $updates: [SharedDeckStorageUpdateInput!]!,
-    $sessionId: ID,
-    $userId: ID
-  ) {
-    updateSharedDeckStorage(
-      deckId: $deckId,
-      updates: $updates,
-      sessionId: $sessionId,
-      userId: $userId
-    )
-  }
-`;
-async function currentContext(operation) {
-    const deckId = await storageDeckId(operation);
-    const context = await getDeckContext();
-    return { deckId, sessionId: context.sessionId ?? undefined };
-}
-async function storageDeckId(operation) {
-    try {
-        return await requireDeckId(operation);
-    }
-    catch (error) {
-        if (error instanceof CastleError && error.code === "MISSING_DECK_ID") {
-            throw storageError("CASTLE_STORAGE_MISSING_DECK_ID", "Save this deck before using Castle storage.", operation);
-        }
-        throw error;
-    }
+// 'user'-scope writes/self-reads share one bucket (the host resolves the
+// current player); a 'user' read of someone else keys by their id.
+function writeBucketKey(scope) {
+    return scope === "deck" ? "deck" : "user:self";
 }
-async function storageGraphql(query, variables, operation) {
-    const token = await requireAuthToken(operation);
-    return graphqlRequest(query, variables, {
-        operation,
-        requireAuth: true,
-        token,
-    });
-}
-async function readBucket(scope, userOrKey, maybeKey, operation) {
-    assertScope(scope, operation);
-    if (scope === "deck")
-        return withSession({ scope });
-    if (maybeKey)
-        return withSession({ scope, userId: userOrKey });
-    return writeBucket(scope, operation);
-}
-async function writeBucket(scope, operation) {
-    assertScope(scope, operation);
+function readBucketKey(scope, userId) {
     if (scope === "deck")
-        return withSession({ scope });
-    const auth = await getAuth();
-    if (!auth.userId) {
-        throw storageError("CASTLE_STORAGE_MISSING_USER_ID", "Castle user id is required for user-scoped shared storage.", operation);
-    }
-    return withSession({ scope, userId: auth.userId });
+        return "deck";
+    return userId ? `user:other:${userId}` : "user:self";
 }
-async function withSession(bucket) {
-    const context = await getDeckContext();
-    return { ...bucket, sessionId: context.sessionId ?? undefined };
-}
-function sharedVariables(deckId, bucket, extra) {
-    return {
-        deckId,
-        sessionId: bucket.sessionId,
-        userId: bucket.userId,
-        ...extra,
-    };
+function scopeFromWriteKey(bucketKey) {
+    return bucketKey === "deck" ? "deck" : "user";
 }
 function updatesFromDirty(dirty) {
     return Array.from(dirty, ([key, value]) => ({ key, value }));
@@ -362,18 +248,14 @@ function assertJsonValue(value, seen, operation) {
     throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values must be JSON.", operation);
 }
 function assertJsonArray(values, seen, operation) {
-    if (seen.has(values)) {
-        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values cannot be cyclic.", operation);
-    }
+    assertNotCyclic(values, seen, operation);
     seen.add(values);
     for (const value of values)
         assertJsonValue(value, seen, operation);
     seen.delete(values);
 }
 function assertJsonObject(value, seen, operation) {
-    if (seen.has(value)) {
-        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values cannot be cyclic.", operation);
-    }
+    assertNotCyclic(value, seen, operation);
     const prototype = Object.getPrototypeOf(value);
     if (prototype !== Object.prototype && prototype !== null) {
         throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage objects must be plain JSON.", operation);
@@ -383,11 +265,10 @@ function assertJsonObject(value, seen, operation) {
         assertJsonValue(child, seen, operation);
     seen.delete(value);
 }
-function makeBucketKey(bucket) {
-    return `${bucket.scope}:${bucket.userId ?? ""}:${bucket.sessionId ?? ""}`;
-}
-function contextKey(deckId, sessionId) {
-    return `${deckId}:${sessionId ?? ""}`;
+function assertNotCyclic(value, seen, operation) {
+    if (seen.has(value)) {
+        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values cannot be cyclic.", operation);
+    }
 }
 function assertScope(scope, operation) {
     if (scope !== "deck" && scope !== "user") {
@@ -400,6 +281,9 @@ function rejectReadBatch(batch, error) {
             read.reject(error);
     }
 }
+function reportSharedStorageError(error) {
+    console.warn("Castle shared storage write failed", error);
+}
 function storageError(code, message, operation) {
     return new CastleError({ code, message, operation });
 }

package/dist/time.js

@@ -1,14 +1,5 @@
 import { CastleError } from "./errors";
-import { graphqlRequest } from "./graphql";
-const SERVER_TIME_QUERY = `
-  query CastleServerTime {
-    serverTime {
-      timestamp
-      timezoneOffset
-      castleEpochData
-    }
-  }
-`;
+import { hostRequest } from "./transport";
 let serverTimeSnapshot = null;
 let serverTimePromise = null;
 export const Time = {
@@ -38,12 +29,10 @@ async function syncServerTime() {
 }
 async function fetchServerTime() {
     const operation = "Time.getServerTime";
-    const data = await graphqlRequest(SERVER_TIME_QUERY, undefined, {
-        operation,
-    });
-    const timestamp = numberField(data.serverTime.timestamp, "serverTime.timestamp", operation);
-    const timezoneOffset = numberField(data.serverTime.timezoneOffset, "serverTime.timezoneOffset", operation);
-    const epochData = jsonObject(data.serverTime.castleEpochData, "serverTime.castleEpochData", operation);
+    const data = await hostRequest("time.getServerTime", {});
+    const timestamp = numberField(data.timestamp, "serverTime.timestamp", operation);
+    const timezoneOffset = numberField(data.timezoneOffset, "serverTime.timezoneOffset", operation);
+    const epochData = jsonObject(data.castleEpochData, "serverTime.castleEpochData", operation);
     return {
         offsetSeconds: snappedOffset(timestamp - clientUnixSeconds()),
         castleTimezoneOffsetMinutes: timezoneOffset,

package/dist/transport.d.ts

@@ -0,0 +1,16 @@
+import { type CommandName, type CommandParams, type CommandResult } from "./commands";
+type PostChannel = "mobile" | "web";
+interface ReactNativeWebViewBridge {
+    postMessage: (message: string) => void;
+}
+declare global {
+    interface Window {
+        ReactNativeWebView?: ReactNativeWebViewBridge;
+        __castleSdkHost?: {
+            receive: (message: unknown) => void;
+        };
+    }
+}
+export declare function hostRequest<C extends CommandName>(command: C, params: CommandParams[C]): Promise<CommandResult[C]>;
+export declare function getCommandChannel(): PostChannel | "local";
+export {};

package/dist/transport.js

@@ -0,0 +1,126 @@
+// Deck-side command-poster. The SDK never makes API calls or holds the auth
+// token; every privileged operation becomes a `command` posted to the outer
+// runtime (host), which validates it, stamps trusted context, runs the call
+// with its own auth, and replies. Three host channels:
+//   - mobile  → window.ReactNativeWebView.postMessage; host pushes responses
+//               back by calling window.__castleSdkHost.receive(...)
+//   - web     → window.parent.postMessage; responses via 'message' events
+//   - local   → the castle-web serve dev server, over runtime.ts's websocket
+// Error reconstruction is uniform here so callers always get a CastleError.
+import { CASTLE_SDK_PROTOCOL, isResponseEnvelope, } from "./commands";
+import { getCastleEmbed } from "./context";
+import { CastleError } from "./errors";
+import { sendLocalCommand } from "./runtime";
+const REQUEST_TIMEOUT_MS = 15000;
+// Interactive platform commands hold the screen while the player interacts with
+// a host-native sheet (e.g. a pass purchase), so the flat data-command timeout
+// is wrong for them: they get NO timeout and resolve only when the host replies.
+const INTERACTIVE_COMMANDS = new Set([
+    "pass.offer",
+]);
+let nextRequestId = 1;
+const pending = new Map();
+let listenersInstalled = false;
+export async function hostRequest(command, params) {
+    try {
+        const channel = resolveChannel();
+        const env = channel === "local"
+            ? await sendLocalCommand(command, params)
+            : await postCommand(channel, command, params);
+        return interpretResponse(command, env);
+    }
+    catch (error) {
+        // Honor the SDK contract that every thrown error is a CastleError. Errors
+        // surfaced by the host (interpretResponse) are already CastleErrors; this
+        // wraps transport-level failures (host timeout / unreachable / dev server
+        // disconnected) that would otherwise be plain Errors.
+        if (error instanceof CastleError)
+            throw error;
+        throw new CastleError({
+            code: "CASTLE_HOST_UNAVAILABLE",
+            message: error instanceof Error
+                ? error.message
+                : `Castle host did not handle ${command}.`,
+            operation: command,
+        });
+    }
+}
+// Exposed so capability modules (e.g. passes) can tell whether the current host
+// has its own UI surface over the deck. "mobile"/"web" hosts render their own
+// purchase/upsell UI; the "local" dev server has none, so the SDK itself shows
+// a minimal in-page notice there.
+export function getCommandChannel() {
+    return resolveChannel();
+}
+function resolveChannel() {
+    if (typeof window === "undefined")
+        return "local";
+    if (window.ReactNativeWebView)
+        return "mobile";
+    const host = getCastleEmbed()?.host;
+    if (host === "web")
+        return "web";
+    if (host === "dev")
+        return "local";
+    // Fallback: an iframe with a parent is the web player; otherwise assume the
+    // local dev server (top-level page served by `castle-web serve`).
+    return window.parent && window.parent !== window ? "web" : "local";
+}
+function postCommand(channel, command, params) {
+    installResponseListener();
+    const requestId = `csdk_${nextRequestId++}`;
+    return new Promise((resolve, reject) => {
+        const timeout = INTERACTIVE_COMMANDS.has(command)
+            ? undefined
+            : setTimeout(() => {
+                pending.delete(requestId);
+                reject(new Error(`Castle host did not respond to ${command}.`));
+            }, REQUEST_TIMEOUT_MS);
+        pending.set(requestId, { resolve, reject, timeout });
+        sendEnvelope(channel, { castleSdk: CASTLE_SDK_PROTOCOL, requestId, command, params });
+    });
+}
+function sendEnvelope(channel, envelope) {
+    const json = JSON.stringify(envelope);
+    if (channel === "mobile") {
+        window.ReactNativeWebView?.postMessage(json);
+    }
+    else {
+        window.parent.postMessage(envelope, "*");
+    }
+}
+// The mobile host can't dispatch a DOM 'message' event, so it calls this global
+// directly with the parsed envelope. The web host posts a 'message' event.
+function installResponseListener() {
+    if (listenersInstalled || typeof window === "undefined")
+        return;
+    listenersInstalled = true;
+    window.__castleSdkHost = { receive: (message) => settle(message) };
+    window.addEventListener("message", (event) => {
+        settle(event.data);
+    });
+}
+function settle(message) {
+    if (!isResponseEnvelope(message))
+        return;
+    const entry = pending.get(message.requestId);
+    if (!entry)
+        return;
+    if (entry.timeout)
+        clearTimeout(entry.timeout);
+    pending.delete(message.requestId);
+    entry.resolve(message);
+}
+function interpretResponse(command, env) {
+    if (env.ok)
+        return env.data;
+    throw fromSerializedError(env.error, command);
+}
+function fromSerializedError(error, command) {
+    return new CastleError({
+        code: error?.code ?? "CASTLE_HOST_ERROR",
+        message: error?.message ?? `Castle command ${command} failed.`,
+        operation: error?.command ?? command,
+        extensions: error?.extensions,
+    });
+}

package/dist/user.js

@@ -1,14 +1,5 @@
-import { requireAuthToken } from "./auth";
 import { CastleError } from "./errors";
-import { graphqlRequest } from "./graphql";
-const CURRENT_USER_QUERY = `
-  query CastleCurrentUser {
-    me {
-      userId
-      username
-    }
-  }
-`;
+import { hostRequest } from "./transport";
 let currentUser = null;
 let currentUserPromise = null;
 export const User = {
@@ -25,25 +16,17 @@ async function getCurrent() {
 }
 async function fetchCurrentUser() {
     const operation = "User.getCurrent";
-    const token = await requireAuthToken(operation);
-    const data = await graphqlRequest(CURRENT_USER_QUERY, undefined, {
-        operation,
-        requireAuth: true,
-        token,
-    });
-    if (!data.me) {
+    const { user } = await hostRequest("user.getCurrent", {});
+    if (!user) {
         throw new CastleError({
             code: "LOGIN_REQUIRED",
             message: "Log in to Castle before using User.getCurrent().",
             operation,
         });
     }
-    return normalizeCurrentUser(data.me, operation);
-}
-function normalizeCurrentUser(user, operation) {
     return {
-        userId: requiredString(user.userId, "me.userId", operation),
-        username: requiredString(user.username, "me.username", operation),
+        userId: requiredString(user.userId, "user.userId", operation),
+        username: requiredString(user.username, "user.username", operation),
         isActive: true,
     };
 }
@@ -52,7 +35,7 @@ function requiredString(value, field, operation) {
         return value;
     throw new CastleError({
         code: "GRAPHQL_BAD_DATA",
-        message: `Castle GraphQL response did not include ${field}.`,
+        message: `Castle response did not include ${field}.`,
         operation,
     });
 }