@tallyrow/safesignal 1.2.0 → 1.4.0

package/dist/framework-react.d.cts

@@ -0,0 +1,97 @@
+import { Component, ReactNode, Context, ErrorInfo, ReactElement } from 'react';
+import { f as Logger, b as Attributes } from './types-CZtSjgq5.cjs';
+
+/**
+ * React error handling — the `./framework-react` subpath.
+ *
+ * The **no-globals, React-native counterpart** to `./capture`: a per-component
+ * `<LogErrorBoundary>` plus a `useLogError()` hook that route React errors
+ * through a consumer-provided `Logger`'s existing secure pipeline (sanitize →
+ * URL-scrub → redact → guard → transport) by calling `logger.error(...)`. Where
+ * `./capture` is a single host-level *global* install, this is explicit,
+ * per-subtree, and side-effect-free — it patches nothing and attaches no global
+ * listeners.
+ *
+ * Properties (see `specs/018-react-error-boundary/contracts/framework-react.md`):
+ *   - Fail-closed: emits via `logger.error`, so messages / stacks / component
+ *     stacks are redacted + sanitized (drop-on-failure) before any transport.
+ *   - Fail-safe: a logging (or `onError`) throw is swallowed; the fallback still
+ *     renders and nothing propagates to the page (Principle III). React's own
+ *     semantics keep it loop-free (a boundary does not catch errors thrown while
+ *     rendering its own fallback).
+ *   - No-globals: no `window.onerror`, no `addEventListener`, no monkey-patching,
+ *     no timers, no ambient reads (Principle VIII).
+ *   - Framework-neutral-preserving: `react` is an externalized **peer** import,
+ *     so the core entry and every other subpath stay React-free (Principle IV).
+ *
+ * The only intra-package `src/` import is **type-only** from `../api/types.js`;
+ * the single runtime external is `react` (the consumer-provided peer). No
+ * runtime state is shared with the core — the helpers operate solely through the
+ * passed/contextual `Logger`.
+ */
+
+/**
+ * React context carrying the consumer's `Logger` for a subtree. Default
+ * `undefined` — when no provider/override resolves a logger the helpers are a
+ * safe no-op (they never mint a fallback logger, which would couple this bundle
+ * to the core runtime). React-scoped, never a global registry.
+ */
+declare const LoggerContext: Context<Logger | undefined>;
+/** Props for {@link LoggerProvider}. */
+interface LoggerProviderProps {
+    /** The consumer's configured `Logger`, shared with the subtree. */
+    logger: Logger;
+    children?: ReactNode;
+}
+/**
+ * Supplies a `Logger` to {@link LogErrorBoundary} / {@link useLogError} within a
+ * subtree. Pure context plumbing — no globals, no side effects.
+ */
+declare function LoggerProvider(props: LoggerProviderProps): ReactElement;
+/** A node, or a render-prop given the caught error + a reset callback. */
+type FallbackRender = ReactNode | ((error: unknown, reset: () => void) => ReactNode);
+/** Props for {@link LogErrorBoundary}. */
+interface LogErrorBoundaryProps {
+    children?: ReactNode;
+    /** Explicit logger override; falls back to {@link LoggerContext}. */
+    logger?: Logger;
+    /** Rendered when an error is caught. Default: `null` (render nothing). */
+    fallback?: FallbackRender;
+    /** Optional consumer hook, invoked fail-safe AFTER logging. */
+    onError?: (error: unknown, info: {
+        componentStack: string;
+    }) => void;
+    /** Changing any key (shallow compare) clears caught state + re-mounts. */
+    resetKeys?: ReadonlyArray<unknown>;
+}
+interface LogErrorBoundaryState {
+    caught: boolean;
+    error: unknown;
+}
+/**
+ * Catches descendant render / lifecycle / constructor errors, logs them through
+ * the resolved `Logger` (with the React component stack), and renders a fallback
+ * in place of the crashed subtree. Errors React cannot catch this way (event
+ * handlers, async) belong to {@link useLogError}.
+ */
+declare class LogErrorBoundary extends Component<LogErrorBoundaryProps, LogErrorBoundaryState> {
+    static contextType: Context<Logger | undefined>;
+    context: Logger | undefined;
+    constructor(props: LogErrorBoundaryProps);
+    static getDerivedStateFromError(error: unknown): LogErrorBoundaryState;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    componentDidUpdate(prevProps: LogErrorBoundaryProps): void;
+    reset(): void;
+    render(): ReactNode;
+}
+/**
+ * Returns a **stable** callback that logs an error through the resolved logger
+ * (`loggerOverride` ?? {@link LoggerContext}) as an `error`-level event — for the
+ * errors a boundary cannot catch (event handlers, async/`Promise` callbacks,
+ * effects). Fail-safe; a **safe no-op** when no logger resolves. The callback
+ * identity is stable across re-renders for a fixed resolved logger (safe in
+ * dependency arrays).
+ */
+declare function useLogError(loggerOverride?: Logger): (error: unknown, attributes?: Attributes) => void;
+
+export { LogErrorBoundary, type LogErrorBoundaryProps, LoggerContext, LoggerProvider, type LoggerProviderProps, useLogError };

package/dist/framework-react.d.ts

