@dxos/plugin-observability 0.8.4-main.f5c0578 → 0.8.4-main.fcc0d83b33

package/dist/lib/node-esm/state-LKANNCJJ.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/capabilities/state.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { contributes } from '@dxos/app-framework';\nimport { LocalStorageStore } from '@dxos/local-storage';\nimport { getObservabilityGroup } from '@dxos/observability';\n\nimport { OBSERVABILITY_PLUGIN } from '../meta';\n\nimport { ObservabilityCapabilities } from './capabilities';\n\nexport default async ({ namespace }: { namespace: string }) => {\n  const state = new LocalStorageStore<ObservabilityCapabilities.State>(OBSERVABILITY_PLUGIN);\n\n  state.prop({ key: 'notified', type: LocalStorageStore.bool({ allowUndefined: true }) });\n\n  // NOTE: This is not stored in local storage such that it can be accessed by workers.\n  state.values.group = await getObservabilityGroup(namespace);\n\n  return contributes(ObservabilityCapabilities.State, state.values, () => state.close());\n};\n"],
-  "mappings": ";;;;;;;;;AAIA,SAASA,mBAAmB;AAC5B,SAASC,yBAAyB;AAClC,SAASC,6BAA6B;AAMtC,IAAA,gBAAe,OAAO,EAAEC,UAAS,MAAyB;AACxD,QAAMC,QAAQ,IAAIC,kBAAmDC,oBAAAA;AAErEF,QAAMG,KAAK;IAAEC,KAAK;IAAYC,MAAMJ,kBAAkBK,KAAK;MAAEC,gBAAgB;IAAK,CAAA;EAAG,CAAA;AAGrFP,QAAMQ,OAAOC,QAAQ,MAAMC,sBAAsBX,SAAAA;AAEjD,SAAOY,YAAYC,0BAA0BC,OAAOb,MAAMQ,QAAQ,MAAMR,MAAMc,MAAK,CAAA;AACrF;",
-  "names": ["contributes", "LocalStorageStore", "getObservabilityGroup", "namespace", "state", "LocalStorageStore", "OBSERVABILITY_PLUGIN", "prop", "key", "type", "bool", "allowUndefined", "values", "group", "getObservabilityGroup", "contributes", "ObservabilityCapabilities", "State", "close"]
-}

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

@@ -1,12 +0,0 @@
-import { type Client } from '@dxos/client';
-import { type Observability } from '@dxos/observability';
-export declare namespace ObservabilityCapabilities {
-    type State = {
-        group?: string;
-        notified?: boolean;
-    };
-    const State: import("@dxos/app-framework").InterfaceDef<State>;
-    const Observability: import("@dxos/app-framework").InterfaceDef<Observability>;
-}
-export declare const ClientCapability: import("@dxos/app-framework").InterfaceDef<Client>;
-//# sourceMappingURL=capabilities.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/capabilities/capabilities.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,yBAAiB,yBAAyB,CAAC;IACzC,KAAY,KAAK,GAAG;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;IACK,MAAM,KAAK,mDAAsE,CAAC;IAElF,MAAM,aAAa,2DAAsF,CAAC;CAClH;AAGD,eAAO,MAAM,gBAAgB,oDAAuE,CAAC"}

package/dist/types/src/capabilities/intent-resolver.d.ts

@@ -1,7 +0,0 @@
-import { Capabilities, type PluginContext } from '@dxos/app-framework';
-declare const _default: ({ context, namespace }: {
-    context: PluginContext;
-    namespace: string;
-}) => import("@dxos/app-framework").Capability<Capabilities.IntentResolver>;
-export default _default;
-//# sourceMappingURL=intent-resolver.d.ts.map

package/dist/types/src/capabilities/intent-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"intent-resolver.d.ts","sourceRoot":"","sources":["../../../../src/capabilities/intent-resolver.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAgB,KAAK,aAAa,EAA+B,MAAM,qBAAqB,CAAC;yBAUlG,wBAAwB;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;AAArF,wBAsDK"}

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

@@ -1,6 +0,0 @@
-import React from 'react';
-import { UserFeedback } from '../types';
-export declare const FeedbackForm: ({ onSave }: {
-    onSave: (values: UserFeedback) => void;
-}) => React.JSX.Element;
-//# sourceMappingURL=FeedbackForm.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"FeedbackForm.d.ts","sourceRoot":"","sources":["../../../../src/components/FeedbackForm.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAwC,MAAM,OAAO,CAAC;AAO7D,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AA+CxC,eAAO,MAAM,YAAY,GAAI,YAAY;IAAE,MAAM,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAA;CAAE,sBAuBlF,CAAC"}

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;AAS3C,eAAO,MAAM,aAAa,yBA0BzB,CAAC"}

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

@@ -1,10 +0,0 @@
-import { Schema } from 'effect';
-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,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,MAAM,OAAO,CAAC;AAS1B,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,+CAAgD,CAAC;CACzE;AAGD,eAAO,MAAM,gBAAgB,+CAA2D,CAAC"}

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/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} />;
-};