@allstak/vue 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to `@allstak/vue` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] — 2026-05-29
+
+Initial release of the official AllStak SDK for Vue 3.
+
+### Added
+
+- `init(config)` — thin bootstrap over `@allstak/js` that stamps the wrapper
+  identity (`sdkName: 'allstak-vue'`, `sdkVersion`) so backend ingest can
+  distinguish Vue traffic. The SDK version is injected at build time from
+  `package.json`, never hand-written.
+- `AllStakPlugin` — `app.use(AllStakPlugin, { apiKey, … })` installer that:
+  - hooks `app.config.errorHandler` to capture uncaught render/lifecycle
+    errors with component name and lifecycle-hook context, preserving any
+    previously registered handler;
+  - optionally hooks `app.config.warnHandler` to record Vue warnings as
+    breadcrumbs (`attachWarnHandler`, off by default);
+  - optionally installs component-render performance tracing
+    (`tracingOptions`);
+  - provides the client via the `$allstak` injection key and
+    `globalProperties.$allstak`.
+- Composition API helpers: `useAllStak`, `useAllStakUser` (sets the user for
+  the component lifetime and clears it on unmount), and `useAllStakSpan`
+  (opens a span finished automatically on scope dispose).
+- `installRouterInstrumentation` / `useAllStakRouter` — vue-router
+  instrumentation that opens a navigation span per route change, records a
+  navigation breadcrumb, finishes the span on completion, and captures
+  router errors.
+- `AllStakErrorBoundary` — error boundary component that reports subtree
+  errors and re-throws by default (configurable via the `rethrow` prop) with
+  an optional `fallback` slot.
+- `createTracingMixins` / `installComponentTracing` — component-render
+  performance tracing. Opens a `ui.vue.<operation>` span (described as
+  `Vue <ComponentName>`) around the configured lifecycle phases of tracked
+  components. Tracking is opt-in via `trackComponents` (`true` or a list of
+  component names) and configurable lifecycle `hooks` (`mount`, `update`,
+  `unmount`).
+- Full re-export of the `@allstak/js` public surface so consumers can pull
+  the entire observability API from a single namespaced import.
+- Dual CJS/ESM builds with bundled type declarations.
+
+[0.1.0]: https://github.com/AllStak/allstak-vue/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AllStak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# @allstak/vue
+
+[![npm](https://img.shields.io/npm/v/@allstak/vue.svg)](https://www.npmjs.com/package/@allstak/vue)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Official AllStak SDK for **Vue 3**. Captures uncaught exceptions, structured logs, navigation spans, HTTP requests, and web vitals — with first-class composition-API ergonomics.
+
+## Install
+
+```bash
+npm install @allstak/vue
+# or
+pnpm add @allstak/vue
+# or
+yarn add @allstak/vue
+```
+
+`vue@^3.2` is a peer dependency; `vue-router@^4` is optional.
+
+## Setup
+
+```ts
+import { createApp } from 'vue';
+import { AllStakPlugin } from '@allstak/vue';
+import App from './App.vue';
+
+createApp(App)
+  .use(AllStakPlugin, {
+    apiKey: import.meta.env.VITE_ALLSTAK_API_KEY,
+    environment: import.meta.env.MODE,
+    release: import.meta.env.VITE_APP_VERSION,
+  })
+  .mount('#app');
+```
+
+That single `use(AllStakPlugin, …)` wires:
+
+- `app.config.errorHandler` — every uncaught render/lifecycle error becomes an Issue
+- A `$allstak` injection key + `globalProperties.$allstak`
+- Auto release-health sessions
+- The full `@allstak/js` ingest pipeline (HTTP, db, logs, breadcrumbs, web-vitals)
+
+## Composition API
+
+```ts
+import { useAllStak, useAllStakUser, useAllStakSpan } from '@allstak/vue';
+
+const allstak = useAllStak();
+allstak.captureException(new Error('payment declined'));
+
+// Bind a user for the lifetime of this component (cleared on unmount)
+useAllStakUser({ id: currentUser.id, email: currentUser.email });
+
+// Open a span; finished automatically on unmount
+const span = useAllStakSpan({ op: 'checkout.review', description: 'review-cart' });
+span.setTag('cart_size', items.value.length);
+```
+
+## vue-router
+
+```ts
+import { createRouter, createWebHistory } from 'vue-router';
+import { installRouterInstrumentation } from '@allstak/vue';
+
+const router = createRouter({ history: createWebHistory(), routes });
+installRouterInstrumentation(router);
+```
+
+Every navigation becomes a `navigation` span + breadcrumb. Router errors become Issues.
+
+## Component performance tracing
+
+Opt in to per-component render timing. A span (`ui.vue.<operation>`, described
+as `Vue <ComponentName>`) is opened around each tracked component's lifecycle
+phase.
+
+```ts
+import { createApp } from 'vue';
+import { AllStakPlugin } from '@allstak/vue';
+
+createApp(App)
+  .use(AllStakPlugin, {
+    apiKey: import.meta.env.VITE_ALLSTAK_API_KEY,
+    tracingOptions: {
+      trackComponents: true,      // or a list: ['Checkout', 'Cart']
+      hooks: ['mount', 'update'], // default: ['mount']
+    },
+  })
+  .mount('#app');
+```
+
+Or install it standalone on an existing app:
+
+```ts
+import { installComponentTracing } from '@allstak/vue';
+
+installComponentTracing(app, { trackComponents: ['Dashboard'] });
+```
+
+## Error boundary
+
+```vue
+<script setup>
+import { AllStakErrorBoundary } from '@allstak/vue';
+</script>
+
+<template>
+  <AllStakErrorBoundary>
+    <RiskyWidget />
+    <template #fallback="{ error }">
+      <p>Sorry — something broke. ({{ error?.message }})</p>
+    </template>
+  </AllStakErrorBoundary>
+</template>
+```
+
+## Configuration
+
+`AllStakPlugin` accepts every option that `@allstak/js`'s `AllStak.init` accepts, plus:
+
+| Option | Default | Purpose |
+|---|---|---|
+| `attachErrorHandler` | `true` | Install `app.config.errorHandler` |
+| `attachWarnHandler` | `false` | Install `app.config.warnHandler` as breadcrumbs |
+| `skipInit` | `false` | Skip the `AllStak.init` call if you've already done it |
+| `tracingOptions` | — | Enable component-render tracing (`trackComponents`, `hooks`) |
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,228 @@
+import { AllStakConfig, AllStak, SpanOptions, Span } from '@allstak/js';
+export { AllStak, AllStakConfig, AllStakIntegration, Breadcrumb, DbQueryItem, ErrorEvent, ErrorEventProcessor, HeartbeatOptions, HttpRequestItem, LogEvent, LogLevel, SamplingContext, Scope, Session, SessionStatus, SessionTracker, Span, SpanData, SpanOptions, SpanProcessor, TracesSampler, WebVitalsContext, WebVitalsModule, consoleIntegration, databaseIntegration, dedupeIntegration, defineIntegration, eventFiltersIntegration, httpClientIntegration, inboundFiltersIntegration, isWebVitalsSupported } from '@allstak/js';
+import * as vue from 'vue';
+import { ComponentOptions, App, Plugin } from 'vue';
+import { Router } from 'vue-router';
+
+/**
+ * The core client instance returned by `AllStak.init`. `@allstak/js` does
+ * not export the `AllStakClient` class by name, so we derive the type from
+ * the value. This keeps the emitted declaration referential (no inlining of
+ * the core class's private members, which would trip TS4094).
+ */
+type AllStakClientInstance = ReturnType<typeof AllStak.init>;
+/**
+ * Initialize the AllStak SDK for a Vue 3 application.
+ *
+ * This is a thin shim over `AllStak.init` from `@allstak/js` that stamps
+ * the wrapper identity (`sdkName`, `sdkVersion`) so the backend can tell
+ * Vue traffic apart from plain JS traffic. Everything else — buffering,
+ * sampling, session health, offline queue, PII scrubbing — is delegated
+ * to the underlying core client.
+ *
+ * Call this once at app boot, BEFORE `app.use(AllStakPlugin)` if you want
+ * the plugin to surface the same client instance.
+ */
+declare function init(config: AllStakConfig): AllStakClientInstance;
+
+/**
+ * Component-lifecycle operations that can be traced. Each maps to a
+ * before/after lifecycle-hook pair on the Vue component instance.
+ */
+type TracingOperation = 'mount' | 'update' | 'unmount';
+interface ComponentTracingOptions {
+    /**
+     * Which components to trace.
+     *   - `false` (default): trace nothing.
+     *   - `true`: trace every component.
+     *   - `string[]`: trace only components whose name is in the list.
+     */
+    trackComponents?: boolean | string[];
+    /**
+     * Which lifecycle operations to time. Default: `['mount']`.
+     * A span is opened on the `before*` hook and finished on the matching
+     * `*ed`/`*ted` hook.
+     */
+    hooks?: TracingOperation[];
+    /**
+     * Span operation prefix. Resulting spans use `ui.vue.<operation>`
+     * (e.g. `ui.vue.mount`). Default: `'ui.vue'`.
+     */
+    opPrefix?: string;
+}
+/**
+ * Build a Vue mixin that opens a span around the configured lifecycle
+ * phases of each tracked component. The span is named after the
+ * component and tagged with the lifecycle operation, giving render-time
+ * visibility comparable to a dedicated component profiler.
+ *
+ * Spans use operation `ui.vue.<operation>` and description
+ * `Vue <ComponentName>`.
+ */
+declare function createTracingMixins(options?: ComponentTracingOptions): ComponentOptions;
+/**
+ * Install component performance tracing on a Vue app via `app.mixin`.
+ *
+ *   import { createApp } from 'vue';
+ *   import { installComponentTracing } from '@allstak/vue';
+ *
+ *   const app = createApp(App);
+ *   installComponentTracing(app, { trackComponents: true });
+ */
+declare function installComponentTracing(app: App, options?: ComponentTracingOptions): void;
+
+interface AllStakVueOptions extends AllStakConfig {
+    /**
+     * Hook into `app.config.errorHandler` to capture every uncaught error
+     * thrown from a render function or watcher. Default: `true`.
+     *
+     * Set to `false` if you have your own error handler and want to call
+     * `AllStak.captureException` from it manually.
+     */
+    attachErrorHandler?: boolean;
+    /**
+     * Hook into `app.config.warnHandler` to capture every Vue warning as a
+     * breadcrumb. Useful while you're stabilising — turn it off in prod
+     * for noisy apps. Default: `false`.
+     */
+    attachWarnHandler?: boolean;
+    /**
+     * Skip calling `AllStak.init`. Pass this when you've already called
+     * `init(...)` yourself (or imported a module that did) and just want
+     * the plugin's Vue-side hooks. Default: `false`.
+     */
+    skipInit?: boolean;
+    /**
+     * Component-render performance tracing. When `trackComponents` is set
+     * (to `true` or a list of component names), a span is opened around
+     * each tracked component's lifecycle phase. Disabled by default.
+     */
+    tracingOptions?: ComponentTracingOptions;
+}
+/**
+ * Vue 3 plugin.
+ *
+ *   import { createApp } from 'vue';
+ *   import { AllStakPlugin } from '@allstak/vue';
+ *   import App from './App.vue';
+ *
+ *   createApp(App)
+ *     .use(AllStakPlugin, {
+ *       apiKey: import.meta.env.VITE_ALLSTAK_API_KEY,
+ *       environment: import.meta.env.MODE,
+ *       release: import.meta.env.VITE_APP_VERSION,
+ *     })
+ *     .mount('#app');
+ */
+declare const AllStakPlugin: Plugin;
+
+type AllStakNS = typeof AllStak;
+/**
+ * Access the AllStak client inside a `<script setup>` block.
+ *
+ *   import { useAllStak } from '@allstak/vue';
+ *
+ *   const allstak = useAllStak();
+ *   allstak.captureException(new Error('boom'));
+ */
+declare function useAllStak(): AllStakNS;
+/**
+ * Set the active user for the duration of this component's lifetime,
+ * automatically clearing it on unmount.
+ *
+ *   useAllStakUser({ id: currentUser.value.id, email: currentUser.value.email });
+ *
+ * The core client identifies users by `id` and/or `email` only. To clear
+ * the user we call `setUser({})` (there is no dedicated clear method).
+ */
+declare function useAllStakUser(user: {
+    id?: string;
+    email?: string;
+} | null): void;
+/**
+ * Open a span and finish it when the component (or effect scope) tears
+ * down. Mirrors the pattern of React's `useSpan`.
+ *
+ *   const span = useAllStakSpan({ op: 'checkout.flow', description: 'review → pay' });
+ *   span.setTag('flow', 'web');
+ */
+declare function useAllStakSpan(opts: SpanOptions): Span;
+
+/**
+ * Instrument vue-router so every route change opens a navigation span +
+ * a breadcrumb.
+ *
+ *   import { createRouter } from 'vue-router';
+ *   import { installRouterInstrumentation } from '@allstak/vue';
+ *
+ *   const router = createRouter({ ... });
+ *   installRouterInstrumentation(router);
+ *
+ * Or composition-API style:
+ *
+ *   const router = useRouter();
+ *   useAllStakRouter(router);
+ */
+declare function installRouterInstrumentation(router: Router): void;
+/** Composable-style alias for `installRouterInstrumentation`. */
+declare function useAllStakRouter(router: Router): void;
+
+/**
+ * A drop-in error boundary component that reports any error thrown in
+ * its subtree to AllStak and then re-throws so the next boundary up the
+ * tree (or the global handler) still sees it.
+ *
+ *   <AllStakErrorBoundary>
+ *     <RiskyWidget />
+ *   </AllStakErrorBoundary>
+ *
+ * Slots:
+ *   default  — the wrapped subtree
+ *   fallback — optional; if provided, rendered when the subtree throws.
+ *              Receives `{ error }` as a slot prop.
+ */
+declare const AllStakErrorBoundary: vue.DefineComponent<vue.ExtractPropTypes<{
+    /**
+     * Re-throw the error after capturing. Default: `true`. Disable only
+     * when this boundary should fully consume the error (i.e. you've
+     * supplied a useful `fallback` slot).
+     */
+    rethrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /**
+     * Re-throw the error after capturing. Default: `true`. Disable only
+     * when this boundary should fully consume the error (i.e. you've
+     * supplied a useful `fallback` slot).
+     */
+    rethrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    rethrow: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * AllStak for Vue 3.
+ *
+ * Public surface:
+ *   - `init`              — bootstrap (delegates to @allstak/js with Vue tagging)
+ *   - `AllStakPlugin`     — `app.use(AllStakPlugin, { apiKey, ... })`
+ *   - `useAllStak`        — composition API access to the client
+ *   - `useAllStakUser`    — set/clear user from inside a setup()
+ *   - `useAllStakSpan`    — open a manual span within a setup
+ *   - `useAllStakRouter`  — instrument vue-router (route change → span)
+ *   - `AllStakErrorBoundary` — re-throwing error boundary component
+ *   - `createTracingMixins` / `installComponentTracing` — component-render spans
+ *   - re-exports          — every top-level @allstak/js export
+ */
+
+declare const SDK_NAME = "allstak-vue";
+declare const SDK_VERSION: string;
+
+export { AllStakErrorBoundary, AllStakPlugin, type AllStakVueOptions, type ComponentTracingOptions, SDK_NAME, SDK_VERSION, type TracingOperation, createTracingMixins, init, installComponentTracing, installRouterInstrumentation, useAllStak, useAllStakRouter, useAllStakSpan, useAllStakUser };

package/dist/index.d.ts

@@ -0,0 +1,228 @@
+import { AllStakConfig, AllStak, SpanOptions, Span } from '@allstak/js';
+export { AllStak, AllStakConfig, AllStakIntegration, Breadcrumb, DbQueryItem, ErrorEvent, ErrorEventProcessor, HeartbeatOptions, HttpRequestItem, LogEvent, LogLevel, SamplingContext, Scope, Session, SessionStatus, SessionTracker, Span, SpanData, SpanOptions, SpanProcessor, TracesSampler, WebVitalsContext, WebVitalsModule, consoleIntegration, databaseIntegration, dedupeIntegration, defineIntegration, eventFiltersIntegration, httpClientIntegration, inboundFiltersIntegration, isWebVitalsSupported } from '@allstak/js';
+import * as vue from 'vue';
+import { ComponentOptions, App, Plugin } from 'vue';
+import { Router } from 'vue-router';
+
+/**
+ * The core client instance returned by `AllStak.init`. `@allstak/js` does
+ * not export the `AllStakClient` class by name, so we derive the type from
+ * the value. This keeps the emitted declaration referential (no inlining of
+ * the core class's private members, which would trip TS4094).
+ */
+type AllStakClientInstance = ReturnType<typeof AllStak.init>;
+/**
+ * Initialize the AllStak SDK for a Vue 3 application.
+ *
+ * This is a thin shim over `AllStak.init` from `@allstak/js` that stamps
+ * the wrapper identity (`sdkName`, `sdkVersion`) so the backend can tell
+ * Vue traffic apart from plain JS traffic. Everything else — buffering,
+ * sampling, session health, offline queue, PII scrubbing — is delegated
+ * to the underlying core client.
+ *
+ * Call this once at app boot, BEFORE `app.use(AllStakPlugin)` if you want
+ * the plugin to surface the same client instance.
+ */
+declare function init(config: AllStakConfig): AllStakClientInstance;
+
+/**
+ * Component-lifecycle operations that can be traced. Each maps to a
+ * before/after lifecycle-hook pair on the Vue component instance.
+ */
+type TracingOperation = 'mount' | 'update' | 'unmount';
+interface ComponentTracingOptions {
+    /**
+     * Which components to trace.
+     *   - `false` (default): trace nothing.
+     *   - `true`: trace every component.
+     *   - `string[]`: trace only components whose name is in the list.
+     */
+    trackComponents?: boolean | string[];
+    /**
+     * Which lifecycle operations to time. Default: `['mount']`.
+     * A span is opened on the `before*` hook and finished on the matching
+     * `*ed`/`*ted` hook.
+     */
+    hooks?: TracingOperation[];
+    /**
+     * Span operation prefix. Resulting spans use `ui.vue.<operation>`
+     * (e.g. `ui.vue.mount`). Default: `'ui.vue'`.
+     */
+    opPrefix?: string;
+}
+/**
+ * Build a Vue mixin that opens a span around the configured lifecycle
+ * phases of each tracked component. The span is named after the
+ * component and tagged with the lifecycle operation, giving render-time
+ * visibility comparable to a dedicated component profiler.
+ *
+ * Spans use operation `ui.vue.<operation>` and description
+ * `Vue <ComponentName>`.
+ */
+declare function createTracingMixins(options?: ComponentTracingOptions): ComponentOptions;
+/**
+ * Install component performance tracing on a Vue app via `app.mixin`.
+ *
+ *   import { createApp } from 'vue';
+ *   import { installComponentTracing } from '@allstak/vue';
+ *
+ *   const app = createApp(App);
+ *   installComponentTracing(app, { trackComponents: true });
+ */
+declare function installComponentTracing(app: App, options?: ComponentTracingOptions): void;
+
+interface AllStakVueOptions extends AllStakConfig {
+    /**
+     * Hook into `app.config.errorHandler` to capture every uncaught error
+     * thrown from a render function or watcher. Default: `true`.
+     *
+     * Set to `false` if you have your own error handler and want to call
+     * `AllStak.captureException` from it manually.
+     */
+    attachErrorHandler?: boolean;
+    /**
+     * Hook into `app.config.warnHandler` to capture every Vue warning as a
+     * breadcrumb. Useful while you're stabilising — turn it off in prod
+     * for noisy apps. Default: `false`.
+     */
+    attachWarnHandler?: boolean;
+    /**
+     * Skip calling `AllStak.init`. Pass this when you've already called
+     * `init(...)` yourself (or imported a module that did) and just want
+     * the plugin's Vue-side hooks. Default: `false`.
+     */
+    skipInit?: boolean;
+    /**
+     * Component-render performance tracing. When `trackComponents` is set
+     * (to `true` or a list of component names), a span is opened around
+     * each tracked component's lifecycle phase. Disabled by default.
+     */
+    tracingOptions?: ComponentTracingOptions;
+}
+/**
+ * Vue 3 plugin.
+ *
+ *   import { createApp } from 'vue';
+ *   import { AllStakPlugin } from '@allstak/vue';
+ *   import App from './App.vue';
+ *
+ *   createApp(App)
+ *     .use(AllStakPlugin, {
+ *       apiKey: import.meta.env.VITE_ALLSTAK_API_KEY,
+ *       environment: import.meta.env.MODE,
+ *       release: import.meta.env.VITE_APP_VERSION,
+ *     })
+ *     .mount('#app');
+ */
+declare const AllStakPlugin: Plugin;
+
+type AllStakNS = typeof AllStak;
+/**
+ * Access the AllStak client inside a `<script setup>` block.
+ *
+ *   import { useAllStak } from '@allstak/vue';
+ *
+ *   const allstak = useAllStak();
+ *   allstak.captureException(new Error('boom'));
+ */
+declare function useAllStak(): AllStakNS;
+/**
+ * Set the active user for the duration of this component's lifetime,
+ * automatically clearing it on unmount.
+ *
+ *   useAllStakUser({ id: currentUser.value.id, email: currentUser.value.email });
+ *
+ * The core client identifies users by `id` and/or `email` only. To clear
+ * the user we call `setUser({})` (there is no dedicated clear method).
+ */
+declare function useAllStakUser(user: {
+    id?: string;
+    email?: string;
+} | null): void;
+/**
+ * Open a span and finish it when the component (or effect scope) tears
+ * down. Mirrors the pattern of React's `useSpan`.
+ *
+ *   const span = useAllStakSpan({ op: 'checkout.flow', description: 'review → pay' });
+ *   span.setTag('flow', 'web');
+ */
+declare function useAllStakSpan(opts: SpanOptions): Span;
+
+/**
+ * Instrument vue-router so every route change opens a navigation span +
+ * a breadcrumb.
+ *
+ *   import { createRouter } from 'vue-router';
+ *   import { installRouterInstrumentation } from '@allstak/vue';
+ *
+ *   const router = createRouter({ ... });
+ *   installRouterInstrumentation(router);
+ *
+ * Or composition-API style:
+ *
+ *   const router = useRouter();
+ *   useAllStakRouter(router);
+ */
+declare function installRouterInstrumentation(router: Router): void;
+/** Composable-style alias for `installRouterInstrumentation`. */
+declare function useAllStakRouter(router: Router): void;
+
+/**
+ * A drop-in error boundary component that reports any error thrown in
+ * its subtree to AllStak and then re-throws so the next boundary up the
+ * tree (or the global handler) still sees it.
+ *
+ *   <AllStakErrorBoundary>
+ *     <RiskyWidget />
+ *   </AllStakErrorBoundary>
+ *
+ * Slots:
+ *   default  — the wrapped subtree
+ *   fallback — optional; if provided, rendered when the subtree throws.
+ *              Receives `{ error }` as a slot prop.
+ */
+declare const AllStakErrorBoundary: vue.DefineComponent<vue.ExtractPropTypes<{
+    /**
+     * Re-throw the error after capturing. Default: `true`. Disable only
+     * when this boundary should fully consume the error (i.e. you've
+     * supplied a useful `fallback` slot).
+     */
+    rethrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /**
+     * Re-throw the error after capturing. Default: `true`. Disable only
+     * when this boundary should fully consume the error (i.e. you've
+     * supplied a useful `fallback` slot).
+     */
+    rethrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    rethrow: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * AllStak for Vue 3.
+ *
+ * Public surface:
+ *   - `init`              — bootstrap (delegates to @allstak/js with Vue tagging)
+ *   - `AllStakPlugin`     — `app.use(AllStakPlugin, { apiKey, ... })`
+ *   - `useAllStak`        — composition API access to the client
+ *   - `useAllStakUser`    — set/clear user from inside a setup()
+ *   - `useAllStakSpan`    — open a manual span within a setup
+ *   - `useAllStakRouter`  — instrument vue-router (route change → span)
+ *   - `AllStakErrorBoundary` — re-throwing error boundary component
+ *   - `createTracingMixins` / `installComponentTracing` — component-render spans
+ *   - re-exports          — every top-level @allstak/js export
+ */
+
+declare const SDK_NAME = "allstak-vue";
+declare const SDK_VERSION: string;
+
+export { AllStakErrorBoundary, AllStakPlugin, type AllStakVueOptions, type ComponentTracingOptions, SDK_NAME, SDK_VERSION, type TracingOperation, createTracingMixins, init, installComponentTracing, installRouterInstrumentation, useAllStak, useAllStakRouter, useAllStakSpan, useAllStakUser };