@@ -0,0 +1,97 @@
+import { Component, ReactNode, Context, ErrorInfo, ReactElement } from 'react';
+import { f as Logger, b as Attributes } from './types-CZtSjgq5.js';
+
+/**
+ * React error handling — the `./framework-react` subpath.
+ *
+ * The **no-globals, React-native counterpart** to `./capture`: a per-component
+ * `<LogErrorBoundary>` plus a `useLogError()` hook that route React errors
+ * through a consumer-provided `Logger`'s existing secure pipeline (sanitize →
+ * URL-scrub → redact → guard → transport) by calling `logger.error(...)`. Where
+ * `./capture` is a single host-level *global* install, this is explicit,
+ * per-subtree, and side-effect-free — it patches nothing and attaches no global
+ * listeners.
+ *
+ * Properties (see `specs/018-react-error-boundary/contracts/framework-react.md`):
+ *   - Fail-closed: emits via `logger.error`, so messages / stacks / component
+ *     stacks are redacted + sanitized (drop-on-failure) before any transport.
+ *   - Fail-safe: a logging (or `onError`) throw is swallowed; the fallback still
+ *     renders and nothing propagates to the page (Principle III). React's own
+ *     semantics keep it loop-free (a boundary does not catch errors thrown while
+ *     rendering its own fallback).
+ *   - No-globals: no `window.onerror`, no `addEventListener`, no monkey-patching,
+ *     no timers, no ambient reads (Principle VIII).
+ *   - Framework-neutral-preserving: `react` is an externalized **peer** import,
+ *     so the core entry and every other subpath stay React-free (Principle IV).
+ *
+ * The only intra-package `src/` import is **type-only** from `../api/types.js`;
+ * the single runtime external is `react` (the consumer-provided peer). No
+ * runtime state is shared with the core — the helpers operate solely through the
+ * passed/contextual `Logger`.
+ */
+
+/**
+ * React context carrying the consumer's `Logger` for a subtree. Default
+ * `undefined` — when no provider/override resolves a logger the helpers are a
+ * safe no-op (they never mint a fallback logger, which would couple this bundle
+ * to the core runtime). React-scoped, never a global registry.
+ */
+declare const LoggerContext: Context<Logger | undefined>;
+/** Props for {@link LoggerProvider}. */
+interface LoggerProviderProps {
+    /** The consumer's configured `Logger`, shared with the subtree. */
+    logger: Logger;
+    children?: ReactNode;
+}
+/**
+ * Supplies a `Logger` to {@link LogErrorBoundary} / {@link useLogError} within a
+ * subtree. Pure context plumbing — no globals, no side effects.
+ */
+declare function LoggerProvider(props: LoggerProviderProps): ReactElement;
+/** A node, or a render-prop given the caught error + a reset callback. */
+type FallbackRender = ReactNode | ((error: unknown, reset: () => void) => ReactNode);
+/** Props for {@link LogErrorBoundary}. */
+interface LogErrorBoundaryProps {
+    children?: ReactNode;
+    /** Explicit logger override; falls back to {@link LoggerContext}. */
+    logger?: Logger;
+    /** Rendered when an error is caught. Default: `null` (render nothing). */
+    fallback?: FallbackRender;
+    /** Optional consumer hook, invoked fail-safe AFTER logging. */
+    onError?: (error: unknown, info: {
+        componentStack: string;
+    }) => void;
+    /** Changing any key (shallow compare) clears caught state + re-mounts. */
+    resetKeys?: ReadonlyArray<unknown>;
+}
+interface LogErrorBoundaryState {
+    caught: boolean;
+    error: unknown;
+}
+/**
+ * Catches descendant render / lifecycle / constructor errors, logs them through
+ * the resolved `Logger` (with the React component stack), and renders a fallback
+ * in place of the crashed subtree. Errors React cannot catch this way (event
+ * handlers, async) belong to {@link useLogError}.
+ */
+declare class LogErrorBoundary extends Component<LogErrorBoundaryProps, LogErrorBoundaryState> {
+    static contextType: Context<Logger | undefined>;
+    context: Logger | undefined;
+    constructor(props: LogErrorBoundaryProps);
+    static getDerivedStateFromError(error: unknown): LogErrorBoundaryState;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    componentDidUpdate(prevProps: LogErrorBoundaryProps): void;
+    reset(): void;
+    render(): ReactNode;
+}
+/**
+ * Returns a **stable** callback that logs an error through the resolved logger
+ * (`loggerOverride` ?? {@link LoggerContext}) as an `error`-level event — for the
+ * errors a boundary cannot catch (event handlers, async/`Promise` callbacks,
+ * effects). Fail-safe; a **safe no-op** when no logger resolves. The callback
+ * identity is stable across re-renders for a fixed resolved logger (safe in
+ * dependency arrays).
+ */
+declare function useLogError(loggerOverride?: Logger): (error: unknown, attributes?: Attributes) => void;
+
+export { LogErrorBoundary, type LogErrorBoundaryProps, LoggerContext, LoggerProvider, type LoggerProviderProps, useLogError };

package/dist/framework-react.mjs

