@pylonsync/sync 0.8.3 → 0.9.1

package/dist/index.d.ts

@@ -401,6 +401,13 @@ export declare class SyncEngine {
     onBinaryFrame(handler: (bytes: Uint8Array) => void): () => void;
     /** Read the cached resolved session. Null user = anonymous. */
     resolvedSession(): ResolvedSession;
+    /**
+     * Whether `/api/auth/me` has answered during this run. Before that,
+     * `resolvedSession()` returns the empty placeholder, which readers must
+     * not mistake for a signed-out user. Notified through the same store
+     * channel as the session itself.
+     */
+    sessionResolved(): boolean;
     /**
      * Coarse connection state (see `SyncConnectionStatus`). Updated as
      * the WS opens/closes and reconnect attempts run; subscribers re-

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.8.3",
+  "version": "0.9.1",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./dist/index.d.ts",

package/src/index.ts

@@ -547,6 +547,16 @@ export class SyncEngine {
     return this.session.resolved();
   }
 
+  /**
+   * Whether `/api/auth/me` has answered during this run. Before that,
+   * `resolvedSession()` returns the empty placeholder, which readers must
+   * not mistake for a signed-out user. Notified through the same store
+   * channel as the session itself.
+   */
+  sessionResolved(): boolean {
+    return this.session.hasObserved();
+  }
+
   /**
    * Coarse connection state (see `SyncConnectionStatus`). Updated as
    * the WS opens/closes and reconnect attempts run; subscribers re-
@@ -2498,8 +2508,11 @@ export class SyncEngine {
           }
         }
       }
+      const firstResolution = !this.session.hasObserved();
       this.session.commitObservation(next);
-      if (verdict.identityChanged) {
+      if (verdict.identityChanged || firstResolution) {
+        // The first answer flips `sessionResolved()` even when the
+        // session itself matches the placeholder (anonymous caller).
         this.store.notify();
       }
       if (broadcast && this.isMultiTabLeader) {

package/src/session-resolved.test.ts

@@ -0,0 +1,41 @@
+// `sessionResolved()` tells readers whether `/api/auth/me` has answered.
+// Before it does, `resolvedSession()` is the empty placeholder — a route
+// guard that reads `userId == null` as "signed out" sends a returning
+// user to the sign-in screen on every cold launch. The flag flips on the
+// first answer, anonymous or not, and notifies store subscribers.
+
+import { afterEach, expect, test } from "bun:test";
+import { createTestEnv, type TestEnv } from "./test-harness";
+
+let env: TestEnv | null = null;
+
+afterEach(async () => {
+  if (env) {
+    await env.dispose();
+    env = null;
+  }
+});
+
+test("unresolved before start; resolved after /api/auth/me answers anonymous", async () => {
+  env = await createTestEnv({ transport: "poll" });
+  const { engine } = env;
+  expect(engine.sessionResolved()).toBe(false);
+  let notified = 0;
+  engine.store.subscribe(() => {
+    notified++;
+  });
+  await engine.start();
+  expect(engine.sessionResolved()).toBe(true);
+  expect(engine.resolvedSession().userId).toBeNull();
+  // The placeholder and the anonymous answer are identical, so only the
+  // resolved flag changed — subscribers must still hear about it.
+  expect(notified).toBeGreaterThan(0);
+});
+
+test("resolved with the signed-in identity", async () => {
+  env = await createTestEnv({ transport: "poll" });
+  env.signIn({ userId: "u1" });
+  await env.engine.start();
+  expect(env.engine.sessionResolved()).toBe(true);
+  expect(env.engine.resolvedSession().userId).toBe("u1");
+});

package/src/session-resolver.ts

@@ -104,6 +104,7 @@ export class SessionResolver {
   commitObservation(next: ResolvedSession): void {
     this.lastSeenTenant = next.tenantId;
     this._resolved = next;
+    this._observed = true;
   }
 
   /** Convenience for tests / migration: inspect + commit in one call.
@@ -112,7 +113,6 @@ export class SessionResolver {
   observeSession(next: ResolvedSession): SessionTransition {
     const verdict = this.inspectSession(next);
     this.commitObservation(next);
-    this._observed = true;
     return verdict;
   }