@tschk/moonshine-vue 0.0.0-stage → 0.4.4

package/README.md

@@ -1,3 +1,299 @@
-# Temporary Holding Version
+# `@tschk/moonshine-vue`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The legacy `/vue` and `/compiler-sfc` entries re-export Vue as a peer.
+At runtime, the root bridges and independent `/reactive` entry depend only on Moonshine's
+signal kernel and native DOM package. They import no Vue, React, WASM, or Crepus
+runtime. Vue remains an optional peer for the two legacy entries.
+
+Strict TypeScript checking of the root entry requires installing
+`@tschk/moonshine-framework`, even when importing only a bridge: the root also
+exports `crepusRenderer` with the framework's `Renderer` contract. The framework
+remains optional for runtime imports and bridge-only browser/Bun/Node bundles.
+This requirement does not apply to the signal-only `@tschk/moonshine` core entry.
+
+The native entry is a bounded composition API implementation. It is not a
+replacement for Vue's component/compiler ABI: do not alias `vue` wholesale onto
+this package or execute existing Vue compiler output against it.
+
+```ts
+import { fromMoonshineSignal } from "@tschk/moonshine-vue";
+import { ref } from "@tschk/moonshine-vue/reactive";
+```
+
+| Subpath          | Provides                                                                                                             |
+| ---------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `.`              | signal bridges, lazy native SSR compatibility renderer                                                               |
+| `./vue`          | `vue` runtime re-exports                                                                                             |
+| `./compiler-sfc` | `vue/compiler-sfc` re-exports                                                                                        |
+| `./reactive`     | native refs/`shallowRef`, `toRef`/`toRefs`/`unref`/`isRef`, `reactive`/`isReactive`, `computed`, synchronous `watch` |
+| `./context`      | native component `provide`, `inject`, `hasInjectionContext`                                                          |
+| `./text`         | native DOM and SSR interpolation conversion                                                                          |
+| `./props`        | compiler-facing shallow declared props and owned parent refresh                                                      |
+| `./events`       | compiler-facing typed component callbacks, callback arrays and per-instance once delivery                            |
+| `./normalize`    | native class/style normalization and compiler-facing DOM/SSR policies                                                |
+
+`./framework` exports the same lazy `crepusRenderer` compatibility name as the
+root. Its optional `@tschk/moonshine-framework` peer is needed only when rendering.
+Pages must use explicit `@tschk/moonshine-dom/ssr` server factories. Existing
+React IR pages need to be ported; this facade does not render React components.
+The compatibility root renderer loads source files under Bun. Bundled deployments use
+`@tschk/moonshine-dom/framework-native` with their bundled module table.
+
+Legacy peer: `vue` >= 3, needed only for `/vue` and `/compiler-sfc`.
+
+Native `watch` requires `{ flush: "sync" }`; component scheduling, deep watches,
+and Vue collection proxies are not implemented by this entry. Plain objects and
+arrays are reactive; nested refs unwrap on object properties and retain their
+identity at integer array entries.
+Each watcher run can register multiple cleanup callbacks. Reruns and stops drain
+them in registration order, attempt all callbacks after a failure, and preserve
+the first error. A cleanup that stops its watcher prevents another callback run.
+
+### Optional native watch errors
+
+`./errors` exports `withComponentErrorHandler(handler, setup)`, which requires a
+live native owner and scopes work created synchronously by `setup`. It handles
+function-source getter errors, `watch` callbacks, `watchSyncEffect` bodies and each
+registered watcher cleanup. The handler runs synchronously and untracked with the
+original thrown value and `{ component, phase }`. The finite phase labels are
+`"watch getter"`, `"watch callback"`, `"watch effect"` and `"watch cleanup"`.
+`component` is the native frame or `undefined`, not a Vue public instance.
+Getter/effect bodies keep their normal tracking; handled getter errors yield
+`undefined`, and handled cleanup errors allow peers and the next run to continue.
+Source reads do not restart recursively when getter reporting writes the source;
+callback feedback remains synchronous and reentrant.
+
+Returned promises with callable `then` and `catch` report rejection through the
+captured handler/frame, including after owner disposal. A then-only object is
+ignored. A throwing `.catch` method escapes its caller. A handler that throws
+logs its secondary error once; genuine reentrant watch errors invoke it again.
+
+Without this scope, existing native throwing and `catchError` behavior remains.
+Other error phases retain their existing handling. This is not Vue's app
+configuration or `onErrorCaptured`, and adds no watcher or component frame.
+
+`toRef` preserves existing native refs, creates live writable property aliases,
+and wraps getters in readonly refs without caching their results. Its optional
+property default applies only to `undefined`; an alias does not make a plain
+source object reactive. Function-valued properties and
+defaults stay literal. `unref` unwraps native refs once and never calls functions.
+`isRef` recognizes only this entry's native refs, including computed/getter refs;
+it does not accept Vue host refs or objects with a spoofed `__v_isRef` flag.
+
+`shallowRef` stores raw values unchanged and tracks replacement of `.value` using
+`Object.is` equality. It preserves existing native refs, existing reactive proxies,
+and literal function values. Nested raw mutations do not notify; an already
+reactive proxy keeps its own tracking. This supports external snapshots without
+deep conversion. `triggerRef` is not implemented.
+
+Native computed refs are lazy and cached, propagate previous successful values,
+and keep writable setters. Stopping an owner releases its watchers without
+freezing separately retained computed refs.
+
+The local Crepuscularity compiler now lowers the bounded typed setup counter
+through real DOM/SSR module graphs without Vue. It supports imported native
+ref/computed helpers, stable function handlers, interpolation and live props;
+strict public prop types and independent instances are verified. Inline and
+imported finite prop interfaces support shallow local writes/deletes and
+coalesced parent refresh. Scoped/module styles, entities, unsupported whitespace, dynamic
+handlers, non-finite defaults and unsupported Boolean prop variants still diagnose. Nested Vue render
+scheduling, effectful parent getter timing, general component composition and
+the VNode ABI remain incomplete. These compiler changes are local and unreleased.
+
+Native `./context` provides `provide`, `inject`, `hasInjectionContext`, and typed
+`InjectionKey` symbols during synchronous native component initialization. Injection
+searches ancestors, never the same component's own providers. Nearest ancestors
+shadow outer values, including explicitly provided `undefined`; refs stay refs.
+Defaults are values unless the third argument is `true`, which invokes a missing
+value's factory untracked. Factories have no Vue public-instance `this` receiver.
+Outside initialization, `provide`/`inject` throw; `hasInjectionContext` returns false.
+This supports DOM and SSR component scopes, not Vue app-level injection or
+`app.runWithContext`, and does not establish full SFC compiler compatibility.
+
+### Optional native lifecycle
+
+`@tschk/moonshine-vue/lifecycle` exports `onMounted`, `onBeforeUnmount`, and
+`onUnmounted`. Register synchronously during native component initialization, or
+register `onUnmounted` inside an `onMounted` or `onBeforeUnmount` callback.
+SSR skips all three. Mounted hooks run after synchronous children and DOM commits,
+with pending component references published first. Disposed components skip queued
+mounts. Before-unmount hooks run parent first with DOM and watchers still active;
+unmounted hooks run child first after DOM removal and reactive teardown. Callbacks
+are untracked; returned cleanup functions are ignored. Mounted callbacks flush
+pending references first, recheck that the owner is live, then invoke the hook
+with its component context. Mounted and before-unmount callbacks restore the previous
+context even when they throw. Registration from an already disposed owner,
+including an unmounted callback, is rejected.
+
+This optional entry has no Vue dependency. It does not provide Vue public-instance
+receivers, app lifecycle, update hooks, async component/Suspense scheduling, or
+full SFC compatibility. Crepus lowers named/aliased imports of these three hooks
+in the accepted authored source slice. Permanent DOM/SSR fixtures verify nested
+registration, connected mount/before phases, disconnected child-first cleanup,
+two instances and server callback suppression. Template refs and Vue's full
+error-handler policy remain unproven. A failed native mounted hook tears down
+its owner; the reference can retain the subtree until unmount.
+
+Callback failures propagate after pending peers and disposal finish. Native
+exported-instance reference cleanup remains deferred; Vue template-ref lowering
+is still pending.
+
+A watch started under an already disposed native owner throws. Ownerless watches
+remain manually stoppable.
+
+`./reactive` also exports `watchSyncEffect(effect)`, returning a stop function.
+The effect runs immediately and tracks synchronous reads, including conditional
+sources. Its supplied cleanup registrar accepts multiple callbacks, including
+late registrations while active; registrations after stopping are ignored.
+Cleanup runs untracked before reruns and on stop. Writes made by the effect or
+its cleanup do not recursively invoke that same effect; cleanup writes remain
+visible to the following run. Native owners stop their effects on disposal;
+ownerless effects require manual stopping. SSR sync effects run and stop with the
+request owner. Promise continuations are not tracked.
+
+Cleanup attempts every registered callback and propagates the first failure;
+failed effect runs release their registered cleanup while preserving the effect
+error. This follows native error handling rather than Vue's app error handler.
+This entry does not supply scheduled `watchEffect`, pause/resume handles, or a
+Vue component render scheduler.
+
+`./reactive` exports `toRefs(object)` for destructuring linked properties without
+losing live reads or writes. It snapshots enumerable string keys (including
+inherited keys), omits symbols and preserves array length and holes. Properties
+added later need `toRef(object, key)`. Existing native refs retain their identity.
+Getter/setter descriptors keep their source receiver; writes to getter-only
+properties throw. This does not implement Vue readonly-proxy warnings or SFC
+compilation.
+
+`./text` exports `toDisplayString` for DOM interpolation and
+`toDisplayStringSSR` for SSR. Both preserve Vue's conversion of nullish values,
+native refs, arrays, objects, maps, sets and symbols without invoking function
+values. DOM conversion can return `undefined` when an object's `toJSON` does;
+SSR converts that result to the literal string `"undefined"`. These helpers
+produce text, and the renderer handles HTML escaping. This optional entry adds
+no host dependency and does not establish Vue SFC or VNode compatibility.
+
+Reactive object and array property updates use `Object.is`: writing negative
+zero after positive zero notifies, while repeating NaN does not. Nested values
+and accessor setter receivers retain this policy. This is specific to the Vue
+entry; native `createMutable` keeps strict equality by default.
+
+`./props` exports compiler-facing `createProps(source, declaredKeys)` and
+`createServerProps(source, declaredKeys)`. Initial props are shallow snapshots
+with own optional keys, preserving nested objects and functions. DOM local
+writes/deletes are reactive; later parent changes coalesce in one owned
+microtask, and unchanged final parent values preserve local overrides. Nested
+props refreshes drain in that same microtask in setup order, so a queued child
+sees its parent's final snapshot. Disposal drops pending refreshes. Server
+snapshots remain independent per request.
+The compiler resolves finite declared keys through its existing safe module
+resolver; unresolved shapes diagnose rather than guessing keys.
+
+Imported PascalCase child components now have real CLI DOM/SSR source proof for
+explicit props-only calls. Parent and child snapshots settle in one props
+microtask in either enqueue order while retaining child state, nodes and focus.
+The permanent source gate includes two independent instances and fresh escaped
+SSR requests. Static default slots have the separate source proof below. Typed component events now have separate real CLI DOM/SSR and production browser proof; the permanent source gate includes these cases. Attrs fallthrough remains unsupported. The bounded lifecycle imports above have separate source proof.
+Native disposal removes retained-node
+listeners; Vue can still invoke a listener on a saved detached button.
+
+This props-only queue does not implement Vue's nested renderer jobs, `nextTick`
+or immediate DOM timing. Parent getters are observed synchronously; local DOM
+effects retain native timing. Setter failures preserve the first error and
+allow sibling refresh/retry, deliberately avoiding the reference's cleanup bugs.
+
+Assigning a reactive child back into a parent preserves its identity and raw
+storage, including array entries and mutation methods. Deep refs, shallow refs,
+and reactive properties all use `Object.is` replacement equality.
+
+Plain unscoped Vue CSS now travels as inventoried build assets through the normal
+Bun stylesheet output and SSR route links. Repeated component instances share
+the stylesheet; whitespace-only blocks emit no assets. The 458-module source
+gate covers unchanged CSS bytes, strict generated types, browser colors and
+fresh escaped SSR. No Vue runtime is imported for this path.
+
+Scoped/module CSS, preprocessors, external styles, URLs, imports, escapes and
+`v-bind` CSS still reject. The graph reader uses Bun's CSS parser and reads only
+the declared inventory; this does not claim PostCSS validation parity.
+
+The optional compiler-private `./slots` entry supports implicit static default
+content and static default outlets. Authored source tests verify repeated
+outlets, lazy fallback, child consumer injection, live parent values, child prop
+refresh, retained leaf state/focus and independent instances through DOM and SSR.
+DOM content owns one attached scope for cache lifetime and failed-factory
+rollback; it adds no component frame. Ordinary Vue modules import no slot helper.
+
+The shared permanent gate covers 734 generated modules and all 728 emitted
+TypeScript modules under both strict checkers using frozen combined
+compiler `82e517ca`. Named/scoped/dynamic slots still reject.
+Native granular updates skip unrelated fallback function calls that Vue
+component jobs repeat; those call-count traces deliberately differ. This does
+not supply Vue's component render scheduler or promise full ABI compatibility.
+
+The optional `/events` helper lowers inline typed tuple-map `defineEmits` declarations and stable parent `@event` handlers, including `.once`. Declared props exclude event callbacks. DOM callbacks stop with their component owner; SSR callbacks remain callable after rendering, matching the bounded reference cases. Native DOM updates and error routing retain Moonshine semantics. Event validators, model events, arbitrary event names and attrs fallthrough still diagnose. This does not establish Vue scheduler or compiler ABI compatibility.
+
+Declared component class/style props now retain literal versus expression provenance in Crepus. The optional `/normalize` entry handles nested class values, static declaration strings, dynamic styles and reactive object cloning with separate DOM/SSR policies. Fresh actual Vue 3.5.13 comparisons pass Unicode whitespace, falsy values, constant aliases, proxy identity, narrow typed styles, retained local state/focus, cleanup and two fresh SSR renders. Intrinsic dynamic class/style, undeclared fallthrough and other directives remain separate work. Merged `__proto__` style keys are safe own data properties; this intentionally differs from the reference prototype setter.
+
+Boolean-bearing finite `defineProps` types now use compiler-only
+`createBooleanProps` / `createServerBooleanProps` from `/props`; ordinary props
+use their original exports and omit the resolver from bundles. The compiler
+retains Boolean/String union order, distinguishes absence from explicit
+undefined, accepts proven declared ASCII hyphen aliases and precasts empty/name
+literals without widening public prop types. Pure optional Boolean setup values
+are internally required; mixed unions remain optional. Fresh source graphs pass
+both strict checkers for both targets and actual Vue 3.5.13 Chromium/SSR comparisons.
+
+Duplicate canonical/alias bindings, ambiguous Boolean intersections, literal
+hyphen declarations mixed with casts, Boolean id/class/style declarations,
+non-ASCII nonempty name-literal casts remain explicit gaps.
+Finite defaults have separate shallow readonly typing; full Vue render jobs and broader macro typing remain incomplete.
+
+### Compiler-facing defaults
+
+The optional `/props` entry includes `createDefaultProps`,
+`createServerDefaultProps`, `DefaultValues`, and `withVueScheduler` for native
+compiler integration. The finite default tuples specify literal values versus
+factories. Factories receive each instance's stable raw props object, run in its
+consumer context, and cache successful results including `undefined`. Setup
+props are shallow readonly in TypeScript; the caller's props remain optional
+where declared. These helpers do not install runtime readonly proxies.
+
+The component carrier gates render work while defaults prepare. Successful
+preparation refreshes that component's render callbacks; failed preparation
+keeps its previous DOM until a later successful parent props commit. Independent
+child component groups remain live. It reuses existing native owners and DOM
+controls and guards feedback at 1,000 render or post waves. Ordinary native DOM
+rendering remains synchronous without the carrier.
+
+Finite typed source `withDefaults` now has real CLI, strict caller, Chromium and
+fresh SSR acceptance, including ordered factories, cached undefined, Boolean
+fallbacks and failed refresh recovery. Spreads, accessors, setup-value captures,
+nested macros and unresolved default shapes still diagnose. Outer casts and
+satisfies constraints retain their type checks.
+
+This is a compiler-private contract, not Vue's complete component job or app
+error policy. Render-expression evaluation and fallback, props-job error
+attribution, and full Vue lifecycle timing remain separate work. The optional `/errors` scope handles watch phases; it does not
+turn a default factory failure into an app error handler call.
+
+### Optional native application mount
+
+`@tschk/moonshine-vue/app` exports `createApp(component, props)` for native
+component factories, including Crepus-compiled Vue components. Props retain the
+factory's public type. The returned native application has only `mount(target)`
+and `unmount()`; `mount` returns `void`, not a Vue public instance.
+
+`mount` accepts a selector, Element or ShadowRoot in the current DOM realm,
+clears its existing children and mounts one owned root. A private container lease
+rejects another app before clearing and remains held until teardown finishes.
+Invalid targets leave
+DOM unchanged and allow a corrected attempt. Once rendering starts, a failed or
+successful attempt is terminal; mounting again throws. `unmount` is idempotent;
+before mounting it is a no-op, and during synchronous mounting it requests
+cleanup when that mount finishes. Failed setup/mounting and rejected promise or
+VNode results release owned work. Accessor children retain native tracking.
+
+This entry adds no Vue scheduler group, VNode renderer, Options API, application
+configuration, public instance, runtime template compiler or hydration. Use native
+factories and native DOM children; the separate legacy `/vue` and `/compiler-sfc`
+entries and their optional peer are unchanged.

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@tschk/moonshine-vue",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.4",
+  "description": "Native composition helpers and signal bridges with optional legacy Vue runtime/compiler entries",
+  "license": "ISC",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./vue": "./src/vue.ts",
+    "./reactive": "./src/reactive.ts",
+    "./compiler-sfc": "./src/compiler-sfc.ts",
+    "./framework": "./src/framework.ts",
+    "./context": "./src/context.ts",
+    "./lifecycle": "./src/lifecycle.ts",
+    "./text": "./src/text.ts",
+    "./props": "./src/props.ts",
+    "./slots": "./src/slots.ts",
+    "./events": "./src/events.ts",
+    "./normalize": "./src/normalize.ts",
+    "./errors": "./src/errors.ts",
+    "./app": "./src/app.ts"
+  },
+  "dependencies": {
+    "@tschk/moonshine": "^0.4.4",
+    "@tschk/moonshine-dom": "^0.4.4"
+  },
+  "devDependencies": {
+    "typescript": "7.0.2"
+  },
+  "peerDependencies": {
+    "vue": ">=3",
+    "@tschk/moonshine-framework": "^0.4.4"
+  },
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": true
+    },
+    "@tschk/moonshine-framework": {
+      "optional": true
+    }
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "moonshine",
+    "vue",
+    "adapter"
+  ],
+  "scripts": {
+    "format": "bunx prettier --check .",
+    "lint": "bunx oxlint .",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test"
+  }
+}