@@ -0,0 +1,87 @@
+import { createContext, Component, createElement, useContext, useCallback } from 'react';
+
+// src/framework-react/index.ts
+var SOURCE_BOUNDARY = "react-error-boundary";
+var SOURCE_HOOK = "react-use-log-error";
+var LoggerContext = createContext(void 0);
+function LoggerProvider(props) {
+  return createElement(
+    LoggerContext.Provider,
+    { value: props.logger },
+    props.children
+  );
+}
+function resetKeysChanged(prev, next) {
+  if (prev === next) return false;
+  if (prev === void 0 || next === void 0) return true;
+  if (prev.length !== next.length) return true;
+  for (let i = 0; i < prev.length; i += 1) {
+    if (!Object.is(prev[i], next[i])) return true;
+  }
+  return false;
+}
+var LogErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { caught: false, error: void 0 };
+    this.reset = this.reset.bind(this);
+  }
+  static getDerivedStateFromError(error) {
+    return { caught: true, error };
+  }
+  componentDidCatch(error, info) {
+    const componentStack = typeof info.componentStack === "string" ? info.componentStack : "";
+    const logger = this.props.logger ?? this.context;
+    try {
+      const attributes = { "safesignal.source": SOURCE_BOUNDARY };
+      if (componentStack) {
+        attributes["safesignal.react.componentStack"] = componentStack;
+      }
+      logger?.error("React render error", attributes, error);
+    } catch {
+    }
+    try {
+      this.props.onError?.(error, { componentStack });
+    } catch {
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (!this.state.caught) return;
+    if (resetKeysChanged(prevProps.resetKeys, this.props.resetKeys)) {
+      this.reset();
+    }
+  }
+  reset() {
+    this.setState({ caught: false, error: void 0 });
+  }
+  render() {
+    if (!this.state.caught) return this.props.children;
+    const { fallback } = this.props;
+    if (typeof fallback === "function") {
+      return fallback(this.state.error, this.reset);
+    }
+    return fallback ?? null;
+  }
+};
+LogErrorBoundary.contextType = LoggerContext;
+function useLogError(loggerOverride) {
+  const contextLogger = useContext(LoggerContext);
+  const logger = loggerOverride ?? contextLogger;
+  return useCallback(
+    (error, attributes) => {
+      try {
+        const attrs = {
+          "safesignal.source": SOURCE_HOOK,
+          ...attributes ?? {}
+        };
+        logger?.error("Reported error", attrs, error);
+      } catch {
+      }
+    },
+    [logger]
+  );
+}
+
+export { LogErrorBoundary, LoggerContext, LoggerProvider, useLogError };
+//# sourceMappingURL=framework-react.mjs.map
+//# sourceMappingURL=framework-react.mjs.map

