@dxos/plugin-observability 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

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

@@ -1,313 +0,0 @@
-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 = Schema.Schema.Type<typeof UserFeedback>;
-export declare namespace ObservabilityAction {
-    const Toggle_base: Schema.TaggedClass<Toggle, `${string}/action/toggle`, {
-        readonly _tag: Schema.tag<`${string}/action/toggle`>;
-    } & {
-        input: Schema.Struct<{
-            state: Schema.optional<typeof Schema.Boolean>;
-        }>;
-        output: typeof Schema.Boolean;
-    }>;
-    export class Toggle extends Toggle_base {
-    }
-    const CaptureUserFeedback_base: Schema.TaggedClass<CaptureUserFeedback, `${string}/action/capture-feedback`, {
-        readonly _tag: Schema.tag<`${string}/action/capture-feedback`>;
-    } & {
-        input: Schema.Struct<{
-            message: Schema.filter<Schema.filter<typeof Schema.String>>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class CaptureUserFeedback extends CaptureUserFeedback_base {
-    }
-    const BaseSendEvent_base: Schema.TaggedClass<BaseSendEvent, `${string}/action/send-event`, {
-        readonly _tag: Schema.tag<`${string}/action/send-event`>;
-    } & {
-        input: Schema.Struct<{
-            name: typeof Schema.String;
-            properties: Schema.optional<typeof Schema.Object>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    /** Base intent for sending events. */
-    export class BaseSendEvent extends BaseSendEvent_base {
-    }
-    const SendEvent_base: Schema.TaggedClass<SendEvent, `${string}/action/send-event`, {
-        readonly _tag: Schema.tag<`${string}/action/send-event`>;
-    } & {
-        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.schema.use"]>;
-            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;
-                };
-                typename: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.schema.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: 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 Schema.Void;
-    }>;
-    /** Intent with strict types for first-party events. */
-    export class SendEvent extends SendEvent_base {
-    }
-    export {};
-}
-//# sourceMappingURL=schema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema.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;AAEnE,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,cAsK7B;KAAG;;CACN"}

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

@@ -1,45 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Rx } from '@effect-rx/rx-react';
-import { Option, pipe } from 'effect';
-
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
-import { ROOT_ID, createExtension } from '@dxos/plugin-graph';
-
-import { OBSERVABILITY_PLUGIN } from '../meta';
-
-// NOTE: Copied from @dxos/plugin-deck to break circular dependency.
-const ATTENDABLE_PATH_SEPARATOR = '~';
-const DECK_COMPANION_TYPE = 'dxos.org/plugin/deck/deck-companion';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${OBSERVABILITY_PLUGIN}/help`,
-      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/capabilities.ts

@@ -1,22 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineCapability } from '@dxos/app-framework';
-import { type Client } from '@dxos/client';
-import { type Observability } from '@dxos/observability';
-
-import { OBSERVABILITY_PLUGIN } from '../meta';
-
-export namespace ObservabilityCapabilities {
-  export type State = {
-    group?: string;
-    notified?: boolean;
-  };
-  export const State = defineCapability<State>(`${OBSERVABILITY_PLUGIN}/capability/state`);
-
-  export const Observability = defineCapability<Observability>(`${OBSERVABILITY_PLUGIN}/capability/observability`);
-}
-
-// NOTE: This is cloned from the client plugin to avoid circular dependencies.
-export const ClientCapability = defineCapability<Client>('dxos.org/plugin/client/capability/client');

package/src/capabilities/intent-resolver.ts

@@ -1,69 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, IntentAction, type PluginContext, contributes, createResolver } from '@dxos/app-framework';
-import { log } from '@dxos/log';
-import { getTelemetryIdentity, storeObservabilityDisabled } from '@dxos/observability';
-
-import { type ObservabilitySettingsProps } from '../components';
-import { OBSERVABILITY_PLUGIN } from '../meta';
-import { ObservabilityAction } from '../types';
-
-import { ClientCapability, ObservabilityCapabilities } from './capabilities';
-
-export default ({ context, namespace }: { context: PluginContext; namespace: string }) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: IntentAction.Track,
-      resolve: (intent) => {
-        log.info('intent', { intent });
-      },
-    }),
-    createResolver({
-      intent: ObservabilityAction.Toggle,
-      resolve: async ({ state }) => {
-        const client = context.getCapability(ClientCapability);
-        const observability = context.getCapability(ObservabilityCapabilities.Observability);
-        const settings = context
-          .getCapability(Capabilities.SettingsStore)
-          .getStore<ObservabilitySettingsProps>(OBSERVABILITY_PLUGIN)!.value;
-        settings.enabled = state ?? !settings.enabled;
-        observability.track({
-          ...getTelemetryIdentity(client),
-          action: 'observability.toggle',
-          properties: {
-            enabled: settings.enabled,
-          },
-        });
-        observability.setMode(settings.enabled ? 'basic' : 'disabled');
-        await storeObservabilityDisabled(namespace, !settings.enabled);
-        return { data: settings.enabled };
-      },
-    }),
-    createResolver({
-      intent: ObservabilityAction.SendEvent,
-      resolve: (data) => {
-        const client = context.getCapability(ClientCapability);
-        const properties = 'properties' in data ? data.properties : {};
-
-        // NOTE: This is to ensure that events fired before observability is ready are still sent.
-        // TODO(wittjosiah): If the intent dispatcher supports concurrent actions in the future,
-        //   then this could be awaited still rather than voiding.
-        void context.waitForCapability(ObservabilityCapabilities.Observability).then((observability) => {
-          observability.track({
-            ...getTelemetryIdentity(client),
-            action: data.name,
-            properties,
-          });
-        });
-      },
-    }),
-    createResolver({
-      intent: ObservabilityAction.CaptureUserFeedback,
-      resolve: async (data) => {
-        const observability = context.getCapability(ObservabilityCapabilities.Observability);
-        observability.captureUserFeedback(data.message);
-      },
-    }),
-  ]);

package/src/components/FeedbackForm.tsx

@@ -1,82 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import React, { useCallback, useRef, useState } from 'react';
-
-import { getSnapshot } from '@dxos/echo-schema';
-import { IconButton, Input, useTranslation } from '@dxos/react-ui';
-import { FormProvider, useFormContext, useInputProps } from '@dxos/react-ui-form';
-
-import { OBSERVABILITY_PLUGIN } from '../meta';
-import { UserFeedback } from '../types';
-
-const defaultValues: UserFeedback = { message: '' };
-
-const FormContent = () => {
-  const { t } = useTranslation(OBSERVABILITY_PLUGIN);
-  const { handleSave, canSave } = useFormContext<UserFeedback>();
-
-  const messageProps = useInputProps(['message']);
-
-  return (
-    <div role='form' className='p-3 flex flex-col gap-2'>
-      <div role='none' className='space-b-1'>
-        <Input.Root validationValence={messageProps.getStatus().status}>
-          <Input.Label>{t('feedback text area label')}</Input.Label>
-          <Input.TextArea
-            classNames={'text-sm'}
-            rows={5}
-            cols={30}
-            placeholder={t('feedback text area placeholder')}
-            value={messageProps.getValue() ?? ''}
-            onChange={(e) => messageProps.onValueChange('string', e.target.value)}
-            // TODO(wittjosiah): This aggressively shows validation errors.
-            onBlur={messageProps.onBlur}
-          />
-          <Input.DescriptionAndValidation>
-            <Input.Validation>{messageProps.getStatus().error}</Input.Validation>
-          </Input.DescriptionAndValidation>
-        </Input.Root>
-      </div>
-
-      <div role='none' className='space-b-2'>
-        <IconButton
-          icon='ph--paper-plane-tilt--regular'
-          label={t('send feedback label')}
-          variant='primary'
-          type='submit'
-          classNames='is-full'
-          disabled={!canSave}
-          onClick={handleSave}
-        />
-      </div>
-    </div>
-  );
-};
-
-// TODO(wittjosiah): Use `Form`?
-export const FeedbackForm = ({ onSave }: { onSave: (values: UserFeedback) => void }) => {
-  const formRef = useRef<HTMLDivElement>(null);
-  const [_, update] = useState({});
-  const forceRender = useCallback(() => update({}), [update]);
-
-  const handleSave = useCallback(
-    (values: UserFeedback) => {
-      onSave(values);
-      // TODO(wittjosiah): Force re-render to clear the form.
-      forceRender();
-    },
-    [forceRender, onSave],
-  );
-
-  const initialValues = getSnapshot(defaultValues);
-
-  return (
-    <FormProvider formRef={formRef} schema={UserFeedback} initialValues={initialValues} onSave={handleSave}>
-      <div ref={formRef}>
-        <FormContent />
-      </div>
-    </FormProvider>
-  );
-};

package/src/components/HelpContainer.tsx

@@ -1,41 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { pipe } from 'effect';
-import React, { useCallback } from 'react';
-
-import { LayoutAction, chain, createIntent, useIntentDispatcher } from '@dxos/app-framework';
-
-import { OBSERVABILITY_PLUGIN } from '../meta';
-import { ObservabilityAction, type UserFeedback } from '../types';
-
-import { FeedbackForm } from './FeedbackForm';
-
-export const HelpContainer = () => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-
-  const handleSave = useCallback(
-    (values: UserFeedback) =>
-      dispatch(
-        pipe(
-          createIntent(ObservabilityAction.CaptureUserFeedback, values),
-          chain(LayoutAction.UpdateComplementary, { part: 'complementary', options: { state: 'collapsed' } }),
-          chain(LayoutAction.AddToast, {
-            part: 'toast',
-            subject: {
-              id: `${OBSERVABILITY_PLUGIN}/feedback-success`,
-              icon: 'ph--paper-plane-tilt--regular',
-              duration: 3000,
-              title: ['feedback toast label', { ns: OBSERVABILITY_PLUGIN }],
-              description: ['feedback toast description', { ns: OBSERVABILITY_PLUGIN }],
-              closeLabel: ['close label', { ns: 'os' }],
-            },
-          }),
-        ),
-      ),
-    [dispatch],
-  );
-
-  return <FeedbackForm onSave={handleSave} />;
-};

package/src/components/ObservabilitySettings.tsx

@@ -1,48 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { Schema } from 'effect';
-import React from 'react';
-
-import { createIntent, useIntentDispatcher } from '@dxos/app-framework';
-import { Input, Message, useTranslation } from '@dxos/react-ui';
-import { DeprecatedFormContainer, DeprecatedFormInput } from '@dxos/react-ui-form';
-
-import { OBSERVABILITY_PLUGIN } from '../meta';
-import { ObservabilityAction } from '../types';
-
-export const ObservabilitySettingsSchema = Schema.mutable(
-  Schema.Struct({
-    enabled: Schema.Boolean,
-    // TODO(wittjosiah): Separate settings for each observability feature.
-    // metrics?: boolean;
-    // telemetry?: boolean;
-    // errors?: boolean;
-  }),
-);
-
-export type ObservabilitySettingsProps = Schema.Schema.Type<typeof ObservabilitySettingsSchema>;
-
-export const ObservabilitySettings = ({ settings }: { settings: ObservabilitySettingsProps }) => {
-  const { t } = useTranslation(OBSERVABILITY_PLUGIN);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-
-  return (
-    <DeprecatedFormContainer>
-      <DeprecatedFormInput
-        label={t('observability enabled label')}
-        secondary={
-          <Message.Root valence='info'>
-            <Message.Content>{t('observability description')}</Message.Content>
-          </Message.Root>
-        }
-      >
-        <Input.Switch
-          checked={settings.enabled}
-          onCheckedChange={(checked) => dispatch(createIntent(ObservabilityAction.Toggle, { state: !!checked }))}
-        />
-      </DeprecatedFormInput>
-    </DeprecatedFormContainer>
-  );
-};

package/src/events.ts

@@ -1,14 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Events, defineEvent } from '@dxos/app-framework';
-
-import { OBSERVABILITY_PLUGIN } from './meta';
-
-export namespace ObservabilityEvents {
-  export const StateReady = Events.createStateEvent(OBSERVABILITY_PLUGIN);
-}
-
-// NOTE: This is cloned from the client plugin to avoid circular dependencies.
-export const ClientReadyEvent = defineEvent('dxos.org/plugin/client/event/client-ready');