sygnal 5.3.7 → 6.0.0

package/src/astro/client.ts

@@ -1,19 +1,26 @@
-import run from '../extra/run'
+// The public entry (external in the build), so islands share the app's
+// Sygnal core instead of a bundled copy (B-019).
+import { run } from 'sygnal'
+// PLAN-4 GS-11 / D120: the app-level error hook, the default export of the module the
+// integration's `onError` option names (undefined without it); served by sygnal/astro's Vite plugin
+// @ts-ignore — a virtual module
+import onError from 'virtual:sygnal/astro-on-error'
 
 interface SygnalComponent {
   (args: any): any;
-  isSygnalComponent?: boolean;
   model?: any;
   intent?: any;
-  hmrActions?: any;
+  connections?: any;
+  resources?: any;
+  route?: any;
+  head?: any;
+  persist?: any;
+  uses?: any;
+  timers?: any;
+  viewTransitions?: any;
   context?: any;
-  peers?: any;
-  components?: any;
   initialState?: any;
   calculated?: any;
-  storeCalculatedInState?: any;
-  DOMSourceName?: string;
-  stateSourceName?: string;
   onError?: (error: Error, info: { componentName: string }) => any;
   debug?: boolean;
   componentName?: string;
@@ -27,8 +34,7 @@ interface AstroMetadata {
 function looksLikeSygnalComponent(Component: any): Component is SygnalComponent {
   if (typeof Component !== 'function') return false
   return Boolean(
-    Component.isSygnalComponent ||
-      Component.model ||
+    Component.model ||
       Component.intent ||
       Component.initialState ||
       Component.componentName
@@ -50,23 +56,39 @@ export default (element: any) => {
       previous.dispose()
     }
 
-    const Wrapped: any = (args: any) => Component({ ...args, props: { ...(props || {}) } })
+    // Island props reach the view like any component's props, spread
+    // top-level (`{ state, title }`), the same as on the server
+    // (renderToString). The view args (state, context, ...) win over a prop
+    // with the same name; `props` is kept for older `({ state, props })`
+    // views (B-026).
+    const islandProps = { ...(props || {}) }
+    const Wrapped: any = (args: any) => Component({ ...islandProps, ...args, props: islandProps })
     Wrapped.model = Component.model
     Wrapped.intent = Component.intent
-    Wrapped.hmrActions = Component.hmrActions
     Wrapped.context = Component.context
-    Wrapped.peers = Component.peers
-    Wrapped.components = Component.components
     Wrapped.initialState = Component.initialState
     Wrapped.calculated = Component.calculated
-    Wrapped.storeCalculatedInState = Component.storeCalculatedInState
-    Wrapped.DOMSourceName = Component.DOMSourceName
-    Wrapped.stateSourceName = Component.stateSourceName
     Wrapped.onError = Component.onError
     Wrapped.debug = Component.debug
+    Wrapped.connections = Component.connections
+    Wrapped.resources = Component.resources
+    Wrapped.route = Component.route
+    Wrapped.head = Component.head
+    // PLAN-4 3-B2: more statics the core reads off the root view: persist (root only: the island
+    // is its app's root), uses, timers (they run only with a timer driver) and viewTransitions
+    Wrapped.persist = Component.persist
+    Wrapped.uses = Component.uses
+    Wrapped.timers = Component.timers
+    Wrapped.viewTransitions = Component.viewTransitions
     Wrapped.componentName = Component.componentName || Component.name
+    // run() names the root by `name` first: diagnostics and devtools should
+    // say 'Counter', not 'Wrapped'
+    try { Object.defineProperty(Wrapped, 'name', { value: Wrapped.componentName, configurable: true }) } catch (_) {}
 
-    const app = run(Wrapped, {}, { mountPoint })
+    // G-206: a `uid` island prop is the island's uid root (as on the server); the view's own
+    // uid() function wins over the prop (args are spread last)
+    // 3-B2: `__hydrate` tells persist() whether the island starts over the server's markup
+    const app = run(Wrapped, { __hydrate: () => client !== 'only' && canHydrate }, { mountPoint, onError, uid: islandProps.uid })
     element.__sygnal = app
   }
 }

package/src/astro/index.d.ts

@@ -1,3 +1,5 @@
+import type { DiagnosticsMode, DiagnosticsPluginOptions, CheckPluginOptions } from '../vite/plugin.d'
+
 declare type SygnalAstroIntegration = {
   name: string;
   hooks: {
@@ -8,8 +10,53 @@ declare type SygnalAstroIntegration = {
         serverEntrypoint: string;
       }) => void;
       updateConfig: (config: any) => void;
+      command?: 'dev' | 'build' | 'preview' | 'sync';
+      logger?: { warn: (message: string) => void };
+      config?: { root?: URL | string; vite?: any };
     }) => void;
   };
 };
 