package/dist/framework-react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/framework-react/index.ts"],"names":[],"mappings":"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","file":"framework-react.mjs","sourcesContent":["/**\n * React error handling — the `./framework-react` subpath.\n *\n * The **no-globals, React-native counterpart** to `./capture`: a per-component\n * `<LogErrorBoundary>` plus a `useLogError()` hook that route React errors\n * through a consumer-provided `Logger`'s existing secure pipeline (sanitize →\n * URL-scrub → redact → guard → transport) by calling `logger.error(...)`. Where\n * `./capture` is a single host-level *global* install, this is explicit,\n * per-subtree, and side-effect-free — it patches nothing and attaches no global\n * listeners.\n *\n * Properties (see `specs/018-react-error-boundary/contracts/framework-react.md`):\n *   - Fail-closed: emits via `logger.error`, so messages / stacks / component\n *     stacks are redacted + sanitized (drop-on-failure) before any transport.\n *   - Fail-safe: a logging (or `onError`) throw is swallowed; the fallback still\n *     renders and nothing propagates to the page (Principle III). React's own\n *     semantics keep it loop-free (a boundary does not catch errors thrown while\n *     rendering its own fallback).\n *   - No-globals: no `window.onerror`, no `addEventListener`, no monkey-patching,\n *     no timers, no ambient reads (Principle VIII).\n *   - Framework-neutral-preserving: `react` is an externalized **peer** import,\n *     so the core entry and every other subpath stay React-free (Principle IV).\n *\n * The only intra-package `src/` import is **type-only** from `../api/types.js`;\n * the single runtime external is `react` (the consumer-provided peer). No\n * runtime state is shared with the core — the helpers operate solely through the\n * passed/contextual `Logger`.\n */\n\nimport {\n  Component,\n  createContext,\n  createElement,\n  useCallback,\n  useContext,\n} from 'react';\nimport type { Context, ErrorInfo, ReactElement, ReactNode } from 'react';\nimport type { Attributes, Logger } from '../api/types.js';\n\n/** `safesignal.source` marker for boundary-caught render errors. */\nconst SOURCE_BOUNDARY = 'react-error-boundary';\n/** `safesignal.source` marker for errors reported via {@link useLogError}. */\nconst SOURCE_HOOK = 'react-use-log-error';\n\n/**\n * React context carrying the consumer's `Logger` for a subtree. Default\n * `undefined` — when no provider/override resolves a logger the helpers are a\n * safe no-op (they never mint a fallback logger, which would couple this bundle\n * to the core runtime). React-scoped, never a global registry.\n */\nexport const LoggerContext: Context<Logger | undefined> = createContext<\n  Logger | undefined\n>(undefined);\n\n/** Props for {@link LoggerProvider}. */\nexport interface LoggerProviderProps {\n  /** The consumer's configured `Logger`, shared with the subtree. */\n  logger: Logger;\n  children?: ReactNode;\n}\n\n/**\n * Supplies a `Logger` to {@link LogErrorBoundary} / {@link useLogError} within a\n * subtree. Pure context plumbing — no globals, no side effects.\n */\nexport function LoggerProvider(props: LoggerProviderProps): ReactElement {\n  return createElement(\n    LoggerContext.Provider,\n    { value: props.logger },\n    props.children,\n  );\n}\n\n/** A node, or a render-prop given the caught error + a reset callback. */\ntype FallbackRender =\n  | ReactNode\n  | ((error: unknown, reset: () => void) => ReactNode);\n\n/** Props for {@link LogErrorBoundary}. */\nexport interface LogErrorBoundaryProps {\n  children?: ReactNode;\n  /** Explicit logger override; falls back to {@link LoggerContext}. */\n  logger?: Logger;\n  /** Rendered when an error is caught. Default: `null` (render nothing). */\n  fallback?: FallbackRender;\n  /** Optional consumer hook, invoked fail-safe AFTER logging. */\n  onError?: (error: unknown, info: { componentStack: string }) => void;\n  /** Changing any key (shallow compare) clears caught state + re-mounts. */\n  resetKeys?: ReadonlyArray<unknown>;\n}\n\ninterface LogErrorBoundaryState {\n  caught: boolean;\n  error: unknown;\n}\n\n/** Shallow, order-sensitive comparison of two reset-key arrays. */\nfunction resetKeysChanged(\n  prev: ReadonlyArray<unknown> | undefined,\n  next: ReadonlyArray<unknown> | undefined,\n): boolean {\n  if (prev === next) return false;\n  if (prev === undefined || next === undefined) return true;\n  if (prev.length !== next.length) return true;\n  for (let i = 0; i < prev.length; i += 1) {\n    if (!Object.is(prev[i], next[i])) return true;\n  }\n  return false;\n}\n\n/**\n * Catches descendant render / lifecycle / constructor errors, logs them through\n * the resolved `Logger` (with the React component stack), and renders a fallback\n * in place of the crashed subtree. Errors React cannot catch this way (event\n * handlers, async) belong to {@link useLogError}.\n */\nexport class LogErrorBoundary extends Component<\n  LogErrorBoundaryProps,\n  LogErrorBoundaryState\n> {\n  static override contextType = LoggerContext;\n  declare context: Logger | undefined;\n\n  constructor(props: LogErrorBoundaryProps) {\n    super(props);\n    this.state = { caught: false, error: undefined };\n    this.reset = this.reset.bind(this);\n  }\n\n  static getDerivedStateFromError(error: unknown): LogErrorBoundaryState {\n    return { caught: true, error };\n  }\n\n  override componentDidCatch(error: unknown, info: ErrorInfo): void {\n    const componentStack =\n      typeof info.componentStack === 'string' ? info.componentStack : '';\n    const logger = this.props.logger ?? this.context;\n    try {\n      const attributes: Attributes = { 'safesignal.source': SOURCE_BOUNDARY };\n      if (componentStack) {\n        attributes['safesignal.react.componentStack'] = componentStack;\n      }\n      logger?.error('React render error', attributes, error);\n    } catch {\n      // Fail-safe: a logging failure must never escalate the original crash.\n    }\n    try {\n      this.props.onError?.(error, { componentStack });\n    } catch {\n      // Fail-safe: a consumer onError that throws must not break the fallback.\n    }\n  }\n\n  override componentDidUpdate(prevProps: LogErrorBoundaryProps): void {\n    if (!this.state.caught) return;\n    if (resetKeysChanged(prevProps.resetKeys, this.props.resetKeys)) {\n      this.reset();\n    }\n  }\n\n  reset(): void {\n    this.setState({ caught: false, error: undefined });\n  }\n\n  override render(): ReactNode {\n    if (!this.state.caught) return this.props.children;\n    const { fallback } = this.props;\n    if (typeof fallback === 'function') {\n      return fallback(this.state.error, this.reset);\n    }\n    return fallback ?? null;\n  }\n}\n\n/**\n * Returns a **stable** callback that logs an error through the resolved logger\n * (`loggerOverride` ?? {@link LoggerContext}) as an `error`-level event — for the\n * errors a boundary cannot catch (event handlers, async/`Promise` callbacks,\n * effects). Fail-safe; a **safe no-op** when no logger resolves. The callback\n * identity is stable across re-renders for a fixed resolved logger (safe in\n * dependency arrays).\n */\nexport function useLogError(\n  loggerOverride?: Logger,\n): (error: unknown, attributes?: Attributes) => void {\n  const contextLogger = useContext(LoggerContext);\n  const logger = loggerOverride ?? contextLogger;\n  return useCallback(\n    (error: unknown, attributes?: Attributes): void => {\n      try {\n        const attrs: Attributes = {\n          'safesignal.source': SOURCE_HOOK,\n          ...(attributes ?? {}),\n        };\n        logger?.error('Reported error', attrs, error);\n      } catch {\n        // Fail-safe: reporting an error must never throw into the caller.\n      }\n    },\n    [logger],\n  );\n}\n"]}

package/dist/framework-vue.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+var vue = require('vue');
+
+// src/framework-vue/index.ts
+var SOURCE_HANDLER = "vue-error-handler";
+var SOURCE_HOOK = "vue-use-log-error";
+var SOURCE_CAPTURED = "vue-error-captured";
+var loggerKey = /* @__PURE__ */ Symbol("safesignal.logger");
+function readName(obj) {
+  if (obj && typeof obj === "object") {
+    const name = obj.name;
+    if (typeof name === "string" && name.length > 0) return name;
+  }
+  return void 0;
+}
+function componentNameOf(instance) {
+  try {
+    if (!instance || typeof instance !== "object") return void 0;
+    const inst = instance;
+    return readName(inst.$options) ?? readName(inst.$?.type) ?? readName(inst.type);
+  } catch {
+    return void 0;
+  }
+}
+function emit(logger, source, message, error, extra, instance, info) {
+  if (!logger) return;
+  try {
+    const attributes = { "safesignal.source": source };
+    if (typeof info === "string" && info.length > 0) {
+      attributes["safesignal.vue.info"] = info;
+    }
+    const name = componentNameOf(instance);
+    if (name) attributes["safesignal.vue.componentName"] = name;
+    if (extra) {
+      for (const key of Object.keys(extra)) {
+        attributes[key] = extra[key];
+      }
+    }
+    logger.error(message, attributes, error);
+  } catch {
+  }
+}
+function createErrorHandler(logger) {
+  return (err, instance, info) => {
+    emit(logger, SOURCE_HANDLER, "Vue error", err, void 0, instance, info);
+  };
+}
+var safesignalErrorHandler = {
+  install(app, options) {
+    const { logger } = options;
+    app.config.errorHandler = createErrorHandler(logger);
+    app.provide(loggerKey, logger);
+  }
+};
+function useLogError(loggerOverride) {
+  const logger = loggerOverride ?? vue.inject(loggerKey);
+  return (error, attributes) => {
+    emit(logger, SOURCE_HOOK, "Reported error", error, attributes);
+  };
+}
+function useErrorCapture(options = {}) {
+  const logger = options.logger ?? vue.inject(loggerKey);
+  vue.onErrorCaptured((err, instance, info) => {
+    emit(
+      logger,
+      SOURCE_CAPTURED,
+      "Vue captured error",
+      err,
+      void 0,
+      instance,
+      info
+    );
+    try {
+      options.onError?.(err, info);
+    } catch {
+    }
+    return options.propagate ? void 0 : false;
+  });
+}
+
+exports.createErrorHandler = createErrorHandler;
+exports.loggerKey = loggerKey;
+exports.safesignalErrorHandler = safesignalErrorHandler;
+exports.useErrorCapture = useErrorCapture;
+exports.useLogError = useLogError;
+//# sourceMappingURL=framework-vue.cjs.map
+//# sourceMappingURL=framework-vue.cjs.map

package/dist/framework-vue.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/framework-vue/index.ts"],"names":["inject","onErrorCaptured"],"mappings":"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","file":"framework-vue.cjs","sourcesContent":["/**\n * Vue error handling — the `./framework-vue` subpath.\n *\n * The **no-globals, Vue-native counterpart** to `./capture` (and the sibling of\n * `./framework-react`): an `app.config.errorHandler` adapter plus composables\n * that route Vue component-tree errors through a consumer-provided `Logger`'s\n * existing secure pipeline (sanitize → URL-scrub → redact → guard → transport)\n * by calling `logger.error(...)`. Where `./capture` is a single host-level\n * *global* install, this is explicit, per-app / per-subtree, and\n * side-effect-free — it patches nothing and attaches no global listeners.\n *\n * Surface:\n *   - `createErrorHandler(logger)` — a side-effect-free factory returning a\n *     handler for `app.config.errorHandler`.\n *   - `safesignalErrorHandler` — a thin Vue plugin that wires the handler AND\n *     `app.provide(loggerKey, logger)`.\n *   - `loggerKey` — the `InjectionKey<Logger>` by which the plugin provides, and\n *     the composables inject, the logger (the Vue parallel of React's context).\n *   - `useLogError(loggerOverride?)` — a stable manual-report callback for errors\n *     Vue's handler cannot catch (async/try-catch, native listeners).\n *   - `useErrorCapture(options?)` — a subtree boundary wrapping `onErrorCaptured`\n *     (parallel of React's `<LogErrorBoundary>`) that logs descendant errors and,\n *     by default, stops propagation so the app-level handler does not double-log.\n *\n * Properties (see `specs/020-vue-error-handler/contracts/framework-vue.md`):\n *   - Fail-closed: emits via `logger.error`, so messages / stacks / the Vue info\n *     string are redacted + sanitized (drop-on-failure) before any transport.\n *   - Fail-safe: a logging (or `onError`) throw is swallowed; the original error\n *     is never escalated and the app keeps running (Principle III).\n *   - No-globals: no `window.onerror`, no `addEventListener`, no monkey-patching,\n *     no timers, no ambient reads (Principle VIII). Errors flow only through the\n *     resolved logger and Vue's own per-app / per-component error hooks.\n *   - Framework-neutral-preserving: `vue` is an externalized **peer** import, so\n *     the core entry and every other subpath stay Vue-free (Principle IV).\n *\n * The only intra-package `src/` import is **type-only** from `../api/types.js`;\n * the single runtime external is `vue` (the consumer-provided peer). No runtime\n * state is shared with the core — the helpers operate solely through the\n * passed/injected `Logger`.\n */\n\nimport {\n  type App,\n  type InjectionKey,\n  inject,\n  onErrorCaptured,\n  type Plugin,\n} from 'vue';\nimport type { Attributes, Logger } from '../api/types.js';\n\n/** `safesignal.source` marker for app-level (`app.config.errorHandler`) errors. */\nconst SOURCE_HANDLER = 'vue-error-handler';\n/** `safesignal.source` marker for errors reported via {@link useLogError}. */\nconst SOURCE_HOOK = 'vue-use-log-error';\n/** `safesignal.source` marker for subtree errors captured by {@link useErrorCapture}. */\nconst SOURCE_CAPTURED = 'vue-error-captured';\n\n/**\n * Vue injection key carrying the consumer's `Logger` for an app/subtree. When no\n * provider/override resolves a logger the helpers are a safe no-op (they never\n * mint a fallback logger, which would couple this bundle to the core runtime).\n * Vue-scoped, never a global registry.\n */\nexport const loggerKey: InjectionKey<Logger> = Symbol('safesignal.logger');\n\n/** The Vue app-level error-handler signature (matches `app.config.errorHandler`). */\nexport type VueErrorHandler = (\n  err: unknown,\n  instance: unknown,\n  info: string,\n) => void;\n\n/** Read a non-empty string `name` from an unknown object, else `undefined`. */\nfunction readName(obj: unknown): string | undefined {\n  if (obj && typeof obj === 'object') {\n    const name = (obj as { name?: unknown }).name;\n    if (typeof name === 'string' && name.length > 0) return name;\n  }\n  return undefined;\n}\n\n/**\n * Best-effort component name from a Vue instance (public or internal shape).\n * Wrapped + tolerant: returns `undefined` rather than throwing when the instance\n * is null, exotic, or nameless. Never reads props/state.\n */\nfunction componentNameOf(instance: unknown): string | undefined {\n  try {\n    if (!instance || typeof instance !== 'object') return undefined;\n    const inst = instance as {\n      $options?: unknown;\n      $?: { type?: unknown };\n      type?: unknown;\n    };\n    return (\n      readName(inst.$options) ?? readName(inst.$?.type) ?? readName(inst.type)\n    );\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Emit one `error`-level event through the resolved logger. Safe no-op when no\n * logger resolves; fail-safe — any throw in the logging path is swallowed so the\n * original error is never escalated.\n */\nfunction emit(\n  logger: Logger | undefined,\n  source: string,\n  message: string,\n  error: unknown,\n  extra?: Attributes,\n  instance?: unknown,\n  info?: string,\n): void {\n  if (!logger) return;\n  try {\n    const attributes: Attributes = { 'safesignal.source': source };\n    if (typeof info === 'string' && info.length > 0) {\n      attributes['safesignal.vue.info'] = info;\n    }\n    const name = componentNameOf(instance);\n    if (name) attributes['safesignal.vue.componentName'] = name;\n    if (extra) {\n      for (const key of Object.keys(extra)) {\n        attributes[key] = extra[key] as Attributes[string];\n      }\n    }\n    logger.error(message, attributes, error);\n  } catch {\n    // Fail-safe: a logging failure must never escalate the original error.\n  }\n}\n\n/**\n * Side-effect-free factory: given a `Logger`, returns a handler suitable for\n * `app.config.errorHandler`. Each invocation emits one `error`-level event\n * (`safesignal.source: 'vue-error-handler'`) via that logger; it attaches\n * nothing at creation and never throws.\n */\nexport function createErrorHandler(logger: Logger): VueErrorHandler {\n  return (err, instance, info) => {\n    emit(logger, SOURCE_HANDLER, 'Vue error', err, undefined, instance, info);\n  };\n}\n\n/** Options for the {@link safesignalErrorHandler} plugin. */\nexport interface SafesignalErrorHandlerOptions {\n  /** The consumer's configured `Logger`, used by the app handler and provided to descendants. */\n  logger: Logger;\n}\n\n/**\n * Vue plugin: `app.use(safesignalErrorHandler, { logger })` sets\n * `app.config.errorHandler = createErrorHandler(logger)` **and**\n * `app.provide(loggerKey, logger)`. No other side effects (no globals, no\n * timers, no listeners).\n */\nexport const safesignalErrorHandler: Plugin<SafesignalErrorHandlerOptions> = {\n  install(app: App, options: SafesignalErrorHandlerOptions): void {\n    const { logger } = options;\n    app.config.errorHandler = createErrorHandler(logger);\n    app.provide(loggerKey, logger);\n  },\n};\n\n/**\n * Returns a callback that logs an error through the resolved logger\n * (`loggerOverride` ?? injected {@link loggerKey}) as an `error`-level event —\n * for the errors a framework handler cannot catch (async/`Promise` callbacks,\n * `try/catch`, native `addEventListener`). Fail-safe; a **safe no-op** when no\n * logger resolves. Call this in `setup()`; the callback identity is stable for\n * the component's lifetime (Vue runs `setup` once).\n */\nexport function useLogError(\n  loggerOverride?: Logger,\n): (error: unknown, attributes?: Attributes) => void {\n  const logger = loggerOverride ?? inject(loggerKey);\n  return (error, attributes) => {\n    emit(logger, SOURCE_HOOK, 'Reported error', error, attributes);\n  };\n}\n\n/** Options for {@link useErrorCapture}. */\nexport interface UseErrorCaptureOptions {\n  /** Explicit logger override; falls back to the injected {@link loggerKey}. */\n  logger?: Logger;\n  /** Optional consumer hook, invoked fail-safe AFTER logging, with Vue's info string. */\n  onError?: (error: unknown, info: string) => void;\n  /** Keep propagating to ancestor/app handlers after logging. Default: false (stop). */\n  propagate?: boolean;\n}\n\n/**\n * Subtree boundary: registers `onErrorCaptured` in the calling component so a\n * descendant error is logged once via the resolved logger\n * (`safesignal.source: 'vue-error-captured'`). By **default it stops\n * propagation** (returns `false`) so the app-level handler does not also log it;\n * pass `{ propagate: true }` to keep it bubbling. The optional `onError` callback\n * is invoked fail-safe after logging. A safe no-op when no logger resolves.\n */\nexport function useErrorCapture(options: UseErrorCaptureOptions = {}): void {\n  const logger = options.logger ?? inject(loggerKey);\n  onErrorCaptured((err, instance, info) => {\n    emit(\n      logger,\n      SOURCE_CAPTURED,\n      'Vue captured error',\n      err,\n      undefined,\n      instance,\n      info,\n    );\n    try {\n      options.onError?.(err, info);\n    } catch {\n      // Fail-safe: a consumer onError that throws must not disrupt the app.\n    }\n    return options.propagate ? undefined : false;\n  });\n}\n"]}

package/dist/framework-vue.d.cts

@@ -0,0 +1,101 @@
+import { InjectionKey, Plugin } from 'vue';
+import { f as Logger, b as Attributes } from './types-CZtSjgq5.cjs';
+
+/**
+ * Vue error handling — the `./framework-vue` subpath.
+ *
+ * The **no-globals, Vue-native counterpart** to `./capture` (and the sibling of
+ * `./framework-react`): an `app.config.errorHandler` adapter plus composables
+ * that route Vue component-tree errors through a consumer-provided `Logger`'s
+ * existing secure pipeline (sanitize → URL-scrub → redact → guard → transport)
+ * by calling `logger.error(...)`. Where `./capture` is a single host-level
+ * *global* install, this is explicit, per-app / per-subtree, and
+ * side-effect-free — it patches nothing and attaches no global listeners.
+ *
+ * Surface:
+ *   - `createErrorHandler(logger)` — a side-effect-free factory returning a
+ *     handler for `app.config.errorHandler`.
+ *   - `safesignalErrorHandler` — a thin Vue plugin that wires the handler AND
+ *     `app.provide(loggerKey, logger)`.
+ *   - `loggerKey` — the `InjectionKey<Logger>` by which the plugin provides, and
+ *     the composables inject, the logger (the Vue parallel of React's context).
+ *   - `useLogError(loggerOverride?)` — a stable manual-report callback for errors
+ *     Vue's handler cannot catch (async/try-catch, native listeners).
+ *   - `useErrorCapture(options?)` — a subtree boundary wrapping `onErrorCaptured`
+ *     (parallel of React's `<LogErrorBoundary>`) that logs descendant errors and,
+ *     by default, stops propagation so the app-level handler does not double-log.
+ *
+ * Properties (see `specs/020-vue-error-handler/contracts/framework-vue.md`):
+ *   - Fail-closed: emits via `logger.error`, so messages / stacks / the Vue info
+ *     string are redacted + sanitized (drop-on-failure) before any transport.
+ *   - Fail-safe: a logging (or `onError`) throw is swallowed; the original error
+ *     is never escalated and the app keeps running (Principle III).
+ *   - No-globals: no `window.onerror`, no `addEventListener`, no monkey-patching,
+ *     no timers, no ambient reads (Principle VIII). Errors flow only through the
+ *     resolved logger and Vue's own per-app / per-component error hooks.
+ *   - Framework-neutral-preserving: `vue` is an externalized **peer** import, so
+ *     the core entry and every other subpath stay Vue-free (Principle IV).
+ *
+ * The only intra-package `src/` import is **type-only** from `../api/types.js`;
+ * the single runtime external is `vue` (the consumer-provided peer). No runtime
+ * state is shared with the core — the helpers operate solely through the
+ * passed/injected `Logger`.
+ */
+
+/**
+ * Vue injection key carrying the consumer's `Logger` for an app/subtree. When no
+ * provider/override resolves a logger the helpers are a safe no-op (they never
+ * mint a fallback logger, which would couple this bundle to the core runtime).
+ * Vue-scoped, never a global registry.
+ */
+declare const loggerKey: InjectionKey<Logger>;
+/** The Vue app-level error-handler signature (matches `app.config.errorHandler`). */
+type VueErrorHandler = (err: unknown, instance: unknown, info: string) => void;
+/**
+ * Side-effect-free factory: given a `Logger`, returns a handler suitable for
+ * `app.config.errorHandler`. Each invocation emits one `error`-level event
+ * (`safesignal.source: 'vue-error-handler'`) via that logger; it attaches
+ * nothing at creation and never throws.
+ */
+declare function createErrorHandler(logger: Logger): VueErrorHandler;
+/** Options for the {@link safesignalErrorHandler} plugin. */
+interface SafesignalErrorHandlerOptions {
+    /** The consumer's configured `Logger`, used by the app handler and provided to descendants. */
+    logger: Logger;
+}
+/**
+ * Vue plugin: `app.use(safesignalErrorHandler, { logger })` sets
+ * `app.config.errorHandler = createErrorHandler(logger)` **and**
+ * `app.provide(loggerKey, logger)`. No other side effects (no globals, no
+ * timers, no listeners).
+ */
+declare const safesignalErrorHandler: Plugin<SafesignalErrorHandlerOptions>;
+/**
+ * Returns a callback that logs an error through the resolved logger
+ * (`loggerOverride` ?? injected {@link loggerKey}) as an `error`-level event —
+ * for the errors a framework handler cannot catch (async/`Promise` callbacks,
+ * `try/catch`, native `addEventListener`). Fail-safe; a **safe no-op** when no
+ * logger resolves. Call this in `setup()`; the callback identity is stable for
+ * the component's lifetime (Vue runs `setup` once).
+ */
+declare function useLogError(loggerOverride?: Logger): (error: unknown, attributes?: Attributes) => void;
+/** Options for {@link useErrorCapture}. */
+interface UseErrorCaptureOptions {
+    /** Explicit logger override; falls back to the injected {@link loggerKey}. */
+    logger?: Logger;
+    /** Optional consumer hook, invoked fail-safe AFTER logging, with Vue's info string. */
+    onError?: (error: unknown, info: string) => void;
+    /** Keep propagating to ancestor/app handlers after logging. Default: false (stop). */
+    propagate?: boolean;
+}
+/**
+ * Subtree boundary: registers `onErrorCaptured` in the calling component so a
+ * descendant error is logged once via the resolved logger
+ * (`safesignal.source: 'vue-error-captured'`). By **default it stops
+ * propagation** (returns `false`) so the app-level handler does not also log it;
+ * pass `{ propagate: true }` to keep it bubbling. The optional `onError` callback
+ * is invoked fail-safe after logging. A safe no-op when no logger resolves.
+ */
+declare function useErrorCapture(options?: UseErrorCaptureOptions): void;
+
+export { type SafesignalErrorHandlerOptions, type UseErrorCaptureOptions, type VueErrorHandler, createErrorHandler, loggerKey, safesignalErrorHandler, useErrorCapture, useLogError };

package/dist/framework-vue.d.ts

@@ -0,0 +1,101 @@
+import { InjectionKey, Plugin } from 'vue';
+import { f as Logger, b as Attributes } from './types-CZtSjgq5.js';
+
+/**
+ * Vue error handling — the `./framework-vue` subpath.
+ *
+ * The **no-globals, Vue-native counterpart** to `./capture` (and the sibling of
+ * `./framework-react`): an `app.config.errorHandler` adapter plus composables
+ * that route Vue component-tree errors through a consumer-provided `Logger`'s
+ * existing secure pipeline (sanitize → URL-scrub → redact → guard → transport)
+ * by calling `logger.error(...)`. Where `./capture` is a single host-level
+ * *global* install, this is explicit, per-app / per-subtree, and
+ * side-effect-free — it patches nothing and attaches no global listeners.
+ *
+ * Surface:
+ *   - `createErrorHandler(logger)` — a side-effect-free factory returning a
+ *     handler for `app.config.errorHandler`.
+ *   - `safesignalErrorHandler` — a thin Vue plugin that wires the handler AND
+ *     `app.provide(loggerKey, logger)`.
+ *   - `loggerKey` — the `InjectionKey<Logger>` by which the plugin provides, and
+ *     the composables inject, the logger (the Vue parallel of React's context).
+ *   - `useLogError(loggerOverride?)` — a stable manual-report callback for errors
+ *     Vue's handler cannot catch (async/try-catch, native listeners).
+ *   - `useErrorCapture(options?)` — a subtree boundary wrapping `onErrorCaptured`
+ *     (parallel of React's `<LogErrorBoundary>`) that logs descendant errors and,
+ *     by default, stops propagation so the app-level handler does not double-log.
+ *
+ * Properties (see `specs/020-vue-error-handler/contracts/framework-vue.md`):
+ *   - Fail-closed: emits via `logger.error`, so messages / stacks / the Vue info
+ *     string are redacted + sanitized (drop-on-failure) before any transport.
+ *   - Fail-safe: a logging (or `onError`) throw is swallowed; the original error
+ *     is never escalated and the app keeps running (Principle III).
+ *   - No-globals: no `window.onerror`, no `addEventListener`, no monkey-patching,
+ *     no timers, no ambient reads (Principle VIII). Errors flow only through the
+ *     resolved logger and Vue's own per-app / per-component error hooks.
+ *   - Framework-neutral-preserving: `vue` is an externalized **peer** import, so
+ *     the core entry and every other subpath stay Vue-free (Principle IV).
+ *
+ * The only intra-package `src/` import is **type-only** from `../api/types.js`;
+ * the single runtime external is `vue` (the consumer-provided peer). No runtime
+ * state is shared with the core — the helpers operate solely through the
+ * passed/injected `Logger`.
+ */
+
+/**
+ * Vue injection key carrying the consumer's `Logger` for an app/subtree. When no
+ * provider/override resolves a logger the helpers are a safe no-op (they never
+ * mint a fallback logger, which would couple this bundle to the core runtime).
+ * Vue-scoped, never a global registry.
+ */
+declare const loggerKey: InjectionKey<Logger>;
+/** The Vue app-level error-handler signature (matches `app.config.errorHandler`). */
+type VueErrorHandler = (err: unknown, instance: unknown, info: string) => void;
+/**
+ * Side-effect-free factory: given a `Logger`, returns a handler suitable for
+ * `app.config.errorHandler`. Each invocation emits one `error`-level event
+ * (`safesignal.source: 'vue-error-handler'`) via that logger; it attaches
+ * nothing at creation and never throws.
+ */
+declare function createErrorHandler(logger: Logger): VueErrorHandler;
+/** Options for the {@link safesignalErrorHandler} plugin. */
+interface SafesignalErrorHandlerOptions {
+    /** The consumer's configured `Logger`, used by the app handler and provided to descendants. */
+    logger: Logger;
+}
+/**
+ * Vue plugin: `app.use(safesignalErrorHandler, { logger })` sets
+ * `app.config.errorHandler = createErrorHandler(logger)` **and**
+ * `app.provide(loggerKey, logger)`. No other side effects (no globals, no
+ * timers, no listeners).
+ */
+declare const safesignalErrorHandler: Plugin<SafesignalErrorHandlerOptions>;
+/**
+ * Returns a callback that logs an error through the resolved logger
+ * (`loggerOverride` ?? injected {@link loggerKey}) as an `error`-level event —
+ * for the errors a framework handler cannot catch (async/`Promise` callbacks,
+ * `try/catch`, native `addEventListener`). Fail-safe; a **safe no-op** when no
+ * logger resolves. Call this in `setup()`; the callback identity is stable for
+ * the component's lifetime (Vue runs `setup` once).
+ */
+declare function useLogError(loggerOverride?: Logger): (error: unknown, attributes?: Attributes) => void;
+/** Options for {@link useErrorCapture}. */
+interface UseErrorCaptureOptions {
+    /** Explicit logger override; falls back to the injected {@link loggerKey}. */
+    logger?: Logger;
+    /** Optional consumer hook, invoked fail-safe AFTER logging, with Vue's info string. */
+    onError?: (error: unknown, info: string) => void;
+    /** Keep propagating to ancestor/app handlers after logging. Default: false (stop). */
+    propagate?: boolean;
+}
+/**
+ * Subtree boundary: registers `onErrorCaptured` in the calling component so a
+ * descendant error is logged once via the resolved logger
+ * (`safesignal.source: 'vue-error-captured'`). By **default it stops
+ * propagation** (returns `false`) so the app-level handler does not also log it;
+ * pass `{ propagate: true }` to keep it bubbling. The optional `onError` callback
+ * is invoked fail-safe after logging. A safe no-op when no logger resolves.
+ */
+declare function useErrorCapture(options?: UseErrorCaptureOptions): void;
+
+export { type SafesignalErrorHandlerOptions, type UseErrorCaptureOptions, type VueErrorHandler, createErrorHandler, loggerKey, safesignalErrorHandler, useErrorCapture, useLogError };