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

package/src/hooks/useActiveSpace.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, useLayout, type PluginContext } from '@dxos/app-framework';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { parseId, useSpace } from '@dxos/react-client/echo';
+
+export const getActiveSpace = (context: PluginContext) => {
+  const layout = context.getCapability(Capabilities.Layout);
+  const client = context.getCapability(ClientCapabilities.Client);
+  const { spaceId } = parseId(layout.workspace);
+  return spaceId ? client.spaces.get(spaceId) : undefined;
+};
+
+export const useActiveSpace = () => {
+  const layout = useLayout();
+  const { spaceId } = parseId(layout.workspace);
+  return useSpace(spaceId);
+};

package/src/hooks/useInputSurfaceLookup.tsx

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Schema } from 'effect';
+import React, { useCallback } from 'react';
+
+import { usePluginManager, isSurfaceAvailable, Surface } from '@dxos/app-framework';
+import { type InputProps } from '@dxos/react-ui-form';
+
+// TODO(ZaymonFC): Move this if you find yourself needing it elsewhere.
+/**
+ * Creates a surface input component based on plugin context.
+ * @param baseData Additional data that will be merged with form data and passed to the surface.
+ * This allows providing more context to the surface than what's available from the form itself.
+ */
+export const useInputSurfaceLookup = (baseData?: Record<string, any>) => {
+  const pluginManager = usePluginManager();
+
+  return useCallback(
+    ({ prop, schema, inputProps }: { prop: string; schema: Schema.Schema<any>; inputProps: InputProps }) => {
+      const composedData = { prop, schema, ...baseData };
+      if (!isSurfaceAvailable(pluginManager.context, { role: 'form-input', data: composedData })) {
+        return undefined;
+      }
+
+      return <Surface role='form-input' data={composedData} {...inputProps} />;
+    },
+    [pluginManager, baseData],
+  );
+};

package/src/hooks/usePath.ts

@@ -2,9 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Option } from 'effect';
 import { useEffect, useState } from 'react';
 
-import { type Graph } from '@dxos/plugin-graph';
+import { type ReadableGraph } from '@dxos/plugin-graph';
 
 /**
  * React hook to get a path from the graph.
@@ -15,15 +16,17 @@ import { type Graph } from '@dxos/plugin-graph';
  * @returns Path if found, undefined otherwise.
  */
 // TODO(wittjosiah): Factor out.
