@playfast/reform-remote 1.1.0 → 1.3.0

package/src/react.ts

@@ -1,12 +1,23 @@
-import { type ReactNode, useEffect, useState, useSyncExternalStore } from 'react'
-import { connect, type InvokeMessage, type RemoteTransport, type ServerMessage } from './transport'
+import { Option } from 'effect'
+import { type ReactNode, useEffect, useRef, useSyncExternalStore } from 'react'
+import {
+  type ClientBinding,
+  connect,
+  type InvokeMessage,
+  type RemoteTransport,
+  type ServerMessage,
+} from './transport'
 import type { RemoteContract, RemoteViewSet } from './client'
 
 export const useRemoteUI = <C extends RemoteContract>(
   transport: RemoteTransport<InvokeMessage, ServerMessage>,
   views: RemoteViewSet<C>,
 ): ReactNode => {
-  const [binding] = useState(() => connect({ transport, views }))
+  // A ref, not `useState`: StrictMode double-invokes a state initializer, and the
+  // binding React discards would keep its transport subscription for good.
+  const held = useRef<Option.Option<ClientBinding>>(Option.none())
+  const binding = Option.getOrElse(held.current, () => connect({ transport, views }))
+  held.current = Option.some(binding)
   useEffect(() => () => binding.dispose(), [binding])
   useSyncExternalStore(binding.subscribe, binding.snapshot, binding.snapshot)
   return binding.node()

package/src/server.test.ts

@@ -231,7 +231,7 @@ test('a list renders one child per item under a single slot, in order', async ()
     expect(byId(tree, '0.Bar.0')!.slot).toBe('Bar')
 
     const items = Wire.childrenOf(tree, '0').filter((node) => node.slot === 'Item')
-    expect(items.map((node) => node.id)).toEqual(['0.Item.0', '0.Item.1'])
+    expect(items.map((node) => node.id)).toEqual(['0.Item.a', '0.Item.b'])
     expect(items.map((node) => node.childIndex)).toEqual([0, 1])
     expect(dataOf(items[0]!, 'label')).toMatchObject({ value: 'A' })
     expect(dataOf(items[1]!, 'label')).toMatchObject({ value: 'B' })
@@ -248,11 +248,11 @@ test('adding an item emits an Upsert for the new node; removing emits a Delete',
     await server.invoke('0.Bar.0:add', { id: 'c', label: 'C' })
     const added = await server.renderDiff()
     expect(deleteIds(added)).toEqual([])
-    expect(upsertIds(added)).toContain('0.Item.2')
+    expect(upsertIds(added)).toContain('0.Item.c')
 
-    await server.invoke('0.Item.2:remove', {})
+    await server.invoke('0.Item.c:remove', {})
     const removed = await server.renderDiff()
-    expect(deleteIds(removed)).toEqual(['0.Item.2'])
+    expect(deleteIds(removed)).toEqual(['0.Item.c'])
   } finally {
     await server.dispose()
   }
@@ -262,9 +262,9 @@ test("a removed node's handle is revoked — a stale client invocation rejects",
   const server = makeRemoteServer(listScene())
   try {
     await server.renderDiff()
-    await server.invoke('0.Item.1:remove', {})
+    await server.invoke('0.Item.b:remove', {})
     await server.renderDiff()
-    await expect(server.invoke('0.Item.1:remove', {})).rejects.toBeDefined()
+    await expect(server.invoke('0.Item.b:remove', {})).rejects.toBeDefined()
   } finally {
     await server.dispose()
   }

package/src/server.ts

@@ -1,370 +1,32 @@
 import {
-  Array as Arr,
-  Context,
   Effect,
   Layer,
-  Match,
   ManagedRuntime,
   Option,
   type ParseResult,
   PubSub,
   Queue,
-  Record as Rec,
-  Schema,
 } from 'effect'
+import { type CapturedScene, forceSync, publish, type UiContract } from '@playfast/reform'
 import {
-  type CapturedScene,
-  Composition,
-  type CompositionClass,
-  forceSync,
-  isFeatureBinding,
-  isSlot,
-  isStructure,
-  publish,
-  type SlotFill,
-  type Structure,
-  type Trigger,
-  type UiContract,
-} from '@playfast/reform'
-import {
-  type AnyComposition,
   type AnyScene,
-  type AnySlot,
-  type AnySlotChild,
   Bus,
   Triggers,
   type TriggerRegistryApi,
-  type UiManifest,
   Wire,
-  type WireNode,
   type WirePatch,
-  type WireProp,
   type WireTree,
 } from '@playfast/reform/internal'
-
-const SETTLE_DRAIN = 30
-const settleDrain = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))
-
-// The erased event map's never values remain assignable to Trigger<unknown> without a cast.
-const eventsOf = (structure: Structure<UiContract>): Record<string, Trigger<unknown>> =>
-  Option.match(Option.fromNullable(structure.events), {
-    onNone: () => ({}),
-    onSome: (events) => events,
-  })
-
-interface Mounted {
-  readonly comp: AnyComposition
-  readonly props: unknown
-  readonly id: string
-  readonly parentId: Option.Option<string>
-  readonly slot: Option.Option<string>
-  readonly childIndex: number
-  readonly key: Option.Option<string>
-}
-
-const childComposition = (child: AnySlotChild): AnyComposition => {
-  if (!isFeatureBinding(child)) {
-    return child
-  }
-  return child.capture<AnyComposition>((binding): AnyComposition => binding.composition)
-}
-
-const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
-  typeof candidate === 'object' && candidate !== null && !Array.isArray(candidate)
-
-const handlesOf = (node: WireNode): ReadonlyArray<string> =>
-  node.props.flatMap((prop) => (prop._tag === 'Event' ? [prop.handle] : []))
-
-// One-shot renders still emit deterministic handles but have no client registry.
-const noRegister: TriggerRegistryApi['register'] = () => Effect.void
-
-const toWireNodeFromStructure = Effect.fn('toWireNodeFromStructure')(function* (
-  mounted: Mounted,
-  structure: Structure<UiContract>,
-  register: TriggerRegistryApi['register'],
-): Effect.fn.Return<WireNode, ParseResult.ParseError> {
-  const manifest: UiManifest = mounted.comp.manifest.ui.manifest
-  const name = manifest.name
-
-  // The manifest stores schema AST only; reconstruct an unknown-safe schema at this wire seam.
-  const encodedProps = yield* Option.match(Option.fromNullable(manifest.props), {
-    onNone: () => Effect.succeed({}),
-    onSome: (reflection) =>
-      Schema.encodeUnknown(Schema.make<unknown, unknown>(reflection.ast))(structure.props).pipe(
-        Effect.flatMap((encoded) => {
-          if (isRecord(encoded)) {
-            return Effect.succeed(encoded)
-          }
-          return Effect.dieMessage(
-            `reform-remote: ${manifest.name} props did not encode to a record`,
-          )
-        }),
-      ),
-  })
-  const dataProps: ReadonlyArray<WireProp> = Rec.toEntries(encodedProps).map(
-    ([propName, propValue]): WireProp => ({
-      _tag: 'Data',
-      name: propName,
-      value: propValue,
-    }),
-  )
-
-  const eventSchemas = Option.fromNullable(manifest.events)
-  const events = eventsOf(structure)
-  const eventProps: ReadonlyArray<WireProp> = yield* Effect.forEach(
-    Rec.toEntries(events),
-    ([eventName, trigger]) =>
-      Effect.gen(function* () {
-        const schema = Option.flatMap(eventSchemas, (schemas) => Rec.get(schemas, eventName))
-        if (Option.isNone(schema)) {
-          return Option.none<WireProp>()
-        }
-        const handle = `${mounted.id}:${eventName}`
-        yield* register(handle, trigger, Schema.make<unknown, unknown>(schema.value.ast))
-        return Option.some<WireProp>({
-          _tag: 'Event',
-          name: eventName,
-          handle,
-        })
-      }),
-  ).pipe(Effect.map(Arr.getSomes))
-
-  return {
-    id: mounted.id,
-    name,
-    parentId: Option.getOrNull(mounted.parentId),
-    childIndex: mounted.childIndex,
-    slot: Option.getOrNull(mounted.slot),
-    key: Option.getOrNull(mounted.key),
-    props: [...dataProps, ...eventProps],
-  }
-})
-
-// Structure erases per-slot fill types; recover SlotFill structurally without `as`.
-const isSlotFill = (candidate: unknown): candidate is SlotFill<unknown> =>
-  typeof candidate === 'object' &&
-  candidate !== null &&
-  '_tag' in candidate &&
-  (candidate._tag === 'Each' || candidate._tag === 'One' || candidate._tag === 'Absent')
-
-const structureFills = (structure: Structure<UiContract>): Record<string, SlotFill<unknown>> =>
-  Rec.fromEntries(
-    Rec.toEntries(structure.slots).flatMap(
-      ([slotName, fillValue]): ReadonlyArray<readonly [string, SlotFill<unknown>]> =>
-        isSlotFill(fillValue) ? [[slotName, fillValue]] : [],
-    ),
-  )
-
-const slotsOf = (comp: AnyComposition): Record<string, AnySlot> =>
-  comp.capture<Record<string, AnySlot>>((exact) => {
-    if (!('slots' in exact.manifest)) {
-      return {}
-    }
-    const candidate: unknown = exact.manifest.slots
-    if (!isRecord(candidate)) {
-      return {}
-    }
-    return Rec.fromEntries(
-      Rec.toEntries(candidate).flatMap(
-        ([name, slotDefinition]): ReadonlyArray<readonly [string, AnySlot]> =>
-          isSlot(slotDefinition) ? [[name, slotDefinition]] : [],
-      ),
-    )
-  })
-
-const serviceFromContext = <Services, Identifier, Service>(
-  context: Context.Context<Services>,
-  tag: Context.Tag<Identifier, Service>,
-  missing: string,
-): Effect.Effect<Service, never, never> =>
-  Option.match(Context.getOption(context, tag), {
-    onNone: () => Effect.dieMessage(missing),
-    onSome: Effect.succeed,
-  })
-
-const capturedSlotProvider = <Services>(
-  context: Context.Context<Services>,
-  slotDefinition: AnySlot,
-): Effect.Effect<AnySlotChild, never, never> =>
-  slotDefinition.capture((exact) =>
-    serviceFromContext(
-      context,
-      exact.provider,
-      'reform-remote: scene does not provide a declared slot',
-    ),
-  )
-
-const renderCapturedComposition = <Services>(
-  context: Context.Context<Services>,
-  composition: AnyComposition,
-  props: unknown,
-): Effect.Effect<Structure<UiContract>, never, never> =>
-  composition.capture<Effect.Effect<Structure<UiContract>, never, never>>(
-    <P, C extends UiContract, S extends ReadonlyArray<unknown>, N extends string, Identity>(
-      exact: CompositionClass<P, C, S, N, Identity>,
-    ): Effect.Effect<Structure<UiContract>, never, never> =>
-      Option.match(exact.parseProps(props), {
-        onNone: () =>
-          Effect.dieMessage(
-            `reform-remote: invalid props for composition ${composition.manifest.name}`,
-          ),
-        onSome: (parsed) =>
-          serviceFromContext(
-            context,
-            exact.tag,
-            `reform-remote: scene does not provide composition ${composition.manifest.name}`,
-          ).pipe(
-            Effect.flatMap((service) =>
-              Composition.render<P, C>(service, {
-                props: parsed,
-                tracker: { add: () => {} },
-              }),
-            ),
-            Effect.flatMap((frame) => {
-              if (isStructure(frame)) {
-                return Effect.succeed(frame)
-              }
-              return Effect.dieMessage(
-                `reform-remote: composition ${composition.manifest.name} did not return a Structure`,
-              )
-            }),
-          ),
-      }),
-  )
-
-const enqueueStructureSlot = (
-  parent: Mounted,
-  slotName: string,
-  child: AnyComposition,
-  fill: SlotFill<unknown>,
-): ReadonlyArray<Mounted> =>
-  Match.value(fill).pipe(
-    Match.tag('Each', (each) =>
-      each.items.map(
-        (entry, index): Mounted => ({
-          comp: child,
-          props: entry.props,
-          id: `${parent.id}.${slotName}.${index}`,
-          parentId: Option.some(parent.id),
-          slot: Option.some(slotName),
-          childIndex: index,
-          key: Option.fromNullable(entry.key),
-        }),
-      ),
-    ),
-    Match.tag('One', (single) => [
-      {
-        comp: child,
-        props: single.props,
-        id: `${parent.id}.${slotName}.0`,
-        parentId: Option.some(parent.id),
-        slot: Option.some(slotName),
-        childIndex: 0,
-        key: Option.none(),
-      } satisfies Mounted,
-    ]),
-    Match.tag('Absent', () => []),
-    Match.exhaustive,
-  )
-
-type SlotProvider<Services> = (
-  slotDefinition: AnySlot,
-) => Effect.Effect<AnySlotChild, never, Services>
-
-const collect = Effect.fn('collect')(function* <Services>(
-  root: AnyComposition,
-  provideSlot: SlotProvider<Services>,
-): Effect.fn.Return<Map<AnySlot, AnyComposition>, never, Services> {
-  const bindings = new Map<AnySlot, AnyComposition>()
-  // Explicit type keeps the recursive reference cast-free.
-  const walk: (comp: AnyComposition) => Effect.Effect<void, never, Services> = Effect.fn('walk')(
-    function* (comp: AnyComposition): Effect.fn.Return<void, never, Services> {
-      yield* Effect.forEach(Rec.values(slotsOf(comp)), (slotClass) =>
-        Effect.gen(function* () {
-          if (bindings.has(slotClass)) {
-            return
-          }
-          const child = childComposition(yield* provideSlot(slotClass))
-          bindings.set(slotClass, child)
-          yield* walk(child)
-        }),
-      )
-    },
-  )
-  yield* walk(root)
-  return bindings
-})
-
-type CompositionRenderer<Services> = (
-  composition: AnyComposition,
-  props: unknown,
-) => Effect.Effect<Structure<UiContract>, never, Services>
-
-interface RenderLevel {
-  <Services>(
-    frontier: ReadonlyArray<Mounted>,
-    bindings: ReadonlyMap<AnySlot, AnyComposition>,
-    register: TriggerRegistryApi['register'],
-    render: CompositionRenderer<Services>,
-  ): Effect.Effect<ReadonlyArray<WireNode>, ParseResult.ParseError, Services>
-}
-
-const renderLevel: RenderLevel = Effect.fn('renderLevel')(function* <Services>(
-  frontier: ReadonlyArray<Mounted>,
-  bindings: ReadonlyMap<AnySlot, AnyComposition>,
-  register: TriggerRegistryApi['register'],
-  render: CompositionRenderer<Services>,
-): Effect.fn.Return<ReadonlyArray<WireNode>, ParseResult.ParseError, Services> {
-  if (frontier.length === 0) {
-    return []
-  }
-  const rendered = yield* Effect.forEach(frontier, (mounted) =>
-    Effect.gen(function* () {
-      const frame = yield* render(mounted.comp, mounted.props)
-      const node = yield* toWireNodeFromStructure(mounted, frame, register)
-      const fills = structureFills(frame)
-      const children = Rec.toEntries(slotsOf(mounted.comp)).flatMap(([slotName, slotClass]) => {
-        const child = bindings.get(slotClass)
-        if (child === undefined) {
-          return []
-        }
-        const fill = fills[slotName]
-        if (fill === undefined) {
-          return []
-        }
-        return enqueueStructureSlot(mounted, slotName, child, fill)
-      })
-      return { node, children }
-    }),
-  )
-  const nodes = rendered.map((entry) => entry.node)
-  const next = rendered.flatMap((entry) => entry.children)
-  const rest = yield* renderLevel(next, bindings, register, render)
-  return [...nodes, ...rest]
-})
-
-const renderSceneWith = Effect.fn('renderSceneWith')(function* <SlotServices, CompositionServices>(
-  scene: AnyScene,
-  options: RenderSceneToWireOptions | undefined,
-  provideSlot: SlotProvider<SlotServices>,
-  render: CompositionRenderer<CompositionServices>,
-): Effect.fn.Return<WireTree, ParseResult.ParseError, SlotServices | CompositionServices> {
-  const register = options?.register ?? noRegister
-  const bindings = yield* collect(scene.composition, provideSlot)
-  const root: Mounted = {
-    comp: scene.composition,
-    props: {},
-    id: '0',
-    parentId: Option.none(),
-    slot: Option.none(),
-    childIndex: 0,
-    key: Option.none(),
-  }
-  return yield* renderLevel([root], bindings, register, render)
-})
-export interface RenderSceneToWireOptions {
-  readonly register: TriggerRegistryApi['register']
-}
+import {
+  capturedSlotProvider,
+  renderCapturedComposition,
+  type RenderSceneToWireOptions,
+  renderSceneWith,
+  serviceFromContext,
+} from './wireRender'
+import { handlesOf, settleDrain } from './wireNode'
+
+export type { RenderSceneToWireOptions } from './wireRender'
 
 // oxlint-disable-next-line reform-rules/prefer-effect-fn -- exported binding: Effect.fn's inferred type isn't portable under isolatedDeclarations
 export const renderSceneToWire = <

package/src/slottedFixtures.ts

@@ -0,0 +1,120 @@
+import { createElement } from 'react'
+import { Effect, Layer, Schema as S } from 'effect'
+import {
+  Composition,
+  Engine,
+  Event,
+  Reducer,
+  State,
+  Ui,
+  mount,
+  one,
+  provide,
+  scene,
+  slot,
+  type CapturedScene,
+  type DerivedContract,
+  type SlotService,
+  ui,
+} from '@playfast/reform'
+import { type CompositionChildSummary, type EngineServices, type WiredUi } from '@playfast/reform/internal'
+
+const GreetingBase: State.StateDefinition<'greeting', string, typeof S.String> = State.make(
+  'greeting',
+  S.String,
+)
+class Greeting extends GreetingBase {}
+class Greeted extends Event.make('Greeted', S.Struct({ text: S.String })) {}
+class Cleared extends Event.make('Cleared', S.Struct({})) {}
+class SetGreeting extends Reducer.make('SetGreeting', {
+  states: [Greeting],
+  events: [Greeted],
+}) {}
+class ClearGreeting extends Reducer.make('ClearGreeting', {
+  states: [Greeting],
+  events: [Cleared],
+}) {}
+const PanelUiBase: WiredUi<
+  DerivedContract<{
+    props: S.Struct<{ greeting: typeof S.String }>
+    events: {
+      greet: S.Struct<{ text: typeof S.String }>
+      clear: S.Struct<{}>
+    }
+  }>,
+  'Panel'
+> = ui('Panel', {
+  props: S.Struct({ greeting: S.String }),
+  events: { greet: S.Struct({ text: S.String }), clear: S.Struct({}) },
+})
+class PanelUi extends PanelUiBase {}
+
+class Panel extends Composition.make('Panel', {
+  title: 'Panel',
+  ui: PanelUi,
+  states: [Greeting],
+})<Panel>() {}
+
+class MainSlot extends slot('Main')<MainSlot, typeof Panel>() {}
+const ShellUiBase: Ui.UiClass<{ props: {}; slots: { Main: MainSlot } }, 'Shell'> = ui('Shell')<{
+  props: {}
+  slots: { Main: MainSlot }
+}>()
+class ShellUi extends ShellUiBase {}
+
+class Shell extends Composition.make('Shell', {
+  title: 'Shell',
+  slots: { Main: MainSlot },
+  ui: ShellUi,
+})<Shell>() {}
+
+type SlottedScene = CapturedScene<
+  typeof ShellUi.Contract,
+  readonly [],
+  | EngineServices
+  | State.StateStore<'greeting', string>
+  | Ui.UiService<'Panel'>
+  | Ui.UiService<'Shell'>
+  | Composition.CompositionId<'Shell', Shell, MainSlot>
+  | Composition.CompositionId<'Panel', Panel, never>
+  | SlotService<'Main', MainSlot, CompositionChildSummary<Panel>>,
+  unknown,
+  'Shell',
+  Shell
+>
+
+const makeSlottedScene = (): SlottedScene => {
+  const presentation = Layer.mergeAll(
+    provide(
+      ShellUi,
+      Ui.make(ShellUi, (_props, slots) => createElement(slots.Main, {})),
+    ),
+    provide(
+      PanelUi,
+      Ui.make(PanelUi, ({ greeting }) => greeting),
+    ),
+    provide(MainSlot, Panel),
+    State.live(Greeting, 'hi'),
+  )
+  const app = Layer.mergeAll(
+    Composition.live(Shell, function* () {
+      yield* Effect.void
+      return mount({ props: {}, slots: { Main: one({}) } })
+    }),
+    Composition.live(Panel, function* () {
+      const greeting = yield* Greeting
+      const greet = yield* Event.trigger(Greeted)
+      const clearTrigger = yield* Event.trigger(Cleared)
+      const clear = (): void => clearTrigger({})
+      return mount({
+        props: { greeting },
+        slots: {},
+        events: { greet, clear },
+      })
+    }),
+    Reducer.live(SetGreeting, (_greeting, event) => event.text),
+    Reducer.live(ClearGreeting, () => ''),
+  ).pipe(Layer.provideMerge(presentation), Layer.provideMerge(Engine))
+  return scene(Shell, { provide: [app] })
+}
+export const slottedScene: typeof makeSlottedScene = makeSlottedScene

package/src/transport.ts

@@ -1,13 +1,6 @@
-import { Effect, Fiber, Match, Option } from 'effect'
-import type { ReactNode } from 'react'
-import { type AnyScene, Wire, type WirePatch, type WireTree } from '@playfast/reform/internal'
+import { Effect, Fiber, Option } from 'effect'
+import { type AnyScene, type WirePatch, type WireTree } from '@playfast/reform/internal'
 import { makeRemoteServer } from './server'
-import {
-  renderWireTree,
-  type ClientConfig,
-  type RemoteContract,
-  type RemoteViewSet,
-} from './client'
 
 export interface SnapshotMessage {
   readonly _tag: 'Snapshot'
@@ -108,6 +101,12 @@ export const serve = (options: ServeOptions): ServerBinding => {
     void Effect.runPromise(
       Effect.promise(() => server.invoke(message.handle, message.payload)).pipe(
         Effect.zipRight(Effect.promise(push)),
+        // A stale handle (its node was deleted by a patch still in flight) fails by
+        // design. Left unhandled that escapes as a rejected promise and, under Node's
+        // default --unhandled-rejections=throw, takes the server down for every client.
+        Effect.catchAllCause((cause) =>
+          Effect.logError(`reform-remote: invoke '${message.handle}' failed`, cause),
+        ),
       ),
     )
   })
@@ -215,6 +214,12 @@ export const serveShared = (options: ServeSharedOptions): SharedServerBinding =>
       void Effect.runPromise(
         Effect.promise(() => server.invoke(message.handle, message.payload)).pipe(
           Effect.zipRight(Effect.promise(push)),
+          // A stale handle (its node was deleted by a patch still in flight) fails by
+          // design. Left unhandled that escapes as a rejected promise and, under Node's
+          // default --unhandled-rejections=throw, takes the server down for every client.
+          Effect.catchAllCause((cause) =>
+            Effect.logError(`reform-remote: invoke '${message.handle}' failed`, cause),
+          ),
         ),
       )
     })
