@dxos/plugin-observability 0.8.4-main.70d3990 → 0.8.4-main.74a063c4e0

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

@@ -1,3 +0,0 @@
-import React from 'react';
-export declare const HelpContainer: () => React.JSX.Element;
-//# sourceMappingURL=HelpContainer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"HelpContainer.d.ts","sourceRoot":"","sources":["../../../../src/components/HelpContainer.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAsB,MAAM,OAAO,CAAC;AAU3C,eAAO,MAAM,aAAa,yBA0BzB,CAAC"}

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

@@ -1,10 +0,0 @@
-import * as Schema from 'effect/Schema';
-import React from 'react';
-export declare const ObservabilitySettingsSchema: Schema.mutable<Schema.Struct<{
-    enabled: typeof Schema.Boolean;
-}>>;
-export type ObservabilitySettingsProps = Schema.Schema.Type<typeof ObservabilitySettingsSchema>;
-export declare const ObservabilitySettings: ({ settings }: {
-    settings: ObservabilitySettingsProps;
-}) => React.JSX.Element;
-//# sourceMappingURL=ObservabilitySettings.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ObservabilitySettings.d.ts","sourceRoot":"","sources":["../../../../src/components/ObservabilitySettings.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,OAAO,CAAC;AAU1B,eAAO,MAAM,2BAA2B;;GAQvC,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhG,eAAO,MAAM,qBAAqB,GAAI,cAAc;IAAE,QAAQ,EAAE,0BAA0B,CAAA;CAAE,sBAqB3F,CAAC"}

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

@@ -1,5 +0,0 @@
-export declare namespace ObservabilityEvents {
-    const StateReady: import("@dxos/app-framework").ActivationEvent;
-}
-export declare const ClientReadyEvent: import("@dxos/app-framework").ActivationEvent;
-//# sourceMappingURL=events.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/events.ts"],"names":[],"mappings":"AAQA,yBAAiB,mBAAmB,CAAC;IAC5B,MAAM,UAAU,+CAAmC,CAAC;CAC5D;AAGD,eAAO,MAAM,gBAAgB,+CAA2D,CAAC"}

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

@@ -1,313 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { Key } 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<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.join"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.limit"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.lock"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.migrate"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.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<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                typename: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.schema.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                objectId: typeof Schema.String;
-                typename: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.object.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                objectId: typeof Schema.String;
-                typename: Schema.optional<typeof Schema.String>;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.share"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.unlock"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.create"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.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<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                messageId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.undo-delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                messageId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.update"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                messageId: typeof Schema.String;
-                messageLength: typeof Schema.Number;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.toggle-resolved"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.undo-delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.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,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAUjC,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/capabilities.ts

@@ -1,23 +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 { meta } from '../meta';
-
-export namespace ObservabilityCapabilities {
-  export type State = {
-    group?: string;
-    notified?: boolean;
-  };
-  export const State = defineCapability<State>(`${meta.id}/capability/state`);
-
-  export const Observability = defineCapability<Observability>(`${meta.id}/capability/observability`);
-}
-
-// NOTE: This is cloned from the client plugin to avoid circular dependencies.
-// TODO(burdon): Figure out how to share defs.
-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 { meta } 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>(meta.id)!.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/internal';
-import { IconButton, Input, useTranslation } from '@dxos/react-ui';
-import { FormProvider, useFormContext, useInputProps } from '@dxos/react-ui-form';
-
-import { meta } from '../meta';
-import { UserFeedback } from '../types';
-
-const defaultValues: UserFeedback = { message: '' };
-
-const FormContent = () => {
-  const { t } = useTranslation(meta.id);
-  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,42 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Function from 'effect/Function';
-import React, { useCallback } from 'react';
-
-import { LayoutAction, chain, createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
-
-import { meta } 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(
-        Function.pipe(
-          createIntent(ObservabilityAction.CaptureUserFeedback, values),
-          chain(LayoutAction.UpdateComplementary, { part: 'complementary', options: { state: 'collapsed' } }),
-          chain(LayoutAction.AddToast, {
-            part: 'toast',
-            subject: {
-              id: `${meta.id}/feedback-success`,
-              icon: 'ph--paper-plane-tilt--regular',
-              duration: 3000,
-              title: ['feedback toast label', { ns: meta.id }],
-              description: ['feedback toast description', { ns: meta.id }],
-              closeLabel: ['close label', { ns: 'os' }],
-            },
-          }),
-        ),
-      ),
-    [dispatch],
-  );
-
-  return <FeedbackForm onSave={handleSave} />;
-};

package/src/components/ObservabilitySettings.tsx

@@ -1,49 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import React from 'react';
-
-import { createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
-import { Input, Message, useTranslation } from '@dxos/react-ui';
-import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
-
-import { meta } 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(meta.id);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-
-  return (
-    <ControlPage>
-      <ControlSection title={t('settings title', { ns: meta.id })}>
-        <Message.Root valence='info' classNames='container-max-width mbe-cardSpacingBlock'>
-          <Message.Content>{t('observability description')}</Message.Content>
-        </Message.Root>
-        <ControlGroup>
-          <ControlItemInput title={t('observability enabled label')}>
-            <Input.Switch
-              checked={settings.enabled}
-              onCheckedChange={(checked) => dispatch(createIntent(ObservabilityAction.Toggle, { state: !!checked }))}
-            />
-          </ControlItemInput>
-        </ControlGroup>
-      </ControlSection>
-    </ControlPage>
-  );
-};

package/src/events.ts

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