-export default function sygnalAstroIntegration(): SygnalAstroIntegration;
+export interface SygnalAstroOptions {
+  /**
+   * Runtime diagnostics for islands in `astro dev`: a mode ('warn',
+   * 'collect', 'error' or 'off') or { mode, strict, ignore }, the same as
+   * the sygnal/vite `diagnostics` option.
+   * @default 'warn'
+   */
+  diagnostics?: DiagnosticsMode | DiagnosticsPluginOptions;
+  /**
+   * Run sygnal-check in `astro dev` (see the sygnal/vite `check` option).
+   * @default true
+   */
+  check?: boolean | CheckPluginOptions;
+  /**
+   * Resolve xstream's `globalthis` dependency to a stub returning the native
+   * `globalThis` (see the sygnal/vite `nativeGlobalThis` option), in
+   * `astro dev` and `astro build`. false: keep the polyfill package.
+   * @default true
+   */
+  nativeGlobalThis?: boolean;
+  /**
+   * Install the DevTools bridge for islands in `astro dev` (see the sygnal/vite
+   * `devtools` option). Never in `astro build`.
+   * @default true
+   */
+  devtools?: boolean;
+  /**
+   * The islands' app-level error hook (PLAN-4 GS-11): the path of a module, relative to the
+   * Astro project root, whose default export is called as run()'s and renderToString's
+   * `onError`, in the browser and during SSR. Reporting only, after a component's onError
+   * boundary chose the fallback.
+   * @example sygnal({ onError: './src/onError.js' })
+   * // src/onError.js
+   * export default (error, { componentName, action, phase }) => report(error)
+   */
+  onError?: string;
+}
+
+/**
+ * Sygnal Astro integration. In `astro dev` it also adds the sygnal Vite
+ * plugin, which turns on runtime diagnostics for islands and runs sygnal-check.
+ */
+export default function sygnalAstroIntegration(options?: SygnalAstroOptions): SygnalAstroIntegration;

package/src/astro/index.ts

@@ -1,5 +1,38 @@
+import sygnalVite from '../vite/plugin'
+import { globalThisAlias } from '../vite/globalthis'
+import type { DiagnosticsMode, DiagnosticsPluginOptions, CheckPluginOptions } from '../vite/plugin'
+// Node built-ins (the integration runs in Node). The package has no @types/node.
+// @ts-ignore
+import path from 'node:path'
+// @ts-ignore
+import { fileURLToPath } from 'node:url'
+
 const SYGNAL_RENDERER_NAME = '@sygnal/astro'
 