package/src/app.ts

@@ -0,0 +1,97 @@
+import { h, render, type DOMChild } from "@tschk/moonshine-dom/dom";
+
+export interface NativeApplication {
+  mount(target: string | Element | ShadowRoot): void;
+  unmount(): void;
+}
+
+const leases = /* @__PURE__ */ new WeakMap<
+  Element | ShadowRoot,
+  NativeApplication
+>();
+
+// Validate async/VNode results without evaluating accessor children ahead of insert.
+function content(value: DOMChild): DOMChild {
+  if (typeof value === "function") return () => content(value());
+  if (Array.isArray(value)) return value.map(content);
+  if (value !== null && typeof value === "object" && !(value instanceof Node)) {
+    if (value instanceof Promise)
+      void Promise.prototype.then.call(value, undefined, () => {});
+    throw new TypeError(
+      "Native applications require DOM children, not promises or VNodes",
+    );
+  }
+  return value;
+}
+
+/** Mount a native compiled/component factory; this does not execute Vue VNodes. */
+export function createApp<P extends object>(
+  component: (props: P) => DOMChild,
+  props: P,
+): NativeApplication {
+  if (typeof component !== "function")
+    throw new TypeError("Native applications require a component factory");
+  if (props === null || typeof props !== "object" || Array.isArray(props))
+    throw new TypeError("Native application props must be an object");
+  let state: "new" | "mounting" | "mounted" | "stopped" = "new";
+  let stop: (() => void) | undefined;
+  const stopped = () => state === "stopped";
+  const unmount = () => {
+    if (state === "new" || state === "stopped") return;
+    state = "stopped";
+    const dispose = stop;
+    stop = undefined;
+    dispose?.();
+  };
+  const app: NativeApplication = {
+    mount(target) {
+      if (state !== "new")
+        throw new Error("Native application cannot be mounted again");
+      if (typeof document === "undefined")
+        throw new Error("Native application mount requires a DOM");
+      const container =
+        typeof target === "string" ? document.querySelector(target) : target;
+      if (!(container instanceof Element) && !(container instanceof ShadowRoot))
+        throw new TypeError(
+          "Native application mount target was not found or is invalid",
+        );
+      if (leases.has(container))
+        throw new Error("Native application mount target is already owned");
+      const release = () => {
+        if (leases.get(container) === app) leases.delete(container);
+      };
+      // Clearing and disposal can synchronously reenter another app mount.
+      leases.set(container, app);
+      state = "mounting";
+      try {
+        container.replaceChildren();
+        if (stopped()) {
+          release();
+          return;
+        }
+        const dispose = render(
+          () => h((input: P) => content(component(input)), props),
+          container,
+        );
+        const finish = () => {
+          try {
+            dispose();
+          } finally {
+            release();
+          }
+        };
+        if (stopped()) finish();
+        else {
+          stop = finish;
+          state = "mounted";
+        }
+      } catch (error) {
+        release();
+        state = "stopped";
+        throw error;
+      }
+    },
+    unmount,
+  };
+  return app;
+}

