Remove @viewBinding decorator and related OO view infrastructure (v9 breaking change)

`viewBinding`, `ViewBinder`, `createViewForModel`, `DEFAULT_VIEW_KEY`, and `ViewMetadata` are removed from `esp-js-react`.
These were part of the old OO model pattern where a decorator on a class instance bound it to a React view via prototype metadata — a pattern that no longer exists in v9.
`ConnectableComponent` now requires an explicit `view` prop; view resolution via decorator metadata is gone.
`viewContext` is also removed from `ConnectableComponentProps` and `connect()` as it only served the decorator lookup.

With no remaining decorator usage in the codebase, `experimentalDecorators` and `emitDecoratorMetadata` are removed from the root `tsconfig.json`.

Author: KeithWoods

CHANGES-v9.md

@@ -321,13 +321,65 @@ new ModelBuilder<MyModel>(router, 'my-model', initialModel)
 
 ---
 
-## esp-js-polimer deprecation
+## esp-js-polimer removal
 
-`esp-js-polimer` is deprecated as of v9. It will not receive new features. Bug fixes may be applied on a best-effort basis.
+`esp-js-polimer` has been **deleted** from the monorepo. The package is no longer published.
 
-Polimer's concepts — immutable state, immer drafts, builder registration, event transforms — are the direct ancestors of the v9 `esp-js` API. Teams using polimer should migrate to the native `ModelBuilder` API. The functional shape is very similar; the main differences are:
+Polimer's concepts — immutable state, immer drafts, builder registration, event transforms — are the direct ancestors of the v9 `esp-js` API. The `ModelBuilder` in `esp-js` is the replacement.
 
-- `PolimerModelBuilder` → `ModelBuilder`
-- `withStateHandlers(key, handlers)` (per-slice) → `withEventHandler` on the full model
-- `@eventTransformFor` (RxJS observable transforms) → `withEffect` + `withEventSubscription`
-- `PolimerModel.getImmutableModel()` → `router.getModelObservable()` returns the POJO directly
+Migration reference:
+
+| esp-js-polimer | esp-js v9 |
+|---|---|
+| `PolimerModelBuilder` | `ModelBuilder` |
+| `withStateHandlers(key, handlers)` (per-slice) | `withEventHandler` on the full model |
+| `@eventTransformFor` (RxJS observable transforms) | `withEffect` + `withEventSubscription` |
+| `PolimerModel.getImmutableModel()` | `router.getModelObservable()` — emits the POJO directly |
+
+---
+
+## esp-js-react — polimer integration removed
+
+`esp-js-react` no longer depends on or integrates with `esp-js-polimer`. The model contract is now simple: `router.getModelObservable()` always emits a **frozen immutable POJO** (produced by immer via `ModelBuilder`). No unwrapping is needed.
+
+### `useSyncModelWithSelector` — removed option
+
+`tryPreSelectPolimerImmutableModel` has been removed from `SyncModelWithSelectorOptions`. This option previously called `model.getEspPolimerImmutableModel()` before applying the selector. Since the model is now the direct frozen snapshot, no pre-selection is necessary.
+
+**Before (v8 with polimer):**
+```typescript
+syncModelWithSelectorOptions<MyModel>()
+    .setModelId('my-model')
+    .setTryPreSelectPolimerImmutableModel(true) // removed
+    .build()
+```
+
+**After (v9):**
+```typescript
+syncModelWithSelectorOptions<MyModel>()
+    .setModelId('my-model')
+    .build()
+```
+
+### `ConnectableComponent` — duck-typing removed
+
+`ConnectableComponent` previously checked for `getEspPolimerImmutableModel` on the model and unwrapped it before passing to `mapModelToProps`. This duck-typing is removed. The raw frozen model is passed directly.
+
+### Reactive API internalized
+
+The `reactive/` module in `esp-js` is now internal-only and is not exported from `src/index.ts`. `Observable`, `Subject`, `RouterObservable`, and `RouterSubject` are no longer part of the public API.
+
+Code that previously used `Observable.create` to wrap `router.getModelObservable()` must be updated to wrap the `subscribe` method directly:
+
+```typescript
+// Before (broken — Observable is no longer exported):
+const wrapped = Observable.create<MyModel>(o => router.getModelObservable('id').subscribe(o));
+
+// After:
+const upstream = router.getModelObservable<MyModel>('id');
+const wrapped = {
+    subscribe(observer: any) {
+        return upstream.subscribe(observer);
+    }
+} as Subscribable<MyModel>;
+```

packages/esp-js-react/src/connect.tsx

@@ -13,11 +13,10 @@ export const connect = function <TModel, TPublishEventProps, TModelMappedToProps
 ): ConnectableComponentFactory<TModel, TPublishEventProps, TModelMappedToProps> {
     return function (view: React.ComponentType) {
         return function (props: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>) {
-            const {modelId, viewContext, ...rest} = props;
+            const {modelId, ...rest} = props;
             return <ConnectableComponent
                 modelId={modelId}
                 view={view}
-                viewContext={viewContext}
                 createPublishEventProps={createPublishEventProps}
                 mapModelToProps={mapModelToProps}
                 {...rest}

packages/esp-js-react/src/connectableComponent.tsx

@@ -3,7 +3,6 @@ import {useRouter} from './espRouterContextProvider';
 import {useMemo} from 'react';
 import {Router} from 'esp-js';
 import {EspModelContextProvider, useGetModelId} from './espModelContextProvider';
-import {createViewForModel} from './viewBindingDecorator';
 import {syncModelWithSelectorOptions, useSyncModelWithSelector} from './useSyncModelWithSelector';
 
 export type CreatePublishEventProps<TPublishEventProps> = (publishModelEvent: (eventType: string, event: any) => void) => TPublishEventProps;
@@ -12,7 +11,6 @@ export type MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps = {}
 
 export interface ConnectableComponentProps<TModel = {}, TPublishEventProps = {}, TModelMappedToProps = {}> {
     modelId?: string;
-    viewContext?: string;
     view?: React.ComponentType;
     createPublishEventProps?: CreatePublishEventProps<TPublishEventProps>;
     mapModelToProps?: MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps>;
@@ -56,7 +54,6 @@ export const ConnectableComponent = <TModel = {}, TPublishEventProps = {}, TMode
         mapModelToProps,
         createPublishEventProps,
         view,
-        viewContext,
         ...rest
     }: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>
 ) => {
@@ -85,7 +82,7 @@ export const ConnectableComponent = <TModel = {}, TPublishEventProps = {}, TMode
         return null;
     }
     let childProps = getChildProps(router, modelId, rest, model, mapModelToProps, publishEventProps);
-    let viewElement = createViewForModel(model, childProps, viewContext, view);
+    let viewElement = view ? React.createElement(view as React.ComponentType<any>, childProps) : null;
     return (
         <EspModelContextProvider modelId={modelId} model={model} router={router} {...childProps}>
             {viewElement}

packages/esp-js-react/src/index.ts

@@ -17,9 +17,6 @@
 // notice_end
 //
 
-export {ViewBinder} from './viewBinder';
-export {viewBinding, DEFAULT_VIEW_KEY} from './viewBindingDecorator';
-export {createViewForModel} from './viewBindingDecorator';
 export {
     connect,
     ConnectableComponentFactory