@@ -250,41 +255,4 @@ export const serveShared = (options: ServeSharedOptions): SharedServerBinding =>
   }
 }
 
-export interface ClientBinding {
-  readonly node: () => ReactNode
-  readonly subscribe: (listener: () => void) => () => void
-  readonly snapshot: () => WireTree
-  readonly dispose: () => void
-}
-
-export interface ConnectOptions<C extends RemoteContract> {
-  readonly transport: RemoteTransport<InvokeMessage, ServerMessage>
-  readonly views: RemoteViewSet<C>
-}
-
-export const connect = <C extends RemoteContract>(options: ConnectOptions<C>): ClientBinding => {
-  const { transport, views } = options
-  const state: { tree: WireTree } = { tree: [] }
-  const listeners = new Set<() => void>()
-  const config: ClientConfig<C> = {
-    views,
-    invoke: (handle, payload) => transport.send({ _tag: 'Invoke', handle, payload }),
-  }
-  const off = transport.onMessage((message) => {
-    state.tree = Match.value(message).pipe(
-      Match.tag('Snapshot', ({ tree }) => tree),
-      Match.tag('Patches', ({ patches }) => Wire.apply(state.tree, patches)),
-      Match.exhaustive,
-    )
-    listeners.forEach((listener) => listener())
-  })
-  return {
-    node: () => renderWireTree(state.tree, config),
-    subscribe: (listener) => {
-      listeners.add(listener)
-      return () => void listeners.delete(listener)
-    },
-    snapshot: () => state.tree,
-    dispose: off,
-  }
-}
+export { type ClientBinding, connect, type ConnectOptions } from './clientBinding'