package/src/compiler-sfc.ts

@@ -0,0 +1 @@
+export { parse, compileScript, compileTemplate } from "vue/compiler-sfc";

package/src/context.ts

@@ -0,0 +1,59 @@
+/** Native component injection; no Vue app or public-instance runtime. */
+import {
+  getComponentContext,
+  peekComponentContext,
+  setContext,
+  type ComponentContext,
+} from "@tschk/moonshine-dom/component";
+import { untrack } from "@tschk/moonshine-dom/reactive";
+
+declare const injectionType: unique symbol;
+export type InjectionKey<T> = symbol & { readonly [injectionType]?: T };
+const providesKey = Symbol("moonshine.vue.provides");
+type Provides = {
+  frame: ComponentContext;
+  parent?: Provides;
+  values: Map<string | symbol, unknown>;
+};
+function layer(frame: ComponentContext): Provides | undefined {
+  return frame.contexts.get(providesKey) as Provides | undefined;
+}
+export function provide<T>(key: InjectionKey<T> | string, value: T): void {
+  const frame = getComponentContext();
+  let current = layer(frame);
+  if (current?.frame !== frame) {
+    current = { frame, parent: current, values: new Map() };
+    setContext(providesKey, current);
+  }
+  current.values.set(key, value);
+}
+export function inject<T>(key: InjectionKey<T> | string): T | undefined;
+export function inject<T>(
+  key: InjectionKey<T> | string,
+  defaultValue: T,
+  treatDefaultAsFactory?: false,
+): T;
+export function inject<T>(
+  key: InjectionKey<T> | string,
+  defaultValue: () => T,
+  treatDefaultAsFactory: true,
+): T;
+export function inject<T>(
+  key: InjectionKey<T> | string,
+  defaultValue?: T | (() => T),
+  treatDefaultAsFactory = false,
+): T | undefined {
+  const frame = getComponentContext();
+  let current = layer(frame);
+  if (current?.frame === frame) current = current.parent;
+  for (; current; current = current.parent) {
+    if (current.values.has(key)) return current.values.get(key) as T;
+  }
+  return treatDefaultAsFactory && typeof defaultValue === "function"
+    ? untrack(() => (defaultValue as () => T)())
+    : (defaultValue as T | undefined);
+}
+export function hasInjectionContext(): boolean {
+  const frame = peekComponentContext();
+  return !!frame?.active && !frame.owner.disposed;
+}

