@dxos/plugin-observability 0.8.2-staging.7ac8446 → 0.8.2

package/dist/types/src/types.d.ts

@@ -1,169 +1,282 @@
-import { S } from '@dxos/echo-schema';
-export declare const UserFeedback: S.Struct<{
-    message: S.filter<S.filter<typeof S.String>>;
+import { Schema } from 'effect';
+import { Type } from '@dxos/echo';
+export declare const UserFeedback: Schema.Struct<{
+    message: Schema.filter<Schema.filter<typeof Schema.String>>;
 }>;
-export type UserFeedback = S.Schema.Type<typeof UserFeedback>;
+export type UserFeedback = Schema.Schema.Type<typeof UserFeedback>;
 export declare namespace ObservabilityAction {
-    const Toggle_base: S.TaggedClass<Toggle, "dxos.org/plugin/observability/action/toggle", {
-        readonly _tag: S.tag<"dxos.org/plugin/observability/action/toggle">;
+    const Toggle_base: Schema.TaggedClass<Toggle, "dxos.org/plugin/observability/action/toggle", {
+        readonly _tag: Schema.tag<"dxos.org/plugin/observability/action/toggle">;
     } & {
-        input: S.Struct<{
-            state: S.optional<typeof S.Boolean>;
+        input: Schema.Struct<{
+            state: Schema.optional<typeof Schema.Boolean>;
         }>;
-        output: typeof S.Boolean;
+        output: typeof Schema.Boolean;
     }>;
     export class Toggle extends Toggle_base {
     }
-    const CaptureUserFeedback_base: S.TaggedClass<CaptureUserFeedback, "dxos.org/plugin/observability/action/capture-feedback", {
-        readonly _tag: S.tag<"dxos.org/plugin/observability/action/capture-feedback">;
+    const CaptureUserFeedback_base: Schema.TaggedClass<CaptureUserFeedback, "dxos.org/plugin/observability/action/capture-feedback", {
+        readonly _tag: Schema.tag<"dxos.org/plugin/observability/action/capture-feedback">;
     } & {
-        input: S.Struct<{
-            message: S.filter<S.filter<typeof S.String>>;
+        input: Schema.Struct<{
+            message: Schema.filter<Schema.filter<typeof Schema.String>>;
         }>;
-        output: typeof S.Void;
+        output: typeof Schema.Void;
     }>;
     export class CaptureUserFeedback extends CaptureUserFeedback_base {
     }
-    const BaseSendEvent_base: S.TaggedClass<BaseSendEvent, "dxos.org/plugin/observability/action/send-event", {
-        readonly _tag: S.tag<"dxos.org/plugin/observability/action/send-event">;
+    const BaseSendEvent_base: Schema.TaggedClass<BaseSendEvent, "dxos.org/plugin/observability/action/send-event", {
+        readonly _tag: Schema.tag<"dxos.org/plugin/observability/action/send-event">;
     } & {
-        input: S.Struct<{
-            name: typeof S.String;
-            properties: S.optional<typeof S.Object>;
+        input: Schema.Struct<{
+            name: typeof Schema.String;
+            properties: Schema.optional<typeof Schema.Object>;
         }>;
-        output: typeof S.Void;
+        output: typeof Schema.Void;
     }>;
     /** Base intent for sending events. */
     export class BaseSendEvent extends BaseSendEvent_base {
     }
-    const SendEvent_base: S.TaggedClass<SendEvent, "dxos.org/plugin/observability/action/send-event", {
-        readonly _tag: S.tag<"dxos.org/plugin/observability/action/send-event">;
+    const SendEvent_base: Schema.TaggedClass<SendEvent, "dxos.org/plugin/observability/action/send-event", {
+        readonly _tag: Schema.tag<"dxos.org/plugin/observability/action/send-event">;
     } & {
-        input: S.Union<[S.Struct<{
-            name: S.Literal<["identity.create"]>;
-        }>, S.Struct<{
-            name: S.Literal<["identity.join"]>;
-        }>, S.Struct<{
-            name: S.Literal<["identity.recover"]>;
-        }>, S.Struct<{
-            name: S.Literal<["identity.share"]>;
-        }>, S.Struct<{
-            name: S.Literal<["navigation.activate"]>;
-            properties: S.Struct<{
-                subjectId: typeof S.String;
-                typename: S.optional<typeof S.String>;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["page.load"]>;
-            properties: S.Struct<{
-                loadDuration: typeof S.Number;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["plugins.toggle"]>;
-            properties: S.Struct<{
-                plugin: typeof S.String;
-                enabled: typeof S.Boolean;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["space.create"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["space.join"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["space.limit"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["space.lock"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["space.migrate"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                targetVersion: S.optional<typeof S.String>;
-                version: S.optional<typeof S.String>;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["space.object.add"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                objectId: typeof S.String;
-                typename: S.optional<typeof S.String>;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["space.share"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["space.unlock"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["threads.create"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                threadId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["threads.delete"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                threadId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["threads.message.add"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                threadId: typeof S.String;
-                threadLength: typeof S.Number;
-                messageId: typeof S.String;
-                messageLength: typeof S.Number;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["threads.message.delete"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                threadId: typeof S.String;
-                messageId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["threads.message.undo-delete"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                threadId: typeof S.String;
-                messageId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["threads.message.update"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                messageId: typeof S.String;
-                messageLength: typeof S.Number;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["threads.toggle-resolved"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                threadId: typeof S.String;
-            }>;
-        }>, S.Struct<{
-            name: S.Literal<["threads.undo-delete"]>;
-            properties: S.Struct<{
-                spaceId: typeof S.String;
-                threadId: typeof S.String;
+        input: Schema.Union<[Schema.Struct<{
+            name: Schema.Literal<["identity.create"]>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["identity.join"]>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["identity.recover"]>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["identity.share"]>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["navigation.activate"]>;
+            properties: Schema.Struct<{
+                subjectId: typeof Schema.String;
+                typename: Schema.optional<typeof Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["page.load"]>;
+            properties: Schema.Struct<{
+                loadDuration: typeof Schema.Number;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["plugins.toggle"]>;
+            properties: Schema.Struct<{
+                plugin: typeof Schema.String;
+                enabled: typeof Schema.Boolean;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["space.create"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["space.join"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["space.limit"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["space.lock"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["space.migrate"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                targetVersion: Schema.optional<typeof Schema.String>;
+                version: Schema.optional<typeof Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["space.object.add"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                objectId: typeof Schema.String;
+                typename: Schema.optional<typeof Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["space.share"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["space.unlock"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["threads.create"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                threadId: typeof Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["threads.delete"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                threadId: typeof Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["threads.message.add"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                threadId: typeof Schema.String;
+                threadLength: typeof Schema.Number;
+                messageId: typeof Schema.String;
+                messageLength: typeof Schema.Number;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["threads.message.delete"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                threadId: typeof Schema.String;
+                messageId: typeof Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["threads.message.undo-delete"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                threadId: typeof Schema.String;
+                messageId: typeof Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["threads.message.update"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                messageId: typeof Schema.String;
+                messageLength: typeof Schema.Number;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["threads.toggle-resolved"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                threadId: typeof Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            name: Schema.Literal<["threads.undo-delete"]>;
+            properties: Schema.Struct<{
+                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
+                    byteLength: number;
+                    encode: (value: Uint8Array) => Type.SpaceId;
+                    decode: (value: Type.SpaceId) => Uint8Array;
+                    isValid: (value: string) => value is Type.SpaceId;
+                    make: (value: string) => Type.SpaceId;
+                    random: () => Type.SpaceId;
+                };
+                threadId: typeof Schema.String;
             }>;
         }>]>;
-        output: typeof S.Void;
+        output: typeof Schema.Void;
     }>;
     /** Intent with strict types for first-party events. */
     export class SendEvent extends SendEvent_base {

package/dist/types/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAUtC,eAAO,MAAM,YAAY;;EAEvB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAI9D,yBAAiB,mBAAmB,CAAC;;;;;;;;;IACnC,MAAM,OAAO,MAAO,SAAQ,WAK1B;KAAG;;;;;;;;;IAEL,MAAM,OAAO,mBAAoB,SAAQ,wBAMxC;KAAG;;;;;;;;;;IAEJ,sCAAsC;IACtC,MAAM,OAAO,aAAc,SAAQ,kBAMjC;KAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEL,uDAAuD;IACvD,MAAM,OAAO,SAAU,SAAQ,cAuJ7B;KAAG;;CACN"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAUlC,eAAO,MAAM,YAAY;;EAEvB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAInE,yBAAiB,mBAAmB,CAAC;;;;;;;;;IACnC,MAAM,OAAO,MAAO,SAAQ,WAK1B;KAAG;;;;;;;;;IAEL,MAAM,OAAO,mBAAoB,SAAQ,wBAMxC;KAAG;;;;;;;;;;IAEJ,sCAAsC;IACtC,MAAM,OAAO,aAAc,SAAQ,kBAMjC;KAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEL,uDAAuD;IACvD,MAAM,OAAO,SAAU,SAAQ,cAuJ7B;KAAG;;CACN"}

package/dist/types/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"version":"5.7.3"}
+{"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/plugin-observability",
-  "version": "0.8.2-staging.7ac8446",
+  "version": "0.8.2",
   "description": "DXOS app framework plugin for hooking up app observability",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -33,38 +33,47 @@
     "src"
   ],
   "dependencies": {
-    "@preact/signals-core": "^1.6.0",
+    "@preact-signals/safe-react": "^0.9.0",
+    "@preact/signals-core": "^1.9.0",
+    "effect": "^3.13.3",
     "localforage": "^1.10.0",
-    "@dxos/app-framework": "0.8.2-staging.7ac8446",
-    "@dxos/async": "0.8.2-staging.7ac8446",
-    "@dxos/echo-schema": "0.8.2-staging.7ac8446",
-    "@dxos/invariant": "0.8.2-staging.7ac8446",
-    "@dxos/live-object": "0.8.2-staging.7ac8446",
-    "@dxos/local-storage": "0.8.2-staging.7ac8446",
-    "@dxos/context": "0.8.2-staging.7ac8446",
-    "@dxos/log": "0.8.2-staging.7ac8446",
-    "@dxos/plugin-graph": "0.8.2-staging.7ac8446",
-    "@dxos/protocols": "0.8.2-staging.7ac8446",
-    "@dxos/react-client": "0.8.2-staging.7ac8446",
-    "@dxos/react-ui-form": "0.8.2-staging.7ac8446",
-    "@dxos/react-ui-stack": "0.8.2-staging.7ac8446",
-    "@dxos/observability": "0.8.2-staging.7ac8446",
-    "@dxos/util": "0.8.2-staging.7ac8446"
+    "@dxos/app-framework": "0.8.2",
+    "@dxos/async": "0.8.2",
+    "@dxos/echo": "0.8.2",
+    "@dxos/echo-schema": "0.8.2",
+    "@dxos/context": "0.8.2",
+    "@dxos/local-storage": "0.8.2",
+    "@dxos/invariant": "0.8.2",
+    "@dxos/live-object": "0.8.2",
+    "@dxos/log": "0.8.2",
+    "@dxos/observability": "0.8.2",
+    "@dxos/plugin-graph": "0.8.2",
+    "@dxos/protocols": "0.8.2",
+    "@dxos/react-ui-form": "0.8.2",
+    "@dxos/react-client": "0.8.2",
+    "@dxos/util": "0.8.2",
+    "@dxos/react-ui-stack": "0.8.2"
   },
   "devDependencies": {
+    "@effect-rx/rx-react": "^0.34.1",
+    "@effect/platform": "0.80.12",
     "@phosphor-icons/react": "^2.1.5",
     "@types/react": "~18.2.0",
     "react": "~18.2.0",
     "vite": "5.4.7",
-    "@dxos/react-ui": "0.8.2-staging.7ac8446",
-    "@dxos/react-ui-theme": "0.8.2-staging.7ac8446",
-    "@dxos/storybook-utils": "0.8.2-staging.7ac8446"
+    "@dxos/react-ui": "0.8.2",
+    "@dxos/react-ui-theme": "0.8.2",
+    "@dxos/storybook-utils": "0.8.2"
   },
   "peerDependencies": {
+    "@effect-rx/rx-react": "^0.34.1",
+    "@effect/platform": "0.80.12",
     "@phosphor-icons/react": "^2.1.5",
+    "effect": "^3.13.3",
     "react": "~18.2.0",
-    "@dxos/react-ui": "0.8.2-staging.7ac8446",
-    "@dxos/react-ui-theme": "0.8.2-staging.7ac8446"
+    "react-dom": "~18.2.0",
+    "@dxos/react-ui-theme": "0.8.2",
+    "@dxos/react-ui": "0.8.2"
   },
   "publishConfig": {
     "access": "public"

package/src/capabilities/app-graph-builder.ts

@@ -2,8 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
-import { createExtension, type Node } from '@dxos/plugin-graph';
+import { Rx } from '@effect-rx/rx-react';
+import { Option, pipe } from 'effect';
+
+import { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';
+import { createExtension, ROOT_ID } from '@dxos/plugin-graph';
 
 import { OBSERVABILITY_PLUGIN } from '../meta';
 
@@ -11,23 +14,32 @@ import { OBSERVABILITY_PLUGIN } from '../meta';
 const ATTENDABLE_PATH_SEPARATOR = '~';
 const DECK_COMPANION_TYPE = 'dxos.org/plugin/deck/deck-companion';
 
-export default (context: PluginsContext) =>
+export default (context: PluginContext) =>
   contributes(Capabilities.AppGraphBuilder, [
     createExtension({
       id: `${OBSERVABILITY_PLUGIN}/help`,
-      filter: (node): node is Node<null> => node.id === 'root',
-      connector: ({ node }) => [
-        {
-          id: [node.id, 'help'].join(ATTENDABLE_PATH_SEPARATOR),
-          type: DECK_COMPANION_TYPE,
-          data: null,
-          properties: {
-            label: ['help label', { ns: OBSERVABILITY_PLUGIN }],
-            icon: 'ph--question--regular',
-            disposition: 'hidden',
-            position: 'hoist',
-          },
-        },
-      ],
+      connector: (node) =>
+        Rx.make((get) =>
+          pipe(
+            get(node),
+            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
+            Option.map((node) => {
+              return [
+                {
+                  id: [node.id, 'help'].join(ATTENDABLE_PATH_SEPARATOR),
+                  type: DECK_COMPANION_TYPE,
+                  data: null,
+                  properties: {
+                    label: ['help label', { ns: OBSERVABILITY_PLUGIN }],
+                    icon: 'ph--question--regular',
+                    disposition: 'hidden',
+                    position: 'hoist',
+                  },
+                },
+              ];
+            }),
+            Option.getOrElse(() => []),
+          ),
+        ),
     }),
   ]);

package/src/capabilities/client-ready.ts

@@ -8,7 +8,7 @@ import {
   createIntent,
   LayoutAction,
   SettingsAction,
-  type PluginsContext,
+  type PluginContext,
 } from '@dxos/app-framework';
 import { setupTelemetryListeners, type Observability } from '@dxos/observability';
 
@@ -17,16 +17,16 @@ import { OBSERVABILITY_PLUGIN } from '../meta';
 import { ObservabilityAction } from '../types';
 
 type ClientReadyOptions = {
-  context: PluginsContext;
+  context: PluginContext;
   namespace: string;
   observability: Observability;
 };
 
 export default async ({ context, namespace, observability }: ClientReadyOptions) => {
-  const manager = context.requestCapability(Capabilities.PluginManager);
-  const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-  const state = context.requestCapability(ObservabilityCapabilities.State);
-  const client = context.requestCapability(ClientCapability);
+  const manager = context.getCapability(Capabilities.PluginManager);
+  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+  const state = context.getCapability(ObservabilityCapabilities.State);
+  const client = context.getCapability(ClientCapability);
 
   const sendPrivacyNotice = async () => {
     const environment = client?.config?.values.runtime?.app?.env?.DX_ENVIRONMENT;