-export const usePath = (graph: Graph, id?: string, timeout?: number): string[] | undefined => {
-  const [pathState, setPathState] = useState<string[] | undefined>(id ? graph.getPath({ target: id }) : undefined);
+export const usePath = (graph: ReadableGraph, id?: string, timeout?: number): Option.Option<string[]> => {
+  const [pathState, setPathState] = useState<Option.Option<string[]>>(
+    id ? graph.getPath({ target: id }) : Option.none(),
+  );
 
   useEffect(() => {
     if (!id && pathState) {
-      setPathState(undefined);
+      setPathState(Option.none());
     }
 
-    if (pathState?.at(-1) === id || !id) {
+    if ((Option.isSome(pathState) && pathState.value.at(-1) === id) || !id) {
       return;
     }
 
@@ -32,7 +35,7 @@ export const usePath = (graph: Graph, id?: string, timeout?: number): string[] |
       try {
         const path = await graph.waitForPath({ target: id }, { timeout });
         if (path) {
-          setPathState(path);
+          setPathState(Option.some(path));
         }
       } catch {}
     });

package/src/index.ts

@@ -2,10 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-export { SpaceCapabilities, ThreadCapabilities } from './capabilities';
-export { SpaceEvents, ThreadEvents } from './events';
+export { SpaceCapabilities } from './capabilities';
+export { SpaceEvents } from './events';
 
 export * from './components';
+export * from './hooks';
 export * from './meta';
 export * from './SpacePlugin';
 export * from './util';

package/src/translations.ts

@@ -15,7 +15,6 @@ export default [
       [SPACE_PLUGIN]: {
         'plugin name': 'Spaces',
         'first run message': 'Nothing selected.',
-        'add space label': 'Create or join a space',
         'create space label': 'Create space',
         'join space label': 'Join space',
         'empty space message': 'No documents',
@@ -34,7 +33,7 @@ export default [
         'export data label': 'Export data',
         'import data label': 'Import data',
         'migrate space label': 'Migrate space',
-        'share space': 'Share space',
+        'share space label': 'Share current space',
         'save space to disk label': 'Save to disk',
         'load space from disk label': 'Load from disk',
         'confirm restore title': 'Overwrite files in this space?',
@@ -43,7 +42,7 @@ export default [
         'object placeholder': 'Type a title here…',
         'personal space label': 'Personal Space',
         'spaces label': 'Spaces',
-        'show hidden spaces label': 'Show closed spaces',
+        'show hidden spaces label': 'Show archived spaces',
         'save files to directory label': 'Save files to disk',
         'select path label': 'Select path',
         'rename collection label': 'Rename collection',
@@ -67,7 +66,6 @@ export default [
           'The requested object has not been found yet. Ensure there are enough peers online in the space with an updated copy.',
         'create object in space label': 'Add to space',
         'create object in collection label': 'Add to collection',
-        'share space label': 'Share',
         'space members label': 'Space members',
         'active space members heading': 'Online ({{count}})',
         'inactive space members heading': 'Offline ({{count}})',
@@ -96,7 +94,7 @@ export default [
         'join success label': 'Successfully joined space',
         'name label': 'Name',
         'name placeholder': 'Name',
-        'object settings label': 'Settings',
+        'object settings label': 'Details',
         'edge replication label': 'Enable EDGE Replication',
         'saving locally label': 'Writing to disk',
         'downloading label': 'Replicating from peers',
@@ -118,6 +116,7 @@ export default [
         'advanced settings label': 'Advanced',
         'foreign keys': 'Foreign Keys',
         'add key': 'Add Key',
+        'open space settings label': 'Open',
 
         'members panel label': 'Members',
         'members verbose label': 'Manage space members',
@@ -126,16 +125,29 @@ export default [
         'invitations label': 'Invitations',
         'space invitation description': 'Manage invitations to the space.',
         'qr code description': 'Share this QR code, or copy the URL and share it with the person you want to invite.',
+        'locked space description': 'This space is locked, unlock it to invite new members.',
+        'space locked label': 'Lock space',
+        'space locked description': 'Locking a space prevents new members from being invited to the space.',
 
         'settings panel label': 'Space Settings',
-        'open space settings label': 'Space Settings',
-        'space settings properties label': 'General',
+        'open current space settings label': 'Open current space settings',
+        'space settings properties label': 'General settings',
+        'space properties settings verbose label': 'Manage space properties',
+        'space properties settings description': 'You can configure how this space is displayed in the app here.',
+        'space settings schema label': 'Schema',
+        'schema verbose label': 'Manage schema',
+        'schema description': 'You can manage all of the schema stored within this space here.',
+        'no schemas found message': 'No schemas found',
         'display name input placeholder': 'Space name',
         'display name description': 'Name of the space as it appears in the app.',
         'icon description': 'Icon used to represent the space in the app.',
         'hue description': 'Color used to represent the space in the app.',
         'edge replication description':
           "Only change this if you know what you're doing. Disabling this will prevent the space from replicating through Composer's EDGE services, and relies solely on peer-to-peer sync.",
+        'archive space description':
+          'Archiving a space will remove it from the sidebar and stop replicating updates, but will not delete the data. You can unarchive it by enabling archived spaces in the app settings.',
+        'archive space label': 'Archive',
+        'unarchive space label': 'Unarchive',
       },
     },
   },

package/src/types/collection.ts

@@ -2,15 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Expando, Ref, S, TypedObject } from '@dxos/echo-schema';
+import { Schema } from 'effect';
+
+import { Expando, Ref, TypedObject } from '@dxos/echo-schema';
 
 export class CollectionType extends TypedObject({ typename: 'dxos.org/type/Collection', version: '0.1.0' })({
-  name: S.optional(S.String),
-  objects: S.mutable(S.Array(Ref(Expando))),
+  name: Schema.optional(Schema.String),
+  objects: Schema.mutable(Schema.Array(Ref(Expando))),
   // Key is schema typename and value is reference to a view object of the associated schema.
   // Having collection reference the views rather than vice versa ensures that the state converges to a single view per key (i.e. type).
   // This also leaves open a future where this key could be changed to allow for multiple stack views per section.
   // TODO(wittjosiah): Any way to make this more type safe?
   // TODO(wittjosiah): Should the views be separate objects or just be schemas for view data in this record?
-  views: S.mutable(S.Record({ key: S.String, value: Ref(Expando) })),
+  views: Schema.mutable(Schema.Record({ key: Schema.String, value: Ref(Expando) })),
 }) {}

package/src/types/index.ts

@@ -3,5 +3,4 @@
 //
 
 export * from './collection';
-export * from './thread';
 export * from './types';

package/src/types/types.ts

@@ -2,17 +2,21 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Schema } from 'effect';
+
 import { type AnyIntentChain } from '@dxos/app-framework';
-import { S, type Expando, type BaseObject, type TypedObject } from '@dxos/echo-schema';
+import { Expando, type BaseObject, type TypedObject } from '@dxos/echo-schema';
 import { type PublicKey } from '@dxos/react-client';
 // TODO(wittjosiah): This pulls in full client.
 import { EchoObjectSchema, ReactiveObjectSchema, type Space, SpaceSchema } from '@dxos/react-client/echo';
+import { CancellableInvitationObservable, Invitation } from '@dxos/react-client/invitations';
 import { type ComplexMap } from '@dxos/util';
 
 import { CollectionType } from './collection';
 import { SPACE_PLUGIN } from '../meta';
 
 export const SPACE_DIRECTORY_HANDLE = 'dxos.org/plugin/space/directory';
+export const SPACE_TYPE = 'dxos.org/type/Space';
 
 export type ObjectViewerProps = {
   lastSeen: number;
@@ -42,11 +46,6 @@ export type PluginState = {
    */
   spaceNames: Record<string, string>;
 
-  /**
-   * Which sections of the space settings are open.
-   */
-  spaceSettingsOpenSections: string[];
-
   /**
    * Which spaces have an SDK migration running currently.
    */
@@ -66,16 +65,16 @@ export type PluginState = {
   enabledEdgeReplication: boolean;
 };
 
-export const SpaceSettingsSchema = S.mutable(
-  S.Struct({
+export const SpaceSettingsSchema = Schema.mutable(
+  Schema.Struct({
     /**
      * Show closed spaces.
      */
-    showHidden: S.Boolean,
+    showHidden: Schema.Boolean,
   }),
 );
 
-export type SpaceSettingsProps = S.Schema.Type<typeof SpaceSettingsSchema>;
+export type SpaceSettingsProps = Schema.Schema.Type<typeof SpaceSettingsSchema>;
 
 // TODO(wittjosiah): Reconcile with graph export serializers.
 
@@ -92,18 +91,22 @@ export interface TypedObjectSerializer<T extends Expando = Expando> {
   deserialize(params: { content: string; space: Space; newId?: boolean }): Promise<T>;
 }
 
-export const SpaceForm = S.Struct({
-  name: S.optional(S.String.annotations({ title: 'Name' })),
-  icon: S.optional(S.String.annotations({ title: 'Icon' })),
-  hue: S.optional(S.String.annotations({ title: 'Color' })),
+// TODO(burdon): Move to FormatEnum or SDK.
+export const IconAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Icon');
+export const HueAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Hue');
+
+export const SpaceForm = Schema.Struct({
+  name: Schema.optional(Schema.String.annotations({ title: 'Name' })),
+  icon: Schema.optional(Schema.String.annotations({ title: 'Icon', [IconAnnotationId]: true })),
+  hue: Schema.optional(Schema.String.annotations({ title: 'Color', [HueAnnotationId]: true })),
   // TODO(wittjosiah): Make optional with default value.
-  edgeReplication: S.Boolean.annotations({ title: 'Enable EDGE Replication' }),
+  edgeReplication: Schema.Boolean.annotations({ title: 'Enable EDGE Replication' }),
 });
 
 export type ObjectForm<T extends BaseObject = BaseObject> = {
-  // TODO(dmaretskyi): Change to S.Schema.AnyNoContext
+  // TODO(dmaretskyi): Change to Schema.Schema.AnyNoContext
   objectSchema: TypedObject;
-  formSchema?: S.Schema<T, any>;
+  formSchema?: Schema.Schema<T, any>;
   hidden?: boolean;
   getIntent: (props: T, options: { space: Space }) => AnyIntentChain;
 };
@@ -113,165 +116,191 @@ export const defineObjectForm = <T extends BaseObject>(form: ObjectForm<T>) => f
 export const SPACE_ACTION = `${SPACE_PLUGIN}/action`;
 
 export namespace SpaceAction {
-  export class OpenCreateSpace extends S.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
-    input: S.Void,
-    output: S.Void,
+  export class OpenCreateSpace extends Schema.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
+    input: Schema.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Create extends S.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
+  export class Create extends Schema.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
     input: SpaceForm,
-    output: S.Struct({
-      id: S.String,
-      subject: S.Array(S.String),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
       space: SpaceSchema,
     }),
   }) {}
 
-  export class Join extends S.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
-    input: S.Struct({
-      invitationCode: S.optional(S.String),
-      onDone: S.optional(S.Any),
+  export class Join extends Schema.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
+    input: Schema.Struct({
+      invitationCode: Schema.optional(Schema.String),
+      onDone: Schema.optional(Schema.Any),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Share extends S.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
-    input: S.Struct({
+  export class OpenMembers extends Schema.TaggedClass<OpenMembers>()(`${SPACE_ACTION}/open-members`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Lock extends S.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
-    input: S.Struct({
+  export class Share extends Schema.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
+    input: Schema.Struct({
       space: SpaceSchema,
+      type: Schema.Enums(Invitation.Type),
+      authMethod: Schema.Enums(Invitation.AuthMethod),
+      multiUse: Schema.Boolean,
+      target: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.instanceOf(CancellableInvitationObservable),
   }) {}
 
-  export class Unlock extends S.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
-    input: S.Struct({
+  export class GetShareLink extends Schema.TaggedClass<GetShareLink>()(`${SPACE_ACTION}/get-share-link`, {
+    input: Schema.Struct({
       space: SpaceSchema,
+      target: Schema.optional(Schema.String),
+      copyToClipboard: Schema.optional(Schema.Boolean),
     }),
-    output: S.Void,
+    output: Schema.String,
   }) {}
 
-  export class Rename extends S.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
-    input: S.Struct({
+  export class Lock extends Schema.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      caller: S.optional(S.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class AddSpace extends S.TaggedClass<AddSpace>()(`${SPACE_ACTION}/add-space`, {
-    input: S.Void,
-    output: S.Void,
+  export class Unlock extends Schema.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
+    input: Schema.Struct({
+      space: SpaceSchema,
+    }),
+    output: Schema.Void,
   }) {}
 
-  export class AddSpaceMenuGroup extends S.TaggedClass<AddSpaceMenuGroup>()(`${SPACE_ACTION}/add-space-menu-group`, {
-    input: S.Void,
-    output: S.Void,
+  export class Rename extends Schema.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
+    input: Schema.Struct({
+      space: SpaceSchema,
+      caller: Schema.optional(Schema.String),
+    }),
+    output: Schema.Void,
   }) {}
 
   // TODO(wittjosiah): Handle scrolling to section.
-  export class OpenSettings extends S.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
-    input: S.Struct({ space: SpaceSchema }),
-    output: S.Void,
+  //   This maybe motivates making the space settings its own deck?
+  export class OpenSettings extends Schema.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
+    input: Schema.Struct({ space: SpaceSchema }),
+    output: Schema.Void,
   }) {}
 
-  export class Open extends S.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
-    input: S.Struct({
+  export class Open extends Schema.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Close extends S.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
-    input: S.Struct({
+  export class Close extends Schema.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Migrate extends S.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
-    input: S.Struct({
+  export class Migrate extends Schema.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      version: S.optional(S.String),
+      version: Schema.optional(Schema.String),
     }),
-    output: S.Boolean,
+    output: Schema.Boolean,
   }) {}
 
-  export class OpenCreateObject extends S.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
-    input: S.Struct({
-      target: S.Union(SpaceSchema, CollectionType),
-      navigable: S.optional(S.Boolean),
+  export class OpenCreateObject extends Schema.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
+    input: Schema.Struct({
+      target: Schema.Union(SpaceSchema, CollectionType),
+      navigable: Schema.optional(Schema.Boolean),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class AddObject extends S.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
-    input: S.Struct({
+  export class AddObject extends Schema.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
+    input: Schema.Struct({
       object: ReactiveObjectSchema,
-      target: S.Union(SpaceSchema, CollectionType),
-      hidden: S.optional(S.Boolean),
+      target: Schema.Union(SpaceSchema, CollectionType),
+      hidden: Schema.optional(Schema.Boolean),
     }),
-    output: S.Struct({
-      id: S.String,
-      subject: S.Array(S.String),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
       object: EchoObjectSchema,
     }),
   }) {}
 
-  export const DeletionData = S.Struct({
-    objects: S.Array(EchoObjectSchema),
+  export class AddRelation extends Schema.TaggedClass<AddRelation>()(`${SPACE_ACTION}/add-relation`, {
+    input: Schema.Struct({
+      space: SpaceSchema,
+      // TODO(wittjosiah): Relation schema.
+      schema: Schema.Any,
+      source: Expando,
+      target: Expando,
+      // TODO(wittjosiah): Type based on relation schema.
+      fields: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+    }),
+    output: Schema.Struct({
+      relation: Schema.Any,
+    }),
+  }) {}
+
+  export const DeletionData = Schema.Struct({
+    objects: Schema.Array(EchoObjectSchema),
     parentCollection: CollectionType,
-    indices: S.Array(S.Number),
-    nestedObjectsList: S.Array(S.Array(EchoObjectSchema)),
-    wasActive: S.Array(S.String),
+    indices: Schema.Array(Schema.Number),
+    nestedObjectsList: Schema.Array(Schema.Array(EchoObjectSchema)),
+    wasActive: Schema.Array(Schema.String),
   });
 
-  export type DeletionData = S.Schema.Type<typeof DeletionData>;
+  export type DeletionData = Schema.Schema.Type<typeof DeletionData>;
 
-  export class RemoveObjects extends S.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
-    input: S.Struct({
-      objects: S.Array(EchoObjectSchema),
-      target: S.optional(CollectionType),
-      deletionData: S.optional(DeletionData),
+  export class RemoveObjects extends Schema.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
+    input: Schema.Struct({
+      objects: Schema.Array(EchoObjectSchema),
+      target: Schema.optional(CollectionType),
+      deletionData: Schema.optional(DeletionData),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class RenameObject extends S.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
-    input: S.Struct({
+  export class RenameObject extends Schema.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
+    input: Schema.Struct({
       object: EchoObjectSchema,
-      caller: S.optional(S.String),
+      caller: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class DuplicateObject extends S.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
-    input: S.Struct({
+  export class DuplicateObject extends Schema.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
+    input: Schema.Struct({
       object: EchoObjectSchema,
-      target: S.Union(SpaceSchema, CollectionType),
+      target: Schema.Union(SpaceSchema, CollectionType),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class WaitForObject extends S.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
-    input: S.Struct({
-      id: S.optional(S.String),
+  export class WaitForObject extends Schema.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
+    input: Schema.Struct({
+      id: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 }
 
 export namespace CollectionAction {
-  export class Create extends S.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
-    input: S.Struct({
-      name: S.optional(S.String),
+  export class Create extends Schema.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
+    input: Schema.Struct({
+      name: Schema.optional(Schema.String),
     }),
-    output: S.Struct({
+    output: Schema.Struct({
       object: CollectionType,
     }),
   }) {}