@livestore/common 0.4.0-dev.8 → 0.4.0

package/src/devtools/mod.ts

@@ -34,7 +34,15 @@ export const makeNodeName = {
 }
 
 export const makeChannelName = {
-  sessionInfo: () => `session-info`,
+  /**
+   * SessionInfo channel for DevTools discovery.
+   * When an `origin` is provided, it is incorporated into the channel name to scope
+   * broadcasts per origin (e.g. `session-info::http%3A%2F%2Flocalhost%3A5173`).
+   * The `origin` is currently required only for the browser extension path; non‑browser
+   * publishers can pass `undefined` to use the legacy global channel name.
+   */
+  sessionInfo: ({ origin }: { origin: string | undefined }) =>
+    origin !== undefined ? `session-info::${encodeURIComponent(origin)}` : `session-info`,
   devtoolsClientSession: ({ storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string }) =>
     `devtools-channel(client-session-${storeId}-${clientId}-${sessionId})`,
   devtoolsClientLeader: ({ storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string }) =>
@@ -52,8 +60,9 @@ export const isChannelName = {
 
 export const makeSessionInfoBroadcastChannel = (
   webmeshNode: MeshNode,
+  options: { origin: string | undefined },
 ): Effect.Effect<WebChannel.WebChannel<SessionInfo.Message, SessionInfo.Message>, never, Scope.Scope> =>
   webmeshNode.makeBroadcastChannel({
-    channelName: makeChannelName.sessionInfo(),
+    channelName: makeChannelName.sessionInfo({ origin: options?.origin }),
     schema: SessionInfo.Message,
   })

package/src/errors.ts

@@ -1,34 +1,34 @@
 import { Cause, Effect, Layer, Schema, Stream } from '@livestore/utils/effect'
 
-export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('LiveStore.UnexpectedError', {
+import * as LiveStoreEvent from './schema/LiveStoreEvent/mod.ts'
+
+export class UnknownError extends Schema.TaggedError<UnknownError>('~@livestore/common/UnknownError')('UnknownError', {
   cause: Schema.Defect,
   note: Schema.optional(Schema.String),
   payload: Schema.optional(Schema.Any),
 }) {
-  static mapToUnexpectedError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  static mapToUnknownError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     effect.pipe(
-      Effect.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
-      Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
+      Effect.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))),
+      Effect.catchAllDefect((cause) => new UnknownError({ cause })),
     )
 
-  static mapToUnexpectedErrorLayer = <A, E, R>(layer: Layer.Layer<A, E, R>) =>
+  static mapToUnknownErrorLayer = <A, E, R>(layer: Layer.Layer<A, E, R>) =>
     layer.pipe(
       Layer.catchAllCause((cause) =>
-        Cause.isFailType(cause) && Schema.is(UnexpectedError)(cause.error)
+        Cause.isFailType(cause) === true && Schema.is(UnknownError)(cause.error) === true
           ? Layer.fail(cause.error)
-          : Layer.fail(new UnexpectedError({ cause: cause })),
+          : Layer.fail(new UnknownError({ cause: cause })),
       ),
     )
 
-  static mapToUnexpectedErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
-    stream.pipe(
-      Stream.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
-    )
+  static mapToUnknownErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
+    stream.pipe(Stream.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))))
 }
 
-export class MaterializerHashMismatchError extends Schema.TaggedError<MaterializerHashMismatchError>()(
-  'LiveStore.MaterializerHashMismatchError',
-  {
+export class MaterializerHashMismatchError extends Schema.TaggedError<MaterializerHashMismatchError>(
+  '~@livestore/common/MaterializerHashMismatchError',
+)('MaterializerHashMismatchError', {
     eventName: Schema.String,
     note: Schema.optionalWith(Schema.String, {
       default: () => 'Please make sure your event materializer is a pure function without side effects.',
@@ -36,18 +36,19 @@ export class MaterializerHashMismatchError extends Schema.TaggedError<Materializ
   },
 ) {}
 
-export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>()(
-  'LiveStore.IntentionalShutdownCause',
-  {
-    reason: Schema.Literal('devtools-reset', 'devtools-import', 'adapter-reset', 'manual'),
-  },
-) {}
+export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>(
+  '~@livestore/common/IntentionalShutdownCause',
+)('IntentionalShutdownCause', {
+  reason: Schema.Literal('devtools-reset', 'devtools-import', 'adapter-reset', 'manual', 'backend-id-mismatch'),
+}) {}
 
-export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>()('LiveStore.StoreInterrupted', {
+export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>(
+  '~@livestore/common/StoreInterrupted',
+)('StoreInterrupted', {
   reason: Schema.String,
 }) {}
 
-export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.SqliteError', {
+export class SqliteError extends Schema.TaggedError<SqliteError>('~@livestore/common/SqliteError')('SqliteError', {
   query: Schema.optional(
     Schema.Struct({
       sql: Schema.String,
@@ -63,7 +64,14 @@ export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.Sq
   note: Schema.optional(Schema.String),
 }) {}
 
-export class MaterializeError extends Schema.TaggedError<MaterializeError>()('LiveStore.MaterializeError', {
-  cause: Schema.Union(MaterializerHashMismatchError, SqliteError),
+export class UnknownEventError extends Schema.TaggedError<UnknownEventError>('~@livestore/common/UnknownEventError')('UnknownEventError', {
+  event: LiveStoreEvent.Client.Encoded.pipe(Schema.pick('name', 'args', 'seqNum', 'clientId', 'sessionId')),
+  reason: Schema.Literal('event-definition-missing', 'materializer-missing'),
+  operation: Schema.String,
+  note: Schema.optional(Schema.String),
+}) {}
+
+export class MaterializeError extends Schema.TaggedError<MaterializeError>('~@livestore/common/MaterializeError')('MaterializeError', {
+  cause: Schema.Union(MaterializerHashMismatchError, SqliteError, UnknownEventError),
   note: Schema.optional(Schema.String),
 }) {}

package/src/index.ts

@@ -2,15 +2,18 @@ export * from './adapter-types.ts'
 export * from './bounded-collections.ts'
 export * from './debug-info.ts'
 export * as Devtools from './devtools/mod.ts'
+export * as LogConfig from './logging.ts'
 export * from './make-client-session.ts'
 export * from './materializer-helper.ts'
 export * from './otel.ts'
 export * from './rematerialize-from-eventlog.ts'
 export * from './schema/state/sqlite/query-builder/mod.ts'
-export * from './schema/state/sqlite/system-tables.ts'
+export * from './schema/state/sqlite/system-tables/mod.ts'
 export * from './schema-management/migrations.ts'
 export * as SqliteDbHelper from './sqlite-db-helper.ts'
+export * from './leader-thread/RejectedPushError.ts'
 export * from './sync/index.ts'
 export * as SyncState from './sync/syncstate.ts'
 export * from './util.ts'
 export * from './version.ts'
+export * from './WorkerTransportError.ts'