+// PLAN-4 GS-11 / D120: both island entries import this; it re-exports the default export of the
+// module the `onError` option names (undefined without it)
+const ON_ERROR_ID = 'virtual:sygnal/astro-on-error'
+
+/** The Vite plugin serving ON_ERROR_ID; `file` is absolute (undefined: no hook) */
+function onErrorPlugin(file?: string) {
+  return {
+    name: 'sygnal:astro-on-error',
+    resolveId: (id: string) => id === ON_ERROR_ID ? '\0' + ON_ERROR_ID : undefined,
+    load: (id: string) => id === '\0' + ON_ERROR_ID
+      ? (file ? `export { default } from ${JSON.stringify(file)}` : 'export default undefined')
+      : undefined,
+    // Vite 6+ (Astro 6 renders in its own 'prerender' / 'ssr' environments): the island server
+    // entry imports the virtual module, so Vite must load it (not Node). `ssr.noExternal`
+    // below covers the 'ssr' environment and older Vite
+    configEnvironment: (name: string) => name === 'client' ? undefined : { resolve: { noExternal: ['sygnal'] } },
+  }
+}
+
+/** The project root as a directory path (Astro gives a file: URL) */
+const rootDir = (root: any): string =>
+  // @ts-ignore — Node's process
+  !root ? process.cwd() : typeof root === 'string' ? root : fileURLToPath(root)
+
 interface AstroRenderer {
   name: string;
   clientEntrypoint: string;
@@ -9,27 +42,91 @@ interface AstroRenderer {
 interface AstroConfigSetupArgs {
   addRenderer: (renderer: AstroRenderer) => void;
   updateConfig: (config: any) => void;
+  command?: 'dev' | 'build' | 'preview' | 'sync';
+  logger?: { warn: (message: string) => void };
+  config?: { root?: URL | string; vite?: { resolve?: { alias?: any } } };
 }
 
-export default function sygnalAstroIntegration() {
+export interface SygnalAstroOptions {
+  /**
+   * Runtime diagnostics for islands in `astro dev`: a mode or
+   * { mode, strict, ignore }, the same as the sygnal/vite `diagnostics`
+   * option (the island client shares the app's core, B-019).
+   * @default 'warn'
+   */
+  diagnostics?: DiagnosticsMode | DiagnosticsPluginOptions;
+  /** Run sygnal-check in `astro dev` (see the sygnal/vite `check` option). @default true */
+  check?: boolean | CheckPluginOptions;
+  /**
+   * Resolve xstream's `globalthis` dependency to a stub returning the native
+   * `globalThis` (see the sygnal/vite `nativeGlobalThis` option), in
+   * `astro dev` and `astro build`. false: keep the polyfill package.
+   * @default true
+   */
+  nativeGlobalThis?: boolean;
+  /**
+   * Install the DevTools bridge for islands in `astro dev` (see the sygnal/vite
+   * `devtools` option). Never in `astro build`.
+   * @default true
+   */
+  devtools?: boolean;
+  /**
+   * PLAN-4 GS-11: the islands' app-level error hook: the path of a module (relative to the Astro
+   * project root) whose default export is called as run()'s / renderToString's `onError`
+   * (error, { componentName, action, phase }), in the browser and during SSR. Reporting only,
+   * after a component's onError boundary chose the fallback.
+   * @example sygnal({ onError: './src/onError.js' })
+   */
+  onError?: string;
+}
+
+export default function sygnalAstroIntegration(options: SygnalAstroOptions = {}) {
   return {
     name: SYGNAL_RENDERER_NAME,
     hooks: {
-      'astro:config:setup': ({ addRenderer, updateConfig }: AstroConfigSetupArgs) => {
+      'astro:config:setup': ({ addRenderer, updateConfig, command, config }: AstroConfigSetupArgs) => {
         addRenderer({
           name: SYGNAL_RENDERER_NAME,
           clientEntrypoint: 'sygnal/astro/client',
           serverEntrypoint: 'sygnal/astro/server',
         })
 
-        updateConfig({
-          vite: {
-            esbuild: {
-              jsx: 'automatic',
-              jsxImportSource: 'sygnal',
-            },
+        const vite: any = {
+          esbuild: {
+            jsx: 'automatic',
+            jsxImportSource: 'sygnal',
           },
-        })
+          // D120: the island entries import the virtual onError module, so they stay on Vite:
+          // not pre-bundled with it, and not externalized (loaded by Node) during SSR
+          optimizeDeps: { exclude: [ON_ERROR_ID] },
+          ssr: { noExternal: ['sygnal'] },
+        }
+        const hook = options.onError ? path.resolve(rootDir(config?.root), options.onError) : undefined
+
+        // Dev mode (G-014): islands are started by sygnal/astro/client, which
+        // user code never imports, so the sygnal Vite plugin wraps that entry
+        // in dev to install DevTools, set the dev flag and load the runtime checks first. It
+        // also runs sygnal-check. `astro build` only gets the `globalthis` alias.
+        if (command === 'dev') {
+          vite.plugins = [sygnalVite({
+            disableJsx: true,
+            disableHmr: true,
+            vitestSetup: false,
+            diagnostics: options.diagnostics,
+            check: options.check,
+            nativeGlobalThis: options.nativeGlobalThis,
+            devtools: options.devtools,
+          })]
+        } else if (options.nativeGlobalThis !== false) {
+          // G-099: the same `globalthis` alias the plugin adds in dev (R2-7: unless the
+          // user's vite config already aliases `globalthis`)
+          const alias = globalThisAlias(config?.vite?.resolve?.alias)
+          if (alias.length) vite.resolve = { alias }
+        }
+
+        vite.plugins = [...(vite.plugins || []), onErrorPlugin(hook)]
+
+        updateConfig({ vite })
       },
     },
   }

package/src/astro/server.ts

@@ -1,10 +1,12 @@
 import {renderToString} from '../extra/ssr'
+// PLAN-4 GS-11 / D120: the integration's `onError` module (see client.ts)
+// @ts-ignore — a virtual module
+import onError from 'virtual:sygnal/astro-on-error'
 
 function looksLikeSygnalComponent(Component: any): boolean {
   if (typeof Component !== 'function') return false
   return Boolean(
-    Component.isSygnalComponent ||
-      Component.model ||
+    Component.model ||
       Component.intent ||
       Component.initialState ||
       Component.componentName
@@ -22,9 +24,15 @@ export function renderToStaticMarkup(
   _metadata?: any
 ): { html: string; attrs: Record<string, any> } {
   try {
+    // Props are spread top-level by renderToString (`{ state, ...props }`);
+    // `props` is also passed, as on the client, for `({ state, props })` views.
     const html = renderToString(Component, {
       state: props.initialState || Component.initialState,
-      props,
+      props: {...props, props},
+      // PLAN-4 GS-11: the app-level error hook (as the client's run() gets)
+      onError,
+      // G-206: a `uid` island prop is its uid root (as on the client), for two islands on a page
+      uid: props.uid,
     })
     return {html, attrs: {}}
   } catch (err: any) {

package/src/collection.ts

@@ -1,98 +1,14 @@
-import isolate from './cycle/isolate/index';
-import {makeCollection} from './cycle/state/index';
-import {h} from './cycle/dom/index';
-import type {Lens} from './cycle/state/types';
-
-let COLLECTION_COUNT = 0;
-
-interface CollectionOptions {
-  combineList?: string[];
-  globalList?: string[];
-  stateSourceName?: string;
-  domSourceName?: string;
-  container?: string;
-  containerClass?: string;
-}
-
-export default function collection(
-  component: (...args: any[]) => any,
-  stateLense: string | Lens<any, any>,
-  opts: CollectionOptions = {}
-): (sources: any) => any {
-  if (typeof component !== 'function') {
-    throw new Error('collection: first argument (component) must be a function');
-  }
-  const {
-    combineList = ['DOM'],
-    globalList = ['EVENTS'],
-    stateSourceName = 'STATE',
-    domSourceName = 'DOM',
-    container = 'div',
-    containerClass,
-  } = opts;
-
-  return (sources: any) => {
-    const key = `sygnal-collection-${COLLECTION_COUNT++}`;
-    const collectionOpts = {
-      item: component,
-      itemKey: (state: any, ind: number) =>
-        typeof state.id !== 'undefined' ? state.id : ind,
-      itemScope: (key: any) => key,
-      channel: stateSourceName,
-      collectSinks: (instances: any) => {
-        return Object.entries(sources).reduce<Record<string, any>>(
-          (acc, [name]) => {
-            if (combineList.includes(name)) {
-              const combined = instances.pickCombine(name);
-              if (name === domSourceName && container) {
-                acc[domSourceName] = combined.map((children: any) => {
-                  const data = containerClass
-                    ? {props: {className: containerClass}}
-                    : {};
-                  return {
-                    sel: container,
-                    data,
-                    children,
-                    key,
-                    text: undefined,
-                    elm: undefined,
-                  };
-                });
-              } else {
-                acc[name] = combined;
-              }
-            } else {
-              acc[name] = instances.pickMerge(name);
-            }
-            return acc;
-          },
-          {}
-        );
-      },
-    };
-
-    const isolateOpts: Record<string, any> = {[stateSourceName]: stateLense};
-
-    globalList.forEach((global) => (isolateOpts[global] = null));
-    combineList.forEach((combine) => (isolateOpts[combine] = null));
-
-    return makeIsolatedCollection(collectionOpts, isolateOpts, sources);
-  };
-}
-
-function makeIsolatedCollection(
-  collectionOpts: any,
-  isolateOpts: any,
-  sources: any
-): any {
-  return isolate(makeCollection(collectionOpts), isolateOpts)(sources);
-}
+import {h} from './cycle/dom/snabbdom';
+// the core's handler for this marker, registered on import (D157)
+import './core/hosts/collection';
 
+/** `<Collection of={Item} from="items" />`: a marker vnode the core's Collection host renders */
 const Collection = (props: any) => {
   const {children, ...sanitizedProps} = props;
   return h('collection', {props: sanitizedProps}, children);
 };
-(Collection as any).label = 'collection';
+(Collection as any).componentName = 'collection';
 (Collection as any).preventInstantiation = true;
 
 export {Collection};
+export default Collection;

package/src/core/actions.ts

@@ -0,0 +1,134 @@
+/**
+ * PLAN-4.6 core: running one action (03-proposal §3, 04 §2.4.1).
+ *
+ * The action's handlers run in model order with (pre, data, next, props), where `pre` is the
+ * state (calculated fields included) from before the action, for every sink:
+ * - STATE: applied at once (D165). ABORT, or the object it was given (GS-4), is no change.
+ *   D205: during an input / change event (an action triggered by typing in a field), no change
+ *   still re-renders the instance, so a controlled field shows the model's value again
+ * - EFFECT: run synchronously (preventDefault on the live event still works); `props.signal`
+ *   aborts on dispose; a returned value is SYG219, a rejected promise SYG214.
+ * - PARENT: straight to the parent's CHILD.select listeners as { name, component, value }.
+ * - READY: the instance's ready flag (the parent re-renders it with data-sygnal-ready).
+ * - ELEMENT: element commands, run after the next patch (extra/elementCommands).
+ * - any other sink (EVENTS, LOG, drivers): stamped and scoped (send), then the app's bus.
+ * A dispatch from a handler (a driver answering synchronously, an EFFECT) is queued (FIFO).
+ */
+import type {Inst} from './instance'
+import {isAbort} from '../shared'
+import {isObj} from './define'
+import {warn, error as logError, fail} from '../extra/diagnostics/legacy'
+import {runElementCommands} from '../extra/elementCommands'
+import {viewOf} from './view'
+import {checkStatics} from './statics'
+import {objIsEqual} from '../cycle/state/objIsEqual'
+import {dbg} from './debug'
+
+export function handle(inst: Inst, type: string, data: any, cause: any, src?: string) {
+  const hs = inst.def.handlers.get(type), app = inst.app, H = app.hooks
+  // (an action with no model entry is seen too: the action log lists it with no sinks)
+  if (H.onAction) H.onAction(viewOf(inst), {type, data, cause, target: viewOf(inst), source: src})
+  dbg(inst, () => `<${type}> Action triggered`)
+  if (!hs) return
+  const def = inst.def
+  const pre = inst.cell.get()
+  let props: any, outs: any[] | undefined
+  const next = (t: string, d?: any, ms: any = 10, effect?: boolean) => {
+    if (typeof ms !== 'number') fail('SYG215', inst, `next() delay in '${type}' must be a number`, "Use next('ACTION', data, ms)")
+    // G-300: none for an instance being disposed; dispose() clears the pending ones
+    if (inst.disposed || inst.dying) return dbg(inst, () => `next(${t}) ignored: disposed`)
+    H.onNext?.(viewOf(inst), t, d, ms)
+    dbg(inst, () => `<${type}> ${effect ? 'EFFECT triggered' : 'Triggered'} a next() action: <${t}> ${ms}ms delay`)
+    const ts = inst.timers ||= new Set()
+    const id = setTimeout(() => { ts.delete(id); inst.disposed || app.dispatch(inst, t, d, 'next') }, ms)
+    ts.add(id)
+  }
+  for (const [sink, h0] of hs) {
+    const h = H.wrapHandler ? H.wrapHandler(viewOf(inst), type, sink, h0) || h0 : h0
+    if (sink == 'EFFECT') {
+      if (typeof h != 'function') continue
+      const failed = (e: any) => app.caught(inst, 'SYG214', `EFFECT handler '${type}' threw`, e, 'effect', type)
+      try {
+        const p = {...(props ||= inst_props(inst, pre)), signal: (inst.ac ||= globalThis.AbortController && new AbortController())?.signal}
+        const r = h(pre, data, (t: string, d?: any, ms?: any) => next(t, d, ms, true), p)
+        if (r?.then) r.then(null, failed)
+        else if (r !== undefined && !isAbort(r)) warn('SYG219', inst, `EFFECT handler '${type}' returned a value, which is ignored`, 'Use a STATE or driver sink')
+      } catch (e) { failed(e) }
+      continue
+    }
+    let v: any
+    if (typeof h == 'function') {
+      try { v = h(pre, data, next, props ||= inst_props(inst, pre)) } catch (e) {
+        app.caught(inst, 'SYG216', `Reducer for '${type}' threw; ${sink == 'STATE' ? 'state unchanged' : 'nothing sent'}`, e, 'reducer', type)
+        continue
+      }
+    } else v = h === undefined || h === true ? data : h
+    if (sink == 'STATE' && (isAbort(v) || v === pre)) {
+      // D205: the DOM event being dispatched (window.event) is the one this action came from
+      if (/^(input|change)$/.test((globalThis as any).event?.type)) inst.refresh()
+      continue
+    }
+    if (isAbort(v)) continue
+    if (sink == 'STATE') {
+      H.onReducer?.(viewOf(inst), type, pre, v)
+      dbg(inst, () => `<${type}> State reducer added`)
+      inst.cell.set(v)
+      // GS-12: this app's DOM driver patches inside a View Transition (makeViewTransitionDOMDriver
+      // reads the flag on its IsolateModule); includes?.: a non-array static lists nothing (G-228).
+      // Only for a state that changed structurally: today an equal one renders nothing (its
+      // request expires unused); here it would re-render the same view, so it asks for nothing
+      if (def.view.viewTransitions?.includes?.(type) && (v === undefined || !objIsEqual(pre, inst.cell.get()))) { const m = inst.dom?._isolateModule; if (m) m.vt = 1 }
+      continue
+    }
+    if (typeof v == 'symbol') { logError('SYG218', inst, `Reducer for '${type}' returned a symbol; nothing sent`, 'Return a value, or ABORT to send nothing'); continue }
+    if (v === undefined) warn('SYG217', inst, `Reducer for '${type}' sent undefined to the driver`, 'Return a value, or ABORT to send nothing')
+    if (H.onSink) H.onSink(viewOf(inst), type, sink, v)
+    dbg(inst, () => `<${type}> Data sent to [${sink}]: ${JSON.stringify(v)}`)
+    if (sink == 'PARENT') {
+      const e = {name: def.name, component: def.view, value: v}
+      if (inst.parent) inst.parent.toChild(e)
+      else app.out('PARENT', e)
+    } else if (sink == 'READY') inst.setReady(!!v)
+    else if (sink == 'ELEMENT') {
+      // onElementCommand returning false: recorded, not run (renderComponent's mock DOM)
+      if (H.onElementCommand?.(viewOf(inst), v) !== false) runElementCommands(inst.el ||= {name: def.name, DOMSourceName: 'DOM', sources: {DOM: inst.dom}, get _disposed() { return inst.disposed }}, v)
+    } else if (inst.st) (outs ||= []).push(sink, v)
+    else send(inst, sink, v)
+  }
+  // G-158 (D170/Q21): a static this action changed reaches its driver before the action's own
+  // driver values (a connection the action opens exists before its first message)
+  if (inst.st) {
+    checkStatics(inst)
+    if (outs) for (let i = 0; i < outs.length; i += 2) send(inst, outs[i], outs[i + 1])
+  }
+}
+
+/** the handlers' 4th argument: the props, children, slots, context, uid and the pre-action state */
+function inst_props(inst: Inst, pre: any) {
+  return {...inst.props, children: inst.children, slots: inst.slots, context: inst.context(), uid: inst.uid, state: pre}
+}
+
+/**
+ * A sink value of an instance: stamped with its sender (EVENTS; object values for a reply-capable
+ * source), scoped through every ancestor's isolation (a driver's value-level isolateValue, else
+ * one stream per instance and sink through isolateSink), then onto the app's bus for that sink.
+ */
+export function send(inst: Inst, n: string, v: any) {
+  const app = inst.app, src = app.sources[n]
+  if (n == 'EVENTS' || (src?.__sygnalReplies && isObj(v))) {
+    v = Object.defineProperties({...v}, {__emitterId: {value: inst.id, configurable: true}, __emitterName: {value: inst.def.name, configurable: true}})
+  }
+  if (inst.parent && src && typeof src.isolateSink == 'function') {
+    let w = v
+    for (let i: Inst = inst; i.parent; i = i.parent) {
+      const o = i.parent.src(n)
+      if (typeof o?.isolateValue != 'function') return app.pipe(inst, n, v, (s$: any) => {
+        for (let j: Inst = inst; j.parent; j = j.parent) { const p = j.parent.src(n); if (typeof p?.isolateSink == 'function') s$ = p.isolateSink(s$, j.scope) }
+        return s$
+      }, (x: any) => app.out(n, x))
+      w = o.isolateValue(w, i.scope)
+    }
+    v = w
+  }
+  app.out(n, v)
+}