@spooky-sync/core 0.0.1-canary.17 → 0.0.1-canary.170

package/package.json

@@ -1,24 +1,29 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.17",
+  "version": "0.0.1-canary.170",
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./otel": {
+      "types": "./dist/otel/index.d.ts",
+      "import": "./dist/otel/index.js"
     }
   },
   "scripts": {
     "dev": "tsdown --watch",
     "dev:example": "pnpm dev",
-    "build": "tsdown",
+    "build": "tsdown && node scripts/check-broker-bundle.mjs",
     "test": "vitest"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/mono424/spooky.git",
+    "url": "https://github.com/mono424/sp00ky.git",
     "directory": "packages/core"
   },
   "keywords": [
@@ -55,12 +60,14 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "workspace:*",
-    "@spooky-sync/ssp-wasm": "workspace:*",
-    "@surrealdb/wasm": "^3.0.0",
+    "@spooky-sync/query-builder": "0.0.1-canary.170",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.170",
+    "@sqlite.org/sqlite-wasm": "3.53.0-build1",
+    "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",
+    "loro-crdt": "^1.5.6",
     "pino": "^10.1.0",
-    "surrealdb": "2.0.0"
+    "surrealdb": "2.0.3"
   },
   "devDependencies": {
     "@types/node": "^22.5.2",

package/scripts/check-broker-bundle.mjs

@@ -0,0 +1,33 @@
+// Build gate: dist/tabs-broker-worker.js must be self-contained ESM.
+// Bundlers cannot trace `new SharedWorker(url)` module graphs, so any
+// import statement surviving into the emitted broker file would 404 at
+// runtime in consumers (the file is fetched as a bare URL, its relative
+// chunk siblings are not copied along). Run after `tsdown` in the build.
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const dist = resolve(dirname(fileURLToPath(import.meta.url)), '../dist/tabs-broker-worker.js');
+
+let code;
+try {
+  code = readFileSync(dist, 'utf8');
+} catch {
+  console.error(`check-broker-bundle: ${dist} missing; did tsdown run?`);
+  process.exit(1);
+}
+
+const problems = [];
+// Static or dynamic imports of sibling chunks.
+const importRe = /(?:^|\n)\s*import[\s(]/;
+if (importRe.test(code)) problems.push('contains an import statement');
+if (!code.includes('onconnect')) problems.push('missing onconnect handler');
+
+if (problems.length > 0) {
+  console.error(`check-broker-bundle: dist/tabs-broker-worker.js ${problems.join('; ')}.`);
+  console.error(
+    'The broker worker must stay free of runtime imports (type-only imports are fine in source).'
+  );
+  process.exit(1);
+}
+console.log('check-broker-bundle: ok');

package/skills/{spooky-core → sp00ky-core}/SKILL.md

@@ -1,27 +1,27 @@
 ---
-name: spooky-core
+name: sp00ky-core
 description: >-
-  Core client for the Spooky reactive local-first SurrealDB framework. Use when
-  initializing SpookyClient, registering queries and subscriptions, performing
+  Core client for the Sp00ky reactive local-first SurrealDB framework. Use when
+  initializing Sp00kyClient, registering queries and subscriptions, performing
   mutations (create/update/delete), handling auth (signUp/signIn/signOut),
   working with file buckets, or using backend runs (HTTP outbox pattern).
 metadata:
-  author: spooky-sync
+  author: sp00ky-sync
   version: "0.0.1"
 ---
 
-# Spooky Core
+# Sp00ky Core
 
-`@spooky-sync/core` provides `SpookyClient`, the main entry point for the Spooky framework. It handles local-first data sync with SurrealDB, reactive queries, optimistic mutations, authentication, file storage, and backend runs.
+`@spooky-sync/core` provides `Sp00kyClient`, the main entry point for the Sp00ky framework. It handles local-first data sync with SurrealDB, reactive queries, optimistic mutations, authentication, file storage, and backend runs.
 
 ## Initialization
 
 ```typescript
-import { SpookyClient } from '@spooky-sync/core';
+import { Sp00kyClient } from '@spooky-sync/core';
 import { schema } from './generated/schema'; // Generated by `spooky generate`
 import schemaSurql from './generated/schema.surql?raw';
 
-const client = new SpookyClient({
+const client = new Sp00kyClient({
   database: {
     endpoint: 'ws://localhost:8000',
     namespace: 'my_ns',
@@ -40,7 +40,7 @@ await client.init();
 await client.close();
 ```
 
-### SpookyConfig Options
+### Sp00kyConfig Options
 
 See [references/config.md](references/config.md) for all configuration options.
 
@@ -159,20 +159,96 @@ Buckets must be defined in the schema under the `buckets` array.
 
 ## Backend Runs (HTTP Outbox)
 
-Backend runs let you trigger server-side operations via an outbox pattern. The payload is queued locally and synced to the server.
+Backend runs let you trigger server-side HTTP operations via an **outbox pattern**. When you call `db.run()`, it creates a job record in a local outbox table. That record syncs to remote SurrealDB, where the Sp00ky Sync Platform (SSP) picks it up and calls your backend HTTP API. The result status is written back to the job record and syncs to the client reactively.
+
+### `db.run()` Signature
+
+```typescript
+db.run<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(
+  backend: B,        // Backend name from sp00ky.yml (e.g., 'api')
+  route: R,          // Route path from OpenAPI spec (e.g., '/spookify')
+  payload: RoutePayload<S, B, R>,  // Typed args for the route
+  options?: RunOptions
+): Promise<void>
+```
+
+All parameters are type-safe — `backend`, `route`, and `payload` are inferred from the generated schema.
+
+### RunOptions
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `assignedTo` | `string` | `undefined` | Record ID to link the job to an entity (e.g., `'thread:abc'`) |
+| `max_retries` | `number` | `3` | Maximum retry attempts on failure |
+| `retry_strategy` | `'linear' \| 'exponential'` | `'linear'` | Backoff strategy between retries |
+
+### Entity Linking via `assignedTo`
+
+The `assignedTo` option is how you link a job to an entity. Passing a record ID:
+
+- Sets the `assigned_to` field on the job record (typed as `record<thread>` etc. in the outbox schema)
+- Enables **permission scoping** — e.g., `WHERE assigned_to.author.id = $auth.id` restricts job visibility to the entity's owner
+- Allows **querying jobs via relationships** — use `.related('jobs')` on the parent entity to reactively track job status
+
+### Full Example
+
+**1. Configure the backend in `sp00ky.yml`:**
+
+```yaml
+backends:
+  api:
+    type: http
+    spec: ../api/openapi.yml
+    baseUrl: http://host.docker.internal:3660
+    auth:
+      type: token
+      token: MY_SECRET
+    method:
+      type: outbox
+      table: job
+      schema: ./src/outbox/api.surql
+```
+
+**2. Define the outbox table in SurrealQL** (`src/outbox/api.surql`):
+
+```sql
+DEFINE TABLE job SCHEMAFULL
+PERMISSIONS
+  FOR select, create, update, delete
+  WHERE $access = "account" AND assigned_to.author.id = $auth.id;
+
+DEFINE FIELD assigned_to ON TABLE job TYPE record<thread>;
+DEFINE FIELD path ON TABLE job TYPE string;
+DEFINE FIELD payload ON TABLE job TYPE any;
+DEFINE FIELD retries ON TABLE job TYPE int DEFAULT ALWAYS 0;
+DEFINE FIELD max_retries ON TABLE job TYPE int DEFAULT ALWAYS 3;
+DEFINE FIELD retry_strategy ON TABLE job TYPE string DEFAULT ALWAYS "linear"
+  ASSERT $value IN ["linear", "exponential"];
+DEFINE FIELD status ON TABLE job TYPE string DEFAULT ALWAYS "pending"
+  ASSERT $value IN ["pending", "processing", "success", "failed"];
+DEFINE FIELD errors ON TABLE job TYPE array<object> DEFAULT ALWAYS [];
+DEFINE FIELD created_at ON TABLE job TYPE datetime VALUE time::now();
+```
+
+**3. Run `spooky generate`** — this produces the typed `backends` block in `schema.gen.ts`.
+
+**4. Call `db.run()` with entity linking:**
 
 ```typescript
-await client.run('email', '/send', {
-  to: 'alice@example.com',
-  subject: 'Hello',
-  body: 'World',
-}, {
-  max_retries: 3,
-  retry_strategy: 'exponential',
+// Trigger the /spookify backend route, linked to a thread
+await client.run('api', '/spookify', { id: threadId }, {
+  assignedTo: threadId,  // Links job to the thread entity
 });
 ```
 
-Backends and routes are defined in the schema under `backends`.
+### How It Works Under the Hood
+
+When you call `db.run('api', '/spookify', payload, options)`:
+
+1. Validates the route exists in the schema and all required args are present
+2. Creates a record in the outbox table (`job`) with fields: `path`, `payload` (JSON-stringified), `max_retries`, `retry_strategy`, and optionally `assigned_to`
+3. The record is created via the standard `client.create()` path — optimistic, synced to remote
+4. SSP detects the new job, calls your backend HTTP API, and updates the job's `status` field (`pending` → `processing` → `success`/`failed`)
 
 ## Common Pitfalls
 

package/skills/{spooky-core → sp00ky-core}/references/auth.md

@@ -2,7 +2,7 @@
 
 ## AuthService API
 
-The `AuthService` is available on `SpookyClient` as `client.auth`.
+The `AuthService` is available on `Sp00kyClient` as `client.auth`.
 
 ### Properties
 

package/skills/{spooky-core → sp00ky-core}/references/config.md

@@ -1,7 +1,7 @@
-# SpookyConfig Reference
+# Sp00kyConfig Reference
 
 ```typescript
-interface SpookyConfig<S extends SchemaStructure> {
+interface Sp00kyConfig<S extends SchemaStructure> {
   database: {
     /** SurrealDB WebSocket endpoint URL */
     endpoint?: string;
@@ -29,8 +29,8 @@ interface SpookyConfig<S extends SchemaStructure> {
    * - Custom: Provide an object implementing PersistenceClient
    */
   persistenceClient?: PersistenceClient | 'surrealdb' | 'localstorage';
-  /** OpenTelemetry collector endpoint */
-  otelEndpoint?: string;
+  /** A pino browser transmit object for forwarding logs (e.g. via @spooky-sync/core/otel) */
+  otelTransmit?: PinoTransmit;
   /** Debounce time in ms for stream updates (default: 100) */
   streamDebounceTime?: number;
 }

package/src/build-globals.d.ts

@@ -0,0 +1,12 @@
+// Build-time string constants injected by tsdown's `define` (see
+// tsdown.config.ts). They carry the real bundled frontend package versions so
+// the DevTools can surface frontend/backend version drift.
+//
+// Typed as `string | undefined` on purpose: the substitution only happens when
+// `@spooky-sync/core` is built with our tsdown plugin. A downstream app that
+// bundles core from source never runs that plugin, so these identifiers must be
+// guarded with `typeof` (see modules/devtools/index.ts) to avoid a runtime
+// ReferenceError that would break DB initialization.
+declare const __SP00KY_CORE_VERSION__: string | undefined;
+declare const __SP00KY_WASM_VERSION__: string | undefined;
+declare const __SP00KY_SURREAL_VERSION__: string | undefined;

package/src/events/events.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { EventSystem, EventDefinition } from './index';
+import type { EventDefinition } from './index';
+import { EventSystem } from './index';
 
 // Define test event types
 type TestEvents = {

package/src/events/index.ts

@@ -172,6 +172,9 @@ export class EventSystem<E extends EventTypeMap> {
    * @param payload The data associated with the event.
    */
   emit<T extends EventType<E>, P extends EventPayload<E, T>>(type: T, payload: P): void {
+    // `{ type, payload }` structurally matches `Event<E, T>` (= the indexed
+    // access `E[T]`), but TS can't verify assignability to an indexed-access
+    // type over the generic `E`/`T`, so the constructed event is asserted.
     const event = {
       type,
       payload,

package/src/index.ts

@@ -1,4 +1,26 @@
 export * from './types';
-export * from './spooky';
+export * from './sp00ky';
 export * from './modules/auth/index';
-export { fileToUint8Array } from './utils/index';
+export { CrdtField, CrdtManager, cursorColorFromName, CURSOR_COLORS } from './modules/crdt/index';
+export {
+  FeatureFlagModule,
+  FeatureFlagHandle,
+  type FeatureFlagOptions,
+  type FeatureFlagOverride,
+  type FeatureFlagSnapshot,
+} from './modules/feature-flag/index';
+export {
+  AppReleaseModule,
+  AppReleaseHandle,
+  type AppReleaseOptions,
+  type AppReleaseSnapshot,
+} from './modules/app-release/index';
+export type {
+  BlobCacheStats,
+  BlobEntry,
+  BlobKey,
+  BlobReadOptions,
+  BlobUrlLease,
+} from './services/blobs/index';
+export { semverGt } from './utils/semver';
+export { fileToUint8Array, textToHtml } from './utils/index';

package/src/modules/app-release/index.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AppReleaseModule } from './index';
+
+// Mirrors the FeatureFlagModule test rig: the DataModule mock captures the
+// single subscribe callback so tests can push live results, and counts
+// query() calls to assert the query is SHARED across apps.
+function makeDeps() {
+  let subCb: ((records: unknown[]) => void) | null = null;
+  const calls: Array<{ sql: string; params: unknown }> = [];
+  let authCb: ((userId: string | null) => void) | null = null;
+
+  const dataModule = {
+    query: async (_table: string, sql: string, params: unknown) => {
+      calls.push({ sql, params });
+      return `hash:${calls.length}`;
+    },
+    subscribe: (_hash: string, cb: (records: unknown[]) => void) => {
+      subCb = cb;
+      return () => {
+        subCb = null;
+      };
+    },
+  };
+  const sync = { enqueueDownEvent: () => {} };
+  const auth = {
+    subscribe: (cb: (userId: string | null) => void) => {
+      authCb = cb;
+      return () => {
+        authCb = null;
+      };
+    },
+  };
+  const logger = { child: () => ({ warn: () => {} }) };
+
+  const deps = { dataModule, sync, auth, logger } as any;
+  return {
+    deps,
+    calls,
+    push: (records: unknown[]) => subCb?.(records),
+    setUser: (id: string | null) => authCb?.(id),
+    hasSub: () => subCb !== null,
+  };
+}
+
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+describe('AppReleaseModule', () => {
+  let env: ReturnType<typeof makeDeps>;
+  let mod: AppReleaseModule<any>;
+
+  beforeEach(() => {
+    env = makeDeps();
+    mod = new AppReleaseModule(env.deps);
+  });
+
+  it('registers ONE shared, unfiltered query for many apps', async () => {
+    mod.release('web');
+    mod.release('admin');
+    await tick();
+
+    expect(env.calls.length).toBe(1);
+    expect(env.calls[0].sql).not.toContain('WHERE');
+    expect(env.calls[0].sql).toContain('FROM _00_app_release');
+  });
+
+  it('fans the shared result out to each handle by app', async () => {
+    const web = mod.release('web');
+    const missing = mod.release('missing');
+    await tick();
+
+    env.push([{ app: 'web', version: '1.2.0', cache_bust: true, mandatory: null }]);
+
+    expect(web.version()).toBe('1.2.0');
+    expect(web.snapshot().cacheBust).toBe(true);
+    expect(web.snapshot().mandatory).toBe(false);
+    expect(missing.version()).toBeUndefined();
+    expect(missing.updateAvailable('1.0.0')).toBe(false);
+  });
+
+  it('updateAvailable compares semver against the running build', async () => {
+    const web = mod.release('web');
+    await tick();
+
+    env.push([{ app: 'web', version: '1.2.0' }]);
+    expect(web.updateAvailable('1.1.9')).toBe(true);
+    expect(web.updateAvailable('1.2.0')).toBe(false);
+    expect(web.updateAvailable('1.3.0')).toBe(false);
+    expect(web.updateAvailable('garbage')).toBe(false);
+  });
+
+  it('observes row updates live without re-registering', async () => {
+    const web = mod.release('web');
+    await tick();
+
+    env.push([{ app: 'web', version: '1.0.0' }]);
+    expect(web.updateAvailable('1.0.0')).toBe(false);
+
+    env.push([{ app: 'web', version: '1.0.1', mandatory: true }]);
+    expect(web.updateAvailable('1.0.0')).toBe(true);
+    expect(web.snapshot().mandatory).toBe(true);
+
+    expect(env.calls.length).toBe(1);
+  });
+
+  it('seeds a late-created handle from the already-loaded snapshot', async () => {
+    mod.release('web');
+    await tick();
+    env.push([{ app: 'web', version: '2.0.0' }]);
+
+    const late = mod.release('web');
+    expect(late.version()).toBe('2.0.0');
+  });
+
+  it('re-registers on user change', async () => {
+    mod.init();
+    const web = mod.release('web');
+    await tick();
+    env.push([{ app: 'web', version: '1.0.0' }]);
+    expect(web.version()).toBe('1.0.0');
+
+    env.setUser('user:other');
+    await tick();
+    expect(env.hasSub()).toBe(true); // re-registered under the new session
+  });
+});

package/src/modules/app-release/index.ts

@@ -0,0 +1,201 @@
+import type { SchemaStructure } from '@spooky-sync/query-builder';
+import type { DataModule } from '../data/index';
+import type { Sp00kySync } from '../sync/index';
+import type { AuthService } from '../auth/index';
+import type { Logger } from '../../services/logger/index';
+import type { QueryTimeToLive } from '../../types';
+import { semverGt } from '../../utils/semver';
+
+// One shared LIVE query over every app's release row. `_00_app_release` is
+// world-readable (root-only writes), one row per app keyed by name — written
+// by `spky deploy` / `spky release` / the git-linked builder. A single
+// registration observes every app at once; a handle for an app with no row
+// simply reports no update. Mirrors the FeatureFlagModule design.
+const RELEASE_QUERY = 'SELECT * FROM _00_app_release';
+
+interface ReleaseRow {
+  app?: string;
+  version?: string;
+  cache_bust?: boolean | null;
+  mandatory?: boolean | null;
+  released_at?: string;
+}
+
+export interface AppReleaseSnapshot {
+  /** Latest announced version for the app, or undefined when no row exists. */
+  version: string | undefined;
+  /** Clients should clear SW/caches when reloading onto this version. */
+  cacheBust: boolean;
+  /** Clients should reload/update immediately instead of asking. */
+  mandatory: boolean;
+  releasedAt: string | undefined;
+}
+
+const EMPTY_SNAPSHOT: AppReleaseSnapshot = {
+  version: undefined,
+  cacheBust: false,
+  mandatory: false,
+  releasedAt: undefined,
+};
+
+export interface AppReleaseOptions {
+  ttl?: QueryTimeToLive;
+}
+
+export class AppReleaseHandle {
+  private latest: AppReleaseSnapshot = EMPTY_SNAPSHOT;
+  private listeners = new Set<(s: AppReleaseSnapshot) => void>();
+  private onCloseFn: (() => void) | null = null;
+  private closed = false;
+
+  constructor(public readonly app: string) {}
+
+  set(snapshot: AppReleaseSnapshot): void {
+    if (this.closed) return;
+    this.latest = snapshot;
+    for (const cb of this.listeners) cb(snapshot);
+  }
+
+  snapshot(): AppReleaseSnapshot {
+    return this.latest;
+  }
+
+  version(): string | undefined {
+    return this.latest.version;
+  }
+
+  /** True when the announced version is semver-newer than `currentVersion`. */
+  updateAvailable(currentVersion: string): boolean {
+    return semverGt(this.latest.version, currentVersion);
+  }
+
+  subscribe(cb: (s: AppReleaseSnapshot) => void): () => void {
+    this.listeners.add(cb);
+    cb(this.latest);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  }
+
+  onClose(cb: () => void): void {
+    this.onCloseFn = cb;
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.listeners.clear();
+    this.onCloseFn?.();
+  }
+}
+
+export interface AppReleaseModuleDeps<S extends SchemaStructure> {
+  dataModule: DataModule<S>;
+  sync: Sp00kySync<S>;
+  auth: AuthService<S>;
+  logger: Logger;
+}
+
+export class AppReleaseModule<S extends SchemaStructure> {
+  private logger: Logger;
+  private handles = new Set<AppReleaseHandle>();
+  private authUnsubscribe: (() => void) | null = null;
+  private lastUserId: string | null = null;
+
+  private querySubscription: (() => void) | null = null;
+  private starting = false;
+  private ttl: QueryTimeToLive = '10m';
+  private snapshots = new Map<string, AppReleaseSnapshot>();
+  private loaded = false;
+
+  constructor(private deps: AppReleaseModuleDeps<S>) {
+    this.logger = deps.logger.child({ service: 'AppReleaseModule' });
+  }
+
+  init(): void {
+    if (this.authUnsubscribe) return;
+    // Auth changes re-register the shared query (a new session invalidates the
+    // old SSP plan). The table itself is world-readable, so the data is the
+    // same for every user — this is purely plumbing hygiene.
+    this.authUnsubscribe = this.deps.auth.subscribe((userId) => {
+      if (userId === this.lastUserId) return;
+      this.lastUserId = userId;
+      void this.refresh();
+    });
+  }
+
+  release(app: string, options: AppReleaseOptions = {}): AppReleaseHandle {
+    const handle = new AppReleaseHandle(app);
+    this.handles.add(handle);
+    handle.onClose(() => this.handles.delete(handle));
+    if (options.ttl) this.ttl = options.ttl;
+    if (this.loaded) {
+      handle.set(this.snapshots.get(app) ?? EMPTY_SNAPSHOT);
+    }
+    void this.ensureStarted();
+    return handle;
+  }
+
+  async closeAll(): Promise<void> {
+    this.authUnsubscribe?.();
+    this.authUnsubscribe = null;
+    this.teardownQuery();
+    for (const handle of [...this.handles]) handle.close();
+  }
+
+  private async refresh(): Promise<void> {
+    this.teardownQuery();
+    this.loaded = false;
+    this.snapshots.clear();
+    await this.ensureStarted();
+  }
+
+  private teardownQuery(): void {
+    this.querySubscription?.();
+    this.querySubscription = null;
+  }
+
+  private async ensureStarted(): Promise<void> {
+    if (this.querySubscription || this.starting || this.handles.size === 0) return;
+    this.starting = true;
+    try {
+      const hash = await this.deps.dataModule.query(
+        '_00_app_release' as any,
+        RELEASE_QUERY,
+        {},
+        this.ttl,
+      );
+      this.deps.sync.enqueueDownEvent({ type: 'register', payload: { hash } });
+      this.querySubscription = this.deps.dataModule.subscribe(
+        hash,
+        (records) => this.applyRecords(records as ReleaseRow[]),
+        { immediate: true },
+      );
+    } catch (err) {
+      this.logger.warn(
+        { err, Category: 'sp00ky-client::AppReleaseModule::register' },
+        'Failed to register app release query',
+      );
+    } finally {
+      this.starting = false;
+    }
+  }
+
+  private applyRecords(records: ReleaseRow[]): void {
+    this.snapshots.clear();
+    for (const row of records ?? []) {
+      if (row && typeof row.app === 'string' && typeof row.version === 'string') {
+        this.snapshots.set(row.app, {
+          version: row.version,
+          cacheBust: row.cache_bust === true,
+          mandatory: row.mandatory === true,
+          releasedAt: row.released_at,
+        });
+      }
+    }
+    this.loaded = true;
+    for (const handle of this.handles) {
+      handle.set(this.snapshots.get(handle.app) ?? EMPTY_SNAPSHOT);
+    }
+  }
+}

package/src/modules/auth/events/index.ts

@@ -1,4 +1,5 @@
-import { createEventSystem, EventDefinition, EventSystem } from '../../../events/index';
+import type { EventDefinition, EventSystem } from '../../../events/index';
+import { createEventSystem } from '../../../events/index';
 
 export const AuthEventTypes = {
   AuthStateChanged: 'AUTH_STATE_CHANGED',