@dxos/app-framework 0.8.2-main.2f9c567 → 0.8.2-main.36232bc

package/dist/types/src/plugin-settings/actions.d.ts

@@ -1,24 +1,24 @@
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 export declare const SETTINGS_PLUGIN = "dxos.org/plugin/settings";
 export declare const SETTINGS_ACTION = "dxos.org/plugin/settings/action";
 export declare const SETTINGS_ID = "!dxos:settings";
 export declare const SETTINGS_KEY = "settings";
 export declare namespace SettingsAction {
-    const Open_base: Schema.TaggedClass<Open, "dxos.org/plugin/settings/action/open", {
-        readonly _tag: Schema.tag<"dxos.org/plugin/settings/action/open">;
+    const Open_base: S.TaggedClass<Open, "dxos.org/plugin/settings/action/open", {
+        readonly _tag: S.tag<"dxos.org/plugin/settings/action/open">;
     } & {
-        input: Schema.Struct<{
-            plugin: Schema.optional<typeof Schema.String>;
+        input: S.Struct<{
+            plugin: S.optional<typeof S.String>;
         }>;
-        output: typeof Schema.Void;
+        output: typeof S.Void;
     }>;
     export class Open extends Open_base {
     }
-    const OpenPluginRegistry_base: Schema.TaggedClass<OpenPluginRegistry, "dxos.org/plugin/settings/action/open-plugin-registry", {
-        readonly _tag: Schema.tag<"dxos.org/plugin/settings/action/open-plugin-registry">;
+    const OpenPluginRegistry_base: S.TaggedClass<OpenPluginRegistry, "dxos.org/plugin/settings/action/open-plugin-registry", {
+        readonly _tag: S.tag<"dxos.org/plugin/settings/action/open-plugin-registry">;
     } & {
-        input: typeof Schema.Void;
-        output: typeof Schema.Void;
+        input: typeof S.Void;
+        output: typeof S.Void;
     }>;
     export class OpenPluginRegistry extends OpenPluginRegistry_base {
     }

package/dist/types/src/plugin-settings/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../src/plugin-settings/actions.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,eAAe,6BAA6B,CAAC;AAC1D,eAAO,MAAM,eAAe,oCAA8B,CAAC;AAG3D,eAAO,MAAM,WAAW,mBAAmB,CAAC;AAC5C,eAAO,MAAM,YAAY,aAAa,CAAC;AAEvC,yBAAiB,cAAc,CAAC;;;;;;;;;IAC9B,MAAM,OAAO,IAAK,SAAQ,SAKxB;KAAG;;;;;;;IAEL,MAAM,OAAO,kBAAmB,SAAQ,uBAMvC;KAAG;;CACL"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../src/plugin-settings/actions.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAC;AAErC,eAAO,MAAM,eAAe,6BAA6B,CAAC;AAC1D,eAAO,MAAM,eAAe,oCAA8B,CAAC;AAG3D,eAAO,MAAM,WAAW,mBAAmB,CAAC;AAC5C,eAAO,MAAM,YAAY,aAAa,CAAC;AAEvC,yBAAiB,cAAc,CAAC;;;;;;;;;IAC9B,MAAM,OAAO,IAAK,SAAQ,SAKxB;KAAG;;;;;;;IAEL,MAAM,OAAO,kBAAmB,SAAQ,uBAMvC;KAAG;;CACL"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/app-framework",
-  "version": "0.8.2-main.2f9c567",
+  "version": "0.8.2-main.36232bc",
   "description": "A framework for building applications from composible plugins.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -38,30 +38,30 @@
   },
   "dependencies": {
     "@preact/signals-core": "^1.6.0",
-    "@dxos/app-graph": "0.8.2-main.2f9c567",
-    "@dxos/client-protocol": "0.8.2-main.2f9c567",
-    "@dxos/debug": "0.8.2-main.2f9c567",
-    "@dxos/artifact": "0.8.2-main.2f9c567",
-    "@dxos/echo-schema": "0.8.2-main.2f9c567",
-    "@dxos/invariant": "0.8.2-main.2f9c567",
-    "@dxos/async": "0.8.2-main.2f9c567",
-    "@dxos/live-object": "0.8.2-main.2f9c567",
-    "@dxos/local-storage": "0.8.2-main.2f9c567",
-    "@dxos/react-hooks": "0.8.2-main.2f9c567",
-    "@dxos/log": "0.8.2-main.2f9c567",
-    "@dxos/util": "0.8.2-main.2f9c567"
+    "@dxos/app-graph": "0.8.2-main.36232bc",
+    "@dxos/artifact": "0.8.2-main.36232bc",
+    "@dxos/async": "0.8.2-main.36232bc",
+    "@dxos/client-protocol": "0.8.2-main.36232bc",
+    "@dxos/debug": "0.8.2-main.36232bc",
+    "@dxos/echo-schema": "0.8.2-main.36232bc",
+    "@dxos/invariant": "0.8.2-main.36232bc",
+    "@dxos/live-object": "0.8.2-main.36232bc",
+    "@dxos/local-storage": "0.8.2-main.36232bc",
+    "@dxos/log": "0.8.2-main.36232bc",
+    "@dxos/react-hooks": "0.8.2-main.36232bc",
+    "@dxos/util": "0.8.2-main.36232bc"
   },
   "devDependencies": {
     "@phosphor-icons/react": "^2.1.5",
     "@types/react": "~18.2.0",
-    "effect": "3.14.21",
+    "effect": "3.13.3",
     "react": "~18.2.0",
     "typedoc": "0.28.1",
-    "@dxos/echo-signals": "0.8.2-main.2f9c567",
-    "@dxos/react-ui": "0.8.2-main.2f9c567",
-    "@dxos/react-ui-syntax-highlighter": "0.8.2-main.2f9c567",
-    "@dxos/random": "0.8.2-main.2f9c567",
-    "@dxos/storybook-utils": "0.8.2-main.2f9c567"
+    "@dxos/echo-signals": "0.8.2-main.36232bc",
+    "@dxos/random": "0.8.2-main.36232bc",
+    "@dxos/react-ui": "0.8.2-main.36232bc",
+    "@dxos/react-ui-syntax-highlighter": "0.8.2-main.36232bc",
+    "@dxos/storybook-utils": "0.8.2-main.36232bc"
   },
   "peerDependencies": {
     "effect": "3.13.3",

package/src/common/capabilities.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import { type Schema as S } from 'effect';
 import { type FC, type PropsWithChildren } from 'react';
 
 import { type GraphBuilder } from '@dxos/app-graph';
@@ -82,7 +82,7 @@ export namespace Capabilities {
   // export type Settings = Parameters<RootSettingsStore['createStore']>[0];
   // export type Settings<T extends SettingsValue = SettingsValue> = SettingsProps<T>;
   export type Settings = {
-    schema: Schema.Schema.All;
+    schema: S.Schema.All;
     prefix: string;
     value?: Record<string, any>;
   };

package/src/common/collaboration.ts

@@ -2,21 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
-import { SchemaAST, Schema } from 'effect';
+import { SchemaAST as AST, Schema as S } from 'effect';
 
 import { Expando, Ref, SpaceIdSchema } from '@dxos/echo-schema';
 
 export namespace CollaborationActions {
-  export class InsertContent extends Schema.TaggedClass<InsertContent>()('assistant/intent-content', {
-    input: Schema.Struct({
+  export class InsertContent extends S.TaggedClass<InsertContent>()('assistant/intent-content', {
+    input: S.Struct({
       spaceId: SpaceIdSchema,
       target: Ref(Expando),
       object: Ref(Expando),
-      label: Schema.String.pipe(Schema.optional),
+      label: S.String.pipe(S.optional),
     }).annotations({
-      [SchemaAST.DescriptionAnnotationId]:
-        'Enables plugins to inject content blocks or references into a related entity.',
+      [AST.DescriptionAnnotationId]: 'Enables plugins to inject content blocks or references into a related entity.',
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 }

package/src/common/file.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 // TODO(burdon): See Accept attribute (uses MIME types).
 // E.g., 'image/*': ['.jpg', '.jpeg', '.png', '.gif'],
@@ -12,11 +12,11 @@ export const defaultFileTypes = {
   text: ['pdf', 'txt', 'md'],
 };
 
-export const FileInfoSchema = Schema.Struct({
-  name: Schema.String,
-  type: Schema.String,
-  url: Schema.optional(Schema.String),
-  cid: Schema.optional(Schema.String), // TODO(burdon): Meta key? Or other common properties with other file management system? (e.g., WNFS).
+export const FileInfoSchema = S.Struct({
+  name: S.String,
+  type: S.String,
+  url: S.optional(S.String),
+  cid: S.optional(S.String), // TODO(burdon): Meta key? Or other common properties with other file management system? (e.g., WNFS).
 });
 
-export type FileInfo = Schema.Schema.Type<typeof FileInfoSchema>;
+export type FileInfo = S.Schema.Type<typeof FileInfoSchema>;

package/src/common/layout.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { Label } from '../plugin-intent';
 
@@ -18,17 +18,17 @@ export namespace LayoutAction {
   /**
    * Generic layout action.
    */
-  export class UpdateLayout extends Schema.TaggedClass<UpdateLayout>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.String.annotations({ description: 'The part of the layout to mutate.' }),
-      subject: Schema.optional(Schema.Any.annotations({ description: 'The subject of the layout update.' })),
-      options: Schema.optional(
-        Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
+  export class UpdateLayout extends S.TaggedClass<UpdateLayout>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.String.annotations({ description: 'The part of the layout to mutate.' }),
+      subject: S.optional(S.Any.annotations({ description: 'The subject of the layout update.' })),
+      options: S.optional(
+        S.Record({ key: S.String, value: S.Any }).annotations({
           description: 'Additional options for the layout action.',
         }),
       ),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
   //
@@ -41,104 +41,98 @@ export namespace LayoutAction {
   //  This allows for plugins to update the layout without depending on a specific layout plugin.
   //  The expectation is that other norms other than these will emerge over time.
 
-  export class SetLayoutMode extends Schema.TaggedClass<SetLayoutMode>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('mode').annotations({ description: 'Setting the layout mode.' }),
-      subject: Schema.optional(
-        Schema.String.annotations({ description: 'Item which is the subject of the new layout mode.' }),
-      ),
-      options: Schema.Union(
-        Schema.Struct({ mode: Schema.String.annotations({ description: 'The new layout mode.' }) }),
-        Schema.Struct({ revert: Schema.Boolean.annotations({ description: 'Revert to the previous layout mode.' }) }),
+  export class SetLayoutMode extends S.TaggedClass<SetLayoutMode>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('mode').annotations({ description: 'Setting the layout mode.' }),
+      subject: S.optional(S.String.annotations({ description: 'Item which is the subject of the new layout mode.' })),
+      options: S.Union(
+        S.Struct({ mode: S.String.annotations({ description: 'The new layout mode.' }) }),
+        S.Struct({ revert: S.Boolean.annotations({ description: 'Revert to the previous layout mode.' }) }),
       ),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class UpdateSidebar extends Schema.TaggedClass<UpdateSidebar>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('sidebar').annotations({ description: 'Updating the sidebar.' }),
-      subject: Schema.optional(
-        Schema.String.annotations({ description: 'URI of the component to display in the sidebar.' }),
-      ),
-      options: Schema.optional(
-        Schema.Struct({
-          state: Schema.Literal('closed', 'collapsed', 'expanded').annotations({
+  export class UpdateSidebar extends S.TaggedClass<UpdateSidebar>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('sidebar').annotations({ description: 'Updating the sidebar.' }),
+      subject: S.optional(S.String.annotations({ description: 'URI of the component to display in the sidebar.' })),
+      options: S.optional(
+        S.Struct({
+          state: S.Literal('closed', 'collapsed', 'expanded').annotations({
             description: 'Whether the sidebar is closed, collapsed, or expanded.',
           }),
         }),
       ),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class UpdateComplementary extends Schema.TaggedClass<UpdateComplementary>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('complementary').annotations({ description: 'Updating the complementary sidebar.' }),
-      subject: Schema.optional(
-        Schema.String.annotations({ description: 'URI of the component to display in the complementary area.' }),
+  export class UpdateComplementary extends S.TaggedClass<UpdateComplementary>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('complementary').annotations({ description: 'Updating the complementary sidebar.' }),
+      subject: S.optional(
+        S.String.annotations({ description: 'URI of the component to display in the complementary area.' }),
       ),
-      options: Schema.optional(
-        Schema.Struct({
-          state: Schema.Literal('closed', 'collapsed', 'expanded').annotations({
+      options: S.optional(
+        S.Struct({
+          state: S.Literal('closed', 'collapsed', 'expanded').annotations({
             description: 'Whether the complementary sidebar is closed, collapsed, or expanded.',
           }),
         }),
       ),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class UpdateDialog extends Schema.TaggedClass<UpdateDialog>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('dialog').annotations({ description: 'Updating the dialog.' }),
-      subject: Schema.optional(
-        Schema.String.annotations({ description: 'URI of the component to display in the dialog.' }),
-      ),
-      options: Schema.Struct({
-        state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the dialog is open or closed.' })),
-        blockAlign: Schema.optional(
-          Schema.Literal('start', 'center', 'end').annotations({ description: 'The alignment of the dialog.' }),
+  export class UpdateDialog extends S.TaggedClass<UpdateDialog>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('dialog').annotations({ description: 'Updating the dialog.' }),
+      subject: S.optional(S.String.annotations({ description: 'URI of the component to display in the dialog.' })),
+      options: S.Struct({
+        state: S.optional(S.Boolean.annotations({ description: 'Whether the dialog is open or closed.' })),
+        blockAlign: S.optional(
+          S.Literal('start', 'center', 'end').annotations({ description: 'The alignment of the dialog.' }),
         ),
-        type: Schema.optional(Schema.Literal('default', 'alert').annotations({ description: 'The type of dialog.' })),
-        props: Schema.optional(
-          Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
+        type: S.optional(S.Literal('default', 'alert').annotations({ description: 'The type of dialog.' })),
+        props: S.optional(
+          S.Record({ key: S.String, value: S.Any }).annotations({
             description: 'Additional props for the dialog.',
           }),
         ),
       }),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class UpdatePopover extends Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }),
-      subject: Schema.optional(
-        Schema.Any.annotations({
+  export class UpdatePopover extends S.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('popover').annotations({ description: 'Updating the popover.' }),
+      subject: S.optional(
+        S.Any.annotations({
           description: 'URI of the component to display in the popover or data to pass to the popover.',
         }),
       ),
-      options: Schema.Struct({
-        side: Schema.optional(
-          Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }),
+      options: S.Struct({
+        side: S.optional(
+          S.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }),
         ),
-        state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })),
-        props: Schema.optional(
-          Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
+        state: S.optional(S.Boolean.annotations({ description: 'Whether the popover is open or closed.' })),
+        props: S.optional(
+          S.Record({ key: S.String, value: S.Any }).annotations({
             description: 'Additional props for the popover.',
           }),
         ),
       }).pipe(
-        Schema.extend(
-          Schema.Union(
-            Schema.Struct({
-              variant: Schema.Literal('virtual'),
-              anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }),
+        S.extend(
+          S.Union(
+            S.Struct({
+              variant: S.Literal('virtual'),
+              anchor: S.Any.annotations({ description: 'The DOM element to anchor the popover to.' }),
             }),
-            Schema.Struct({
-              variant: Schema.optional(Schema.Literal('react')),
-              anchorId: Schema.String.annotations({
+            S.Struct({
+              variant: S.optional(S.Literal('react')),
+              anchorId: S.String.annotations({
                 description: 'An id that can be used to determine whether to render the anchor subcomponent.',
               }),
             }),
@@ -146,125 +140,119 @@ export namespace LayoutAction {
         ),
       ),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export const Toast = Schema.Struct({
-    id: Schema.String.annotations({ description: 'The id of the toast.' }),
-    title: Schema.optional(Label.annotations({ description: 'The title of the toast.' })),
-    description: Schema.optional(Label.annotations({ description: 'The description of the toast.' })),
-    icon: Schema.optional(Schema.String.annotations({ description: 'The icon of the toast.' })),
-    duration: Schema.optional(Schema.Number.annotations({ description: 'The duration of the toast.' })),
-    closeLabel: Schema.optional(Label.annotations({ description: 'The label of the close button.' })),
-    actionLabel: Schema.optional(Label.annotations({ description: 'The label of the action button.' })),
-    actionAlt: Schema.optional(Label.annotations({ description: 'The alt text of the action button.' })),
-    onAction: Schema.optional(
-      Schema.Any.annotations({ description: 'The action to perform when the action button is clicked.' }),
+  export const Toast = S.Struct({
+    id: S.String.annotations({ description: 'The id of the toast.' }),
+    title: S.optional(Label.annotations({ description: 'The title of the toast.' })),
+    description: S.optional(Label.annotations({ description: 'The description of the toast.' })),
+    icon: S.optional(S.String.annotations({ description: 'The icon of the toast.' })),
+    duration: S.optional(S.Number.annotations({ description: 'The duration of the toast.' })),
+    closeLabel: S.optional(Label.annotations({ description: 'The label of the close button.' })),
+    actionLabel: S.optional(Label.annotations({ description: 'The label of the action button.' })),
+    actionAlt: S.optional(Label.annotations({ description: 'The alt text of the action button.' })),
+    onAction: S.optional(
+      S.Any.annotations({ description: 'The action to perform when the action button is clicked.' }),
     ),
   });
 
-  export interface Toast extends Omit<Schema.Schema.Type<typeof Toast>, 'onAction'> {
+  export interface Toast extends Omit<S.Schema.Type<typeof Toast>, 'onAction'> {
     onAction?: () => void;
   }
 
-  export class AddToast extends Schema.TaggedClass<AddToast>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('toast').annotations({ description: 'Adding a toast.' }),
+  export class AddToast extends S.TaggedClass<AddToast>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('toast').annotations({ description: 'Adding a toast.' }),
       subject: Toast.annotations({ description: 'The toast to add.' }),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class SwitchWorkspace extends Schema.TaggedClass<SwitchWorkspace>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('workspace').annotations({ description: 'Switching the workspace.' }),
-      subject: Schema.String.annotations({ description: 'The id of the workspace to switch to.' }),
+  export class SwitchWorkspace extends S.TaggedClass<SwitchWorkspace>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('workspace').annotations({ description: 'Switching the workspace.' }),
+      subject: S.String.annotations({ description: 'The id of the workspace to switch to.' }),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class RevertWorkspace extends Schema.TaggedClass<RevertWorkspace>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('workspace').annotations({ description: 'Switching the workspace.' }),
-      options: Schema.Struct({
-        revert: Schema.Literal(true).annotations({ description: 'Revert to the previous workspace.' }),
+  export class RevertWorkspace extends S.TaggedClass<RevertWorkspace>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('workspace').annotations({ description: 'Switching the workspace.' }),
+      options: S.Struct({
+        revert: S.Literal(true).annotations({ description: 'Revert to the previous workspace.' }),
       }),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class Open extends Schema.TaggedClass<Open>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('main').annotations({ description: 'Opening an item in the main content area.' }),
-      subject: Schema.Array(Schema.String.annotations({ description: 'Ids of the items to open.' })),
-      options: Schema.optional(
-        Schema.Struct({
-          state: Schema.optional(Schema.Literal(true).annotations({ description: 'The items are being added.' })),
-          variant: Schema.optional(Schema.String.annotations({ description: 'The variant of the item to open.' })),
-          key: Schema.optional(
-            Schema.String.annotations({
-              description: 'If provided, will replace item with a matching key (id prefix).',
-            }),
-          ),
-          workspace: Schema.optional(Schema.String.annotations({ description: 'The workspace to open the items in.' })),
-          scrollIntoView: Schema.optional(Schema.Boolean.annotations({ description: 'Scroll the items into view.' })),
-          pivotId: Schema.optional(
-            Schema.String.annotations({ description: 'The id of the item to place new items next to.' }),
+  export class Open extends S.TaggedClass<Open>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('main').annotations({ description: 'Opening an item in the main content area.' }),
+      subject: S.Array(S.String.annotations({ description: 'Ids of the items to open.' })),
+      options: S.optional(
+        S.Struct({
+          state: S.optional(S.Literal(true).annotations({ description: 'The items are being added.' })),
+          variant: S.optional(S.String.annotations({ description: 'The variant of the item to open.' })),
+          key: S.optional(
+            S.String.annotations({ description: 'If provided, will replace item with a matching key (id prefix).' }),
           ),
-          positioning: Schema.optional(
-            Schema.Union(
-              Schema.Literal('start').annotations({ description: 'The items are being added before the pivot item.' }),
-              Schema.Literal('end').annotations({ description: 'The items are being added after the pivot item.' }),
+          workspace: S.optional(S.String.annotations({ description: 'The workspace to open the items in.' })),
+          scrollIntoView: S.optional(S.Boolean.annotations({ description: 'Scroll the items into view.' })),
+          pivotId: S.optional(S.String.annotations({ description: 'The id of the item to place new items next to.' })),
+          positioning: S.optional(
+            S.Union(
+              S.Literal('start').annotations({ description: 'The items are being added before the pivot item.' }),
+              S.Literal('end').annotations({ description: 'The items are being added after the pivot item.' }),
             ),
           ),
         }),
       ),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class Set extends Schema.TaggedClass<Set>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('main').annotations({ description: 'Setting items in the main content area.' }),
-      subject: Schema.Array(Schema.String.annotations({ description: 'Ids of the items to set.' })),
-      options: Schema.Struct({
-        override: Schema.Literal(true).annotations({
-          description: 'Override the current items in the main content area.',
-        }),
+  export class Set extends S.TaggedClass<Set>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('main').annotations({ description: 'Setting items in the main content area.' }),
+      subject: S.Array(S.String.annotations({ description: 'Ids of the items to set.' })),
+      options: S.Struct({
+        override: S.Literal(true).annotations({ description: 'Override the current items in the main content area.' }),
       }),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class Close extends Schema.TaggedClass<Close>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('main').annotations({ description: 'Closing items in the main content area.' }),
-      subject: Schema.Array(Schema.String.annotations({ description: 'Ids of the items to close.' })),
-      options: Schema.Struct({
-        state: Schema.Literal(false).annotations({ description: 'The items are being removed.' }),
+  export class Close extends S.TaggedClass<Close>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('main').annotations({ description: 'Closing items in the main content area.' }),
+      subject: S.Array(S.String.annotations({ description: 'Ids of the items to close.' })),
+      options: S.Struct({
+        state: S.Literal(false).annotations({ description: 'The items are being removed.' }),
       }),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class ScrollIntoView extends Schema.TaggedClass<ScrollIntoView>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('current').annotations({ description: 'Setting the current item' }),
-      subject: Schema.optional(Schema.String.annotations({ description: 'The id of the item to set as current.' })),
-      options: Schema.optional(
-        Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
+  export class ScrollIntoView extends S.TaggedClass<ScrollIntoView>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('current').annotations({ description: 'Setting the current item' }),
+      subject: S.optional(S.String.annotations({ description: 'The id of the item to set as current.' })),
+      options: S.optional(
+        S.Record({ key: S.String, value: S.Any }).annotations({
           description: 'Additional options for the scroll into view.',
         }),
       ),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 
-  export class Expose extends Schema.TaggedClass<Expose>()(UPDATE_LAYOUT, {
-    input: Schema.Struct({
-      part: Schema.Literal('navigation').annotations({ description: 'Exposing an item in the navigation area.' }),
-      subject: Schema.String.annotations({ description: 'The id of the item to expose.' }),
+  export class Expose extends S.TaggedClass<Expose>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('navigation').annotations({ description: 'Exposing an item in the navigation area.' }),
+      subject: S.String.annotations({ description: 'The id of the item to expose.' }),
     }),
-    output: Schema.Void,
+    output: S.Void,
   }) {}
 }

package/src/common/translations.ts

@@ -2,16 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
-export const ResourceKey = Schema.Union(Schema.String, Schema.Record({ key: Schema.String, value: Schema.Any }));
-export type ResourceKey = Schema.Schema.Type<typeof ResourceKey>;
+export const ResourceKey = S.Union(S.String, S.Record({ key: S.String, value: S.Any }));
+export type ResourceKey = S.Schema.Type<typeof ResourceKey>;
 
-export const ResourceLanguage = Schema.Record({ key: Schema.String, value: ResourceKey });
-export type ResourceLanguage = Schema.Schema.Type<typeof ResourceLanguage>;
+export const ResourceLanguage = S.Record({ key: S.String, value: ResourceKey });
+export type ResourceLanguage = S.Schema.Type<typeof ResourceLanguage>;
 
 /**
  * A resource is a collection of translations for a language.
  */
-export const Resource = Schema.Record({ key: Schema.String, value: ResourceLanguage });
-export type Resource = Schema.Schema.Type<typeof Resource>;
+export const Resource = S.Record({ key: S.String, value: ResourceLanguage });
+export type Resource = S.Schema.Type<typeof Resource>;

package/src/playground/generator/generator.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { Capabilities, Events } from '../../common';
 import { contributes, defineEvent, defineCapability, defineModule, definePlugin } from '../../core';
@@ -15,9 +15,9 @@ export const CountEvent = defineEvent('dxos.org/test/generator/count');
 export const createPluginId = (id: string) => `dxos.org/test/generator/${id}`;
 
 export const createGeneratorIntent = (id: string) => {
-  class Alert extends Schema.TaggedClass<Alert>()(`${createPluginId(id)}/action/alert`, {
-    input: Schema.Void,
-    output: Schema.Void,
+  class Alert extends S.TaggedClass<Alert>()(`${createPluginId(id)}/action/alert`, {
+    input: S.Void,
+    output: S.Void,
   }) {}
 
   return Alert as unknown as IntentSchema<any, any>;

package/src/playground/logger/schema.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
-export class Log extends Schema.TaggedClass<Log>()('dxos.org/test/logger/log', {
-  input: Schema.Struct({
-    message: Schema.String,
+export class Log extends S.TaggedClass<Log>()('dxos.org/test/logger/log', {
+  input: S.Struct({
+    message: S.String,
   }),
-  output: Schema.Void,
+  output: S.Void,
 }) {}