package/src/error-context.ts

@@ -0,0 +1,57 @@
+/** Private callback policy; no Vue app/public-instance ABI. */
+import {
+  peekComponentContext,
+  type ComponentContext,
+} from "@tschk/moonshine-dom/component";
+import { getOwner, untrack } from "@tschk/moonshine-dom/reactive";
+export type WatchErrorPhase =
+  "watch getter" | "watch callback" | "watch effect" | "watch cleanup";
+export type ComponentErrorInfo = {
+  readonly component: ComponentContext | undefined;
+  readonly phase: WatchErrorPhase;
+};
+export type ComponentErrorHandler = (
+  error: unknown,
+  info: ComponentErrorInfo,
+) => void;
+export type ErrorDispatcher = (error: unknown, phase: WatchErrorPhase) => void;
+export const componentErrorKey = /* @__PURE__ */ Symbol(
+  "moonshine.vue.callback-error",
+);
+export function captureWatchErrorHandler(): ErrorDispatcher | undefined {
+  const handler = getOwner()?.context?.get(componentErrorKey) as
+    ComponentErrorHandler | undefined;
+  if (!handler) return;
+  const component = peekComponentContext();
+  return (error, phase) => {
+    try {
+      untrack(() => handler(error, { component, phase }));
+    } catch (secondary) {
+      console.error(secondary);
+    }
+  };
+}
+export function invokeWatch<T>(
+  report: ErrorDispatcher,
+  phase: WatchErrorPhase,
+  fn: () => T,
+): T | undefined {
+  let result: T;
+  try {
+    result = fn();
+  } catch (error) {
+    report(error, phase);
+    return;
+  }
+  // Attach outside the user-call guard: a throwing .catch method must escape.
+  if (
+    result !== null &&
+    (typeof result === "object" || typeof result === "function") &&
+    typeof (result as { then?: unknown }).then === "function" &&
+    typeof (result as { catch?: unknown }).catch === "function"
+  )
+    (
+      result as unknown as { catch(reject: (error: unknown) => void): unknown }
+    ).catch((error) => report(error, phase));
+  return result;
+}

package/src/errors.ts

@@ -0,0 +1,24 @@
+/** Explicit native error scope; does not construct a Vue application. */
+import { createComponentScope, getOwner } from "@tschk/moonshine-dom/reactive";
+import { componentErrorKey, type ComponentErrorHandler } from "./error-context";
+export type {
+  ComponentErrorHandler,
+  ComponentErrorInfo,
+  WatchErrorPhase,
+} from "./error-context";
+export function withComponentErrorHandler<T>(
+  handler: ComponentErrorHandler,
+  setup: () => T,
+): T {
+  if (typeof handler !== "function" || typeof setup !== "function")
+    throw new TypeError("Error handler and setup must be functions");
+  const owner = getOwner();
+  if (!owner || owner.disposed)
+    throw Error("Component error scope requires a live owner");
+  return createComponentScope(() => {
+    const scope = getOwner()!;
+    scope.context = new Map(scope.context);
+    scope.context.set(componentErrorKey, handler);
+    return setup();
+  });
+}