npm - @allstak/nuxt - Versions diffs - 0.1.0 - Mend

@allstak/nuxt 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/CHANGELOG.md +55 -0
package/LICENSE +21 -0
package/README.md +108 -0
package/dist/module.d.mts +156 -0
package/dist/module.json +12 -0
package/dist/module.mjs +104 -0
package/dist/runtime/client.d.ts +10 -0
package/dist/runtime/client.js +2 -0
package/dist/runtime/plugins/allstak.client.d.ts +16 -0
package/dist/runtime/plugins/allstak.client.js +83 -0
package/dist/runtime/server/plugin.d.ts +14 -0
package/dist/runtime/server/plugin.js +116 -0
package/dist/runtime/server.d.ts +12 -0
package/dist/runtime/server.js +2 -0
package/dist/runtime/shared-options.d.ts +17 -0
package/dist/runtime/shared-options.js +0 -0
package/dist/runtime/version.d.ts +2 -0
package/dist/runtime/version.js +2 -0
package/dist/types.d.mts +9 -0
package/package.json +73 -0

package/CHANGELOG.md ADDED Viewed

@@ -0,0 +1,55 @@
+# Changelog
+All notable changes to `@allstak/nuxt` 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 Nuxt 3 / Nuxt 4, shipped as a
+Nuxt module built with `@nuxt/module-builder`.
+### Added
+- `@allstak/nuxt` Nuxt module (`defineNuxtModule`, config key `allstak`,
+  compatibility `nuxt >= 3.7`, Nuxt 4 supported). Register it in
+  `nuxt.config.ts` `modules: ['@allstak/nuxt']`.
+- Client runtime plugin (registered via `addPlugin`, `mode: 'client'`,
+  `order: 0`) that:
+  - delegates init and the Vue-side glue to `@allstak/vue`'s `AllStakPlugin`,
+    stamping the wrapper identity (`sdkName: 'allstak-nuxt'`, `sdkVersion`) so
+    backend ingest can distinguish Nuxt traffic;
+  - sets `attachErrorHandler: false` so it does not hijack
+    `app.config.errorHandler` — error capture is driven through Nuxt hooks;
+  - captures uncaught client errors via the `vue:error` and `app:error` Nuxt
+    hooks through a shared `reportNuxtError` helper, filtering expected
+    3xx/4xx statuses;
+  - opens a `navigation` span and breadcrumb per route change (`page:start` →
+    `page:finish`), guarded by a tree-shakeable tracing flag.
+- Nitro server plugin (registered via `addServerPlugin`) that:
+  - calls `AllStak.init` on the server, reading `runtimeConfig.public.allstak`
+    with a `process.env` fallback, stamped with the Nuxt SDK identity;
+  - captures unhandled server errors via the Nitro `error` hook with the H3
+    event context, ignoring expected 3xx/4xx;
+  - wraps every request in an `http.server` span (`request` → finished on
+    `beforeResponse` / `afterResponse` with the response status);
+  - injects trace meta tags into the SSR `<head>` via `render:html` for
+    client↔server trace continuity, skipped for pre-rendered / SWR-cached
+    responses.
+- Module options: `enabled`, `client`, `server`, `injectTraceMetaTags`,
+  `autoInjectServerAllStak` (`'plugin'` | `'top-level-import'` |
+  `'experimental_dynamic-import'`), `experimental_entrypointWrappedFunctions`,
+  `sourceMapsUploadOptions`, and `debug`.
+- `client.config` / `server.config`-equivalent init configuration via the
+  `allstak.client` / `allstak.server` module options (sampling, filters, and
+  every option `AllStak.init` accepts).
+- `runtimeConfig.public.allstak` read for `apiKey` / `host` / `environment` /
+  `release` / `dist`, with sensible defaults seeded by the module.
+- Client surface (`@allstak/nuxt/client`) re-exporting the full `@allstak/vue`
+  API; server surface (`@allstak/nuxt/server`) re-exporting the full
+  `@allstak/js` API. Both export `SDK_NAME` and `SDK_VERSION`.
+- The SDK version is injected at build time from `package.json`
+  (`__ALLSTAK_NUXT_VERSION__`), never hand-written, so it cannot drift.
+[0.1.0]: https://github.com/AllStak/allstak-nuxt/releases/tag/v0.1.0

package/LICENSE ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,108 @@
+# @allstak/nuxt
+[![npm](https://img.shields.io/npm/v/@allstak/nuxt.svg)](https://www.npmjs.com/package/@allstak/nuxt)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+Official AllStak SDK for **Nuxt 3 / Nuxt 4**, shipped as a Nuxt module. Captures uncaught errors on the client and the Nitro server, wraps every server request in a span, opens navigation spans on route changes, stitches client↔server traces through SSR meta tags, and surfaces the full AllStak observability API on both runtimes.
+Built on `@allstak/vue` (client) and `@allstak/js` (server).
+## Install
+```bash
+npm install @allstak/nuxt
+# or
+pnpm add @allstak/nuxt
+# or
+yarn add @allstak/nuxt
+```
+`nuxt@^3.7 || ^4` is a peer dependency. Nuxt >= 3.14 is recommended.
+## Setup
+Register the module and provide your ingest key through `runtimeConfig`:
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@allstak/nuxt'],
+  runtimeConfig: {
+    public: {
+      allstak: {
+        apiKey: process.env.ALLSTAK_API_KEY,
+        environment: process.env.NODE_ENV,
+        release: process.env.APP_VERSION,
+      },
+    },
+  },
+  // Optional — client.config / server.config-equivalent options:
+  allstak: {
+    client: { tracesSampleRate: 1.0 },
+    server: { tracesSampleRate: 1.0 },
+  },
+});
+```
+That single entry wires:
+- **Client** — delegates init and the Vue glue to `@allstak/vue`'s plugin (with `attachErrorHandler: false` so Nuxt's own error handling isn't hijacked), captures errors via the `vue:error` and `app:error` hooks, and opens a `navigation` span per route change.
+- **Server (Nitro)** — calls `AllStak.init` on the server, captures unhandled errors via the Nitro `error` hook, wraps each request in an `http.server` span, and injects trace meta tags into the SSR `<head>`.
+- Reads `runtimeConfig.public.allstak` for `apiKey` / `host` / `environment` / `release` / `dist` so secrets never have to live in `nuxt.config`.
+## Using the API
+The full client API is available from `@allstak/nuxt/client`, and the full server API from `@allstak/nuxt/server`:
+```ts
+// A client component
+import { AllStak, useAllStak } from '@allstak/nuxt/client';
+const allstak = useAllStak();
+allstak.captureException(new Error('payment declined'));
+```
+```ts
+// server/api/orders.post.ts
+import { AllStak } from '@allstak/nuxt/server';
+export default defineEventHandler(async (event) => {
+  AllStak.addBreadcrumb({ type: 'order', message: 'creating order' });
+  // ...
+});
+```
+## Module options
+Configured under the `allstak` key in `nuxt.config.ts`:
+| Option | Default | Purpose |
+|---|---|---|
+| `enabled` | `true` | Master switch. `false` registers nothing. |
+| `client` | `true` | Wire the client plugin. Pass an object to set client init config (sampling, filters, …). |
+| `server` | `true` | Wire the Nitro server plugin. Pass an object to set server init config. |
+| `injectTraceMetaTags` | `true` | Inject SSR trace meta tags for client↔server trace continuity (skipped for pre-render / SWR). |
+| `autoInjectServerAllStak` | `'plugin'` | Server-init strategy: `'plugin'`, `'top-level-import'`, or `'experimental_dynamic-import'`. |
+| `experimental_entrypointWrappedFunctions` | `['default','handler','server']` | Entry functions wrapped by the dynamic-import strategy. |
+| `sourceMapsUploadOptions` | — | Source-map upload config (`org`, `project`, `authToken`, `release`, `sourcemaps`). Enables `sourcemap.client: 'hidden'`. |
+| `debug` | `false` | Verbose module + runtime logging. |
+### Public runtime config
+The browser-safe ingest config lives under `runtimeConfig.public.allstak`:
+| Field | Purpose |
+|---|---|
+| `apiKey` | Publishable ingest key. |
+| `host` | Override the AllStak ingest host. |
+| `environment` | Deployment environment (e.g. `production`). |
+| `release` | Release identifier for grouping. |
+| `dist` | Build distribution identifier. |
+The server plugin also reads `ALLSTAK_API_KEY` / `ALLSTAK_HOST` / `APP_VERSION` from `process.env` as a fallback for the build-artifact and top-level-import server-init strategies, where runtime config may not be assembled yet.
+## License
+MIT

package/dist/module.d.mts ADDED Viewed

@@ -0,0 +1,156 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { AllStakConfig } from '@allstak/js';
+/**
+ * Strategy for getting the server-side AllStak init to run. The Nitro server
+ * boots before Nuxt's runtime config is fully assembled, so the server SDK is
+ * configured from `runtimeConfig.public.allstak` (read inside the server
+ * plugin) and these strategies control how/when the server plugin is wired:
+ *
+ *   - `'plugin'` (default): register a Nitro plugin via `addServerPlugin()`.
+ *     The plugin calls `AllStak.init` lazily on the first server request /
+ *     Nitro `error` hook. This is the portable default that works on every
+ *     Nitro preset (node-server, edge, serverless).
+ *   - `'top-level-import'`: in addition to the plugin, the module can be
+ *     instructed (by the host build) to import the server config at the top
+ *     of the Nitro entry. Surfaced for forward compatibility.
+ *   - `'experimental_dynamic-import'`: wrap the Nitro entrypoint functions so
+ *     the server SDK is imported dynamically before the handler runs.
+ */
+type AutoInjectServerStrategy = 'plugin' | 'top-level-import' | 'experimental_dynamic-import';
+/**
+ * Source-map upload options surfaced for the build-integration
+ * story. Upload itself is performed by `@allstak/js`'s source-map tooling /
+ * the AllStak CLI against the AllStak source-map ingest endpoint; the module
+ * threads these values through so a host can configure them in one place.
+ */
+interface SourceMapsUploadOptions {
+    /** Enable source-map upload during production build. Default: `false`. */
+    enabled?: boolean;
+    /** AllStak organisation slug. */
+    org?: string;
+    /** AllStak project slug. */
+    project?: string;
+    /** Upload auth token. Prefer an env var over committing this. */
+    authToken?: string;
+    /** Override the upload endpoint (defaults to the configured AllStak host). */
+    url?: string;
+    /** Suppress upload logging. Default: `false`. */
+    silent?: boolean;
+    /** Release name the maps are associated with. */
+    release?: {
+        name?: string;
+    };
+    /** Which emitted assets to scan, ignore, and clean up after upload. */
+    sourcemaps?: {
+        assets?: string | string[];
+        ignore?: string | string[];
+        filesToDeleteAfterUpload?: string | string[];
+    };
+}
+/**
+ * `@allstak/nuxt` module options. Configured under the `allstak` key in
+ * `nuxt.config.ts`:
+ *
+ *   export default defineNuxtConfig({
+ *     modules: ['@allstak/nuxt'],
+ *     allstak: {
+ *       enabled: true,
+ *       client: { tracesSampleRate: 1.0 },
+ *       server: { tracesSampleRate: 1.0 },
+ *     },
+ *     runtimeConfig: {
+ *       public: {
+ *         allstak: {
+ *           apiKey: process.env.ALLSTAK_API_KEY,
+ *           environment: process.env.NODE_ENV,
+ *           release: process.env.APP_VERSION,
+ *         },
+ *       },
+ *     },
+ *   });
+ */
+interface AllStakModuleOptions {
+    /** Master switch. When `false` the module registers nothing. Default: `true`. */
+    enabled?: boolean;
+    /**
+     * Wire the client runtime plugin (error capture + router/navigation spans).
+     * Default: `true`.
+     */
+    client?: boolean | AllStakClientConfig;
+    /**
+     * Wire the Nitro server plugin (unhandled-error capture + per-request span +
+     * SSR trace meta-tag injection). Default: `true`.
+     */
+    server?: boolean | AllStakServerConfig;
+    /**
+     * Inject `<meta name="allstak-trace">` / `<meta name="baggage">` tags into
+     * the SSR HTML head so the client can continue the server's trace. Default:
+     * `true`. Skipped automatically for pre-rendered / SWR-cached responses.
+     */
+    injectTraceMetaTags?: boolean;
+    /** Server-init injection strategy. Default: `'plugin'`. */
+    autoInjectServerAllStak?: AutoInjectServerStrategy;
+    /**
+     * Entry function names wrapped by the `'experimental_dynamic-import'`
+     * strategy. Default: `['default', 'handler', 'server']`.
+     */
+    experimental_entrypointWrappedFunctions?: string[];
+    /** Source-map upload configuration (build-time). */
+    sourceMapsUploadOptions?: SourceMapsUploadOptions;
+    /** Emit verbose module + runtime logging. Default: `false`. */
+    debug?: boolean;
+}
+/**
+ * Client-side init config. A subset/passthrough of `AllStakConfig` so a host
+ * can set sampling, filters, and tracing in `nuxt.config.ts`. Secrets
+ * (`apiKey`) should live in `runtimeConfig.public.allstak`, not here.
+ */
+type AllStakClientConfig = Partial<AllStakConfig>;
+/** Server-side init config. Same passthrough shape as the client. */
+type AllStakServerConfig = Partial<AllStakConfig>;
+/**
+ * Shape the module writes into `runtimeConfig.public.allstak`. Only the public
+ * fields belong here — they ship to the browser. The `apiKey` is a publishable
+ * ingest key (the same key the other browser SDKs use), not a server secret.
+ */
+interface AllStakPublicRuntimeConfig {
+    apiKey?: string;
+    host?: string;
+    environment?: string;
+    release?: string;
+    dist?: string;
+}
+declare const SDK_NAME = "allstak-nuxt";
+declare const SDK_VERSION: string;
+/**
+ * `@allstak/nuxt` — the official AllStak Nuxt module.
+ *
+ * Wiring it is a one-liner in `nuxt.config.ts`:
+ *
+ *   export default defineNuxtConfig({
+ *     modules: ['@allstak/nuxt'],
+ *     runtimeConfig: {
+ *       public: {
+ *         allstak: { apiKey: process.env.ALLSTAK_API_KEY },
+ *       },
+ *     },
+ *   });
+ *
+ * The module:
+ *   - registers a client plugin that delegates to `@allstak/vue`'s
+ *     `AllStakPlugin` (init + Vue glue) and wires Nuxt error hooks + router
+ *     navigation spans;
+ *   - registers a Nitro server plugin that calls `AllStak.init` on the server,
+ *     captures unhandled server errors, wraps every request in a span, and
+ *     injects SSR trace meta tags;
+ *   - reads `runtimeConfig.public.allstak` for `apiKey`/`environment`/`release`
+ *     /`host`/`dist` so secrets never have to live in `nuxt.config`;
+ *   - exposes split client/server configuration through the
+ *     `allstak.client` / `allstak.server` module options.
+ */
+declare const _default: _nuxt_schema.NuxtModule<AllStakModuleOptions, AllStakModuleOptions, false>;
+export { SDK_NAME, SDK_VERSION, _default as default };
+export type { AllStakClientConfig, AllStakModuleOptions, AllStakPublicRuntimeConfig, AllStakServerConfig, AutoInjectServerStrategy, SourceMapsUploadOptions };

package/dist/module.json ADDED Viewed

@@ -0,0 +1,12 @@
+{
+  "name": "@allstak/nuxt",
+  "version": "0.1.0",
+  "configKey": "allstak",
+  "compatibility": {
+    "nuxt": ">=3.7.0"
+  },
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs ADDED Viewed

@@ -0,0 +1,104 @@
+import { fileURLToPath } from 'node:url';
+import { defineNuxtModule, useLogger, createResolver, addPlugin, addServerPlugin, addTemplate } from '@nuxt/kit';
+const name = "@allstak/nuxt";
+const version = "0.1.0";
+const SDK_NAME = "allstak-nuxt";
+const SDK_VERSION = typeof __ALLSTAK_NUXT_VERSION__ === "string" ? __ALLSTAK_NUXT_VERSION__ : version;
+const module$1 = defineNuxtModule({
+  meta: {
+    name: name,
+    version: version,
+    configKey: "allstak",
+    compatibility: {
+      // Hooks/APIs used (nuxtApp.hook('vue:error'), addServerPlugin, render:html)
+      // are stable from 3.7; recommend >= 3.14. Nuxt 4 supported.
+      nuxt: ">=3.7.0"
+    }
+  },
+  defaults: {
+    enabled: true,
+    client: true,
+    server: true,
+    injectTraceMetaTags: true,
+    autoInjectServerAllStak: "plugin",
+    experimental_entrypointWrappedFunctions: ["default", "handler", "server"],
+    debug: false
+  },
+  setup(options, nuxt) {
+    const logger = useLogger(name);
+    if (options.enabled === false) {
+      if (options.debug) logger.info("disabled via `allstak.enabled: false` \u2014 skipping setup");
+      return;
+    }
+    const resolver = createResolver(import.meta.url);
+    const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
+    nuxt.options.build.transpile.push(runtimeDir);
+    nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
+    const existingPublic = nuxt.options.runtimeConfig.public.allstak;
+    nuxt.options.runtimeConfig.public.allstak = {
+      apiKey: "",
+      ...existingPublic ?? {}
+    };
+    const clientConfig = typeof options.client === "object" ? options.client : {};
+    const serverConfig = typeof options.server === "object" ? options.server : {};
+    const defines = {
+      __ALLSTAK_NUXT_VERSION__: JSON.stringify(version),
+      __ALLSTAK_CLIENT_CONFIG__: JSON.stringify(clientConfig),
+      __ALLSTAK_SERVER_CONFIG__: JSON.stringify(serverConfig),
+      __ALLSTAK_INJECT_META__: JSON.stringify(options.injectTraceMetaTags !== false)
+    };
+    nuxt.options.vite = nuxt.options.vite || {};
+    nuxt.options.vite.define = { ...nuxt.options.vite.define ?? {}, ...defines };
+    nuxt.options.nitro = nuxt.options.nitro || {};
+    nuxt.options.nitro.replace = { ...nuxt.options.nitro.replace ?? {}, ...defines };
+    if (options.client !== false) {
+      addPlugin({
+        src: resolver.resolve("./runtime/plugins/allstak.client"),
+        mode: "client",
+        order: 0
+      });
+      if (options.debug) logger.info("registered client plugin");
+    }
+    if (options.server !== false) {
+      const strategy = options.autoInjectServerAllStak ?? "plugin";
+      addServerPlugin(resolver.resolve("./runtime/server/plugin"));
+      if (strategy === "top-level-import") {
+        nuxt.options.nitro.plugins = nuxt.options.nitro.plugins || [];
+        nuxt.options.nitro.plugins.push(resolver.resolve("./runtime/server/plugin"));
+        if (options.debug) logger.info("server strategy 'top-level-import' wired");
+      } else if (strategy === "experimental_dynamic-import") {
+        nuxt.options.nitro.virtual = nuxt.options.nitro.virtual || {};
+        const wrapped = options.experimental_entrypointWrappedFunctions ?? ["default", "handler", "server"];
+        nuxt.options.nitro.virtual["#allstak-entrypoint-functions"] = `export const wrapped = ${JSON.stringify(wrapped)};`;
+        if (options.debug) {
+          logger.info(
+            `server strategy 'experimental_dynamic-import' wrapping: ${wrapped.join(", ")}`
+          );
+        }
+      }
+      if (options.debug) logger.info("registered Nitro server plugin");
+    }
+    if (options.sourceMapsUploadOptions?.enabled) {
+      addTemplate({
+        filename: "allstak-sourcemaps-options.mjs",
+        getContents: () => `export default ${JSON.stringify(options.sourceMapsUploadOptions ?? {}, null, 2)};
+`
+      });
+      if (typeof nuxt.options.sourcemap === "object") {
+        if (nuxt.options.sourcemap.client === void 0) {
+          nuxt.options.sourcemap.client = "hidden";
+        }
+      } else if (nuxt.options.sourcemap === void 0) {
+        nuxt.options.sourcemap = { client: "hidden", server: true };
+      }
+      if (options.debug) logger.info("source-map upload options surfaced");
+    }
+    if (options.debug) {
+      logger.success(`${name}@${version} ready (configKey: allstak)`);
+    }
+  }
+});
+export { SDK_NAME, SDK_VERSION, module$1 as default };

package/dist/runtime/client.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Client surface of `@allstak/nuxt`.
+ *
+ * Mirrors the framework convention where the client entry re-exports the full
+ * Vue SDK plus the framework-specific helpers. Importable in client code as:
+ *
+ *   import { AllStak, useAllStak } from '@allstak/nuxt/client';
+ */
+export * from '@allstak/vue';
+export { SDK_NAME, SDK_VERSION } from './version.js';

package/dist/runtime/client.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "@allstak/vue";
2	+ export { SDK_NAME, SDK_VERSION } from "./version.js";

package/dist/runtime/plugins/allstak.client.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+/**
+ * Client runtime plugin (registered via `addPlugin`, order 0 so it runs early).
+ *
+ * Responsibilities:
+ *   1. `app.use(AllStakPlugin, …)` — delegate init + the Vue-side glue to the
+ *      shared `@allstak/vue` SDK. `attachErrorHandler: false` so we do NOT
+ *      hijack `app.config.errorHandler` (which would swallow Nuxt's own 500
+ *      handling); error capture is driven through the Nuxt hooks below instead.
+ *   2. `vue:error` / `app:error` Nuxt hooks → `reportNuxtError` (filtering
+ *      expected 3xx/4xx).
+ *   3. Router instrumentation → a `navigation` span per route change, finished
+ *      on `page:finish`, guarded by the tree-shakeable `__ALLSTAK_TRACING__`
+ *      flag.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/allstak.client.js ADDED Viewed

@@ -0,0 +1,83 @@
+import { AllStakPlugin } from "@allstak/vue";
+import { AllStak } from "@allstak/js";
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+import { SDK_NAME, SDK_VERSION } from "../version.js";
+const baseClientConfig = typeof __ALLSTAK_CLIENT_CONFIG__ !== "undefined" ? __ALLSTAK_CLIENT_CONFIG__ : {};
+function isExpectedHttpStatus(error) {
+  const status = error?.statusCode ?? error?.status;
+  return typeof status === "number" && status >= 300 && status < 500;
+}
+function reportNuxtError(args) {
+  const { error, instance, info, source } = args;
+  if (isExpectedHttpStatus(error)) return;
+  try {
+    AllStak.captureException(error instanceof Error ? error : new Error(String(error)), {
+      framework: "nuxt",
+      source,
+      componentName: instance?.$options?.name,
+      lifecycleHook: info
+    });
+  } catch {
+  }
+}
+export default defineNuxtPlugin({
+  name: "allstak:client",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const runtime = useRuntimeConfig();
+    const publicConfig = runtime.public?.allstak ?? {};
+    const options = {
+      ...baseClientConfig,
+      apiKey: publicConfig.apiKey ?? baseClientConfig.apiKey ?? "",
+      host: publicConfig.host ?? baseClientConfig.host,
+      environment: publicConfig.environment ?? baseClientConfig.environment,
+      release: publicConfig.release ?? baseClientConfig.release,
+      dist: publicConfig.dist ?? baseClientConfig.dist,
+      sdkName: SDK_NAME,
+      sdkVersion: SDK_VERSION,
+      // Drive capture through Nuxt hooks, not Vue's errorHandler.
+      attachErrorHandler: false
+    };
+    nuxtApp.vueApp.use(AllStakPlugin, options);
+    nuxtApp.hook("vue:error", (error, instance, info) => {
+      reportNuxtError({ error, instance, info, source: "vue:error" });
+    });
+    nuxtApp.hook("app:error", (error) => {
+      reportNuxtError({ error, source: "app:error" });
+    });
+    const tracingFlag = globalThis.__ALLSTAK_TRACING__;
+    if (tracingFlag === false) return;
+    let activeNavSpan = null;
+    nuxtApp.hook("page:start", () => {
+      const to = nuxtApp.$router?.currentRoute?.value;
+      try {
+        AllStak.addBreadcrumb({
+          type: "navigation",
+          message: `\u2192 ${String(to?.fullPath ?? "")}`,
+          level: "info",
+          data: {
+            name: String(to?.name ?? ""),
+            fullPath: String(to?.fullPath ?? "")
+          }
+        });
+        activeNavSpan = AllStak.startSpan("navigation", {
+          description: String(to?.fullPath ?? ""),
+          attributes: {
+            "allstak.origin": "auto.navigation.nuxt",
+            "route.name": String(to?.name ?? ""),
+            "route.path": String(to?.path ?? "")
+          }
+        });
+      } catch {
+      }
+    });
+    nuxtApp.hook("page:finish", () => {
+      try {
+        activeNavSpan?.finish("ok");
+      } catch {
+      } finally {
+        activeNavSpan = null;
+      }
+    });
+  }
+});

package/dist/runtime/server/plugin.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+/**
+ * Nitro server plugin (registered via `addServerPlugin`).
+ *
+ *   1. `AllStak.init` on the server, stamped with the Nuxt SDK identity.
+ *   2. `request` → open a per-request span; `afterResponse` / `beforeResponse`
+ *      → finish it with the response status, so every server request is wrapped
+ *      in a span.
+ *   3. `error` hook → `captureException` with the H3 event context (ignoring
+ *      expected 3xx/4xx).
+ *   4. `render:html` → inject trace meta tags into the SSR `<head>` so the
+ *      client continues the server's trace. Skipped for pre-render / SWR.
+ */
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugin.js ADDED Viewed

@@ -0,0 +1,116 @@
+import { AllStak } from "@allstak/js";
+import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
+import { SDK_NAME, SDK_VERSION } from "../version.js";
+const baseServerConfig = typeof __ALLSTAK_SERVER_CONFIG__ !== "undefined" ? __ALLSTAK_SERVER_CONFIG__ : {};
+const injectMetaTags = typeof __ALLSTAK_INJECT_META__ !== "undefined" ? __ALLSTAK_INJECT_META__ : true;
+const INIT_FLAG = "__allstakNuxtServerInitialised__";
+function isExpectedHttpStatus(error) {
+  const status = error?.statusCode ?? error?.status;
+  return typeof status === "number" && status >= 300 && status < 500;
+}
+function ensureInit() {
+  const g = globalThis;
+  if (g[INIT_FLAG]) return;
+  g[INIT_FLAG] = true;
+  let publicConfig = {};
+  try {
+    const runtime = useRuntimeConfig();
+    publicConfig = runtime?.public?.allstak ?? {};
+  } catch {
+  }
+  const apiKey = publicConfig.apiKey ?? baseServerConfig.apiKey ?? process.env.ALLSTAK_API_KEY ?? "";
+  try {
+    AllStak.init({
+      ...baseServerConfig,
+      apiKey,
+      host: publicConfig.host ?? baseServerConfig.host ?? process.env.ALLSTAK_HOST,
+      environment: publicConfig.environment ?? baseServerConfig.environment ?? process.env.NODE_ENV,
+      release: publicConfig.release ?? baseServerConfig.release ?? process.env.APP_VERSION,
+      dist: publicConfig.dist ?? baseServerConfig.dist,
+      sdkName: SDK_NAME,
+      sdkVersion: SDK_VERSION
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+  } catch {
+  }
+}
+export default defineNitroPlugin((nitroApp) => {
+  ensureInit();
+  const SPAN_KEY = "_allstakSpan";
+  const ev = (event) => event;
+  nitroApp.hooks.hook("request", (event) => {
+    const e = ev(event);
+    try {
+      const method = e?.method ?? e?.node?.req?.method ?? "GET";
+      const path = e?.path ?? e?.node?.req?.url ?? "/";
+      const span = AllStak.startSpan("http.server", {
+        description: `${method} ${path}`,
+        attributes: {
+          "allstak.origin": "auto.http.server.nuxt",
+          "http.method": String(method),
+          "http.target": String(path)
+        }
+      });
+      e.context[SPAN_KEY] = span;
+    } catch {
+    }
+  });
+  const finishSpan = (event, status) => {
+    const e = ev(event);
+    try {
+      const span = e?.context?.[SPAN_KEY];
+      if (!span) return;
+      if (typeof status === "number") span.setTag("http.status_code", String(status));
+      span.finish(typeof status === "number" && status >= 500 ? "error" : "ok");
+      delete e.context[SPAN_KEY];
+    } catch {
+    }
+  };
+  nitroApp.hooks.hook("beforeResponse", (event, response) => {
+    const e = ev(event);
+    const status = e?.node?.res?.statusCode ?? response?.status;
+    finishSpan(event, status);
+  });
+  nitroApp.hooks.hook("afterResponse", (event) => {
+    finishSpan(event, ev(event)?.node?.res?.statusCode);
+  });
+  nitroApp.hooks.hook("error", (error, context) => {
+    if (isExpectedHttpStatus(error)) return;
+    const e = context?.event ? ev(context.event) : void 0;
+    try {
+      if (e) finishSpan(e, 500);
+      AllStak.captureException(error instanceof Error ? error : new Error(String(error)), {
+        framework: "nuxt",
+        source: "nitro:error",
+        method: e?.method ?? e?.node?.req?.method,
+        path: e?.path ?? e?.node?.req?.url
+      });
+    } catch {
+    }
+  });
+  if (injectMetaTags) {
+    const looseHook = nitroApp.hooks.hook;
+    looseHook("render:html", (html, context) => {
+      try {
+        const e = context?.event ? ev(context.event) : void 0;
+        if (isPrerenderOrSwr(e)) return;
+        const traceId = AllStak.getTraceId?.();
+        const spanId = AllStak.getCurrentSpanId?.();
+        if (!traceId) return;
+        const traceParent = spanId ? `${traceId}-${spanId}` : traceId;
+        html.head.push(`<meta name="allstak-trace" content="${escapeAttr(traceParent)}">`);
+        html.head.push(`<meta name="baggage" content="${escapeAttr(`allstak-trace_id=${traceId}`)}">`);
+      } catch {
+      }
+    });
+  }
+});
+function isPrerenderOrSwr(event) {
+  if (!event) return true;
+  const rules = event.context?.routeRules;
+  if (rules && (rules.swr || rules.isr)) return true;
+  return false;
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}

package/dist/runtime/server.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+/**
+ * Server surface of `@allstak/nuxt`.
+ *
+ * Mirrors the framework convention where the server entry re-exports the full
+ * core (node) SDK so server route handlers and Nitro plugins can call the
+ * manual API directly:
+ *
+ *   import { AllStak } from '@allstak/nuxt/server';
+ *   export default defineEventHandler(() => { AllStak.addBreadcrumb({ ... }); });
+ */
+export * from '@allstak/js';
+export { SDK_NAME, SDK_VERSION } from './version.js';

package/dist/runtime/server.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "@allstak/js";
2	+ export { SDK_NAME, SDK_VERSION } from "./version.js";

package/dist/runtime/shared-options.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+/**
+ * Runtime-side view of the public runtime config the module writes into
+ * `runtimeConfig.public.allstak`. Kept in the runtime tree (not `src/types.ts`)
+ * so the bundled runtime plugins stay self-contained and don't drag the
+ * module's build-time types into the client/server bundles.
+ *
+ * Only public fields live here — they ship to the browser. The `apiKey` is a
+ * publishable ingest key (the same key the other browser SDKs use), not a
+ * server secret.
+ */
+export interface AllStakPublicRuntimeConfig {
+    apiKey?: string;
+    host?: string;
+    environment?: string;
+    release?: string;
+    dist?: string;
+}

package/dist/runtime/shared-options.js ADDED Viewed

File without changes

package/dist/runtime/version.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export declare const SDK_NAME = "allstak-nuxt";
2	+ export declare const SDK_VERSION: string;

package/dist/runtime/version.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export const SDK_NAME = "allstak-nuxt";
2	+ export const SDK_VERSION = typeof __ALLSTAK_NUXT_VERSION__ === "string" ? __ALLSTAK_NUXT_VERSION__ : "0.0.0-dev";

package/dist/types.d.mts ADDED Viewed

@@ -0,0 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+import type { default as Module } from './module.mjs'
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+export { type SDK_NAME, type SDK_VERSION, default } from './module.mjs'
+export { type AllStakClientConfig, type AllStakModuleOptions, type AllStakPublicRuntimeConfig, type AllStakServerConfig, type AutoInjectServerStrategy, type SourceMapsUploadOptions } from './module.mjs'

package/package.json ADDED Viewed

@@ -0,0 +1,73 @@
+{
+  "name": "@allstak/nuxt",
+  "version": "0.1.0",
+  "description": "Official AllStak SDK for Nuxt 3 / Nuxt 4 \u2014 error tracking, structured logs, distributed tracing, and observability for the client and the Nitro server.",
+  "keywords": [
+    "nuxt",
+    "nuxt3",
+    "nuxt4",
+    "nuxt-module",
+    "nitro",
+    "observability",
+    "error-tracking",
+    "logging",
+    "monitoring",
+    "tracing",
+    "allstak"
+  ],
+  "type": "module",
+  "homepage": "https://allstak.sa",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AllStak/allstak-nuxt.git"
+  },
+  "bugs": "https://github.com/AllStak/allstak-nuxt/issues",
+  "license": "MIT",
+  "author": "AllStak <sdk@allstak.sa>",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "types": "./dist/types.d.mts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "build": "nuxt-module-build build",
+    "typecheck": "nuxt-module-build prepare && tsc --noEmit -p .nuxt/tsconfig.json",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "nuxt": "^3.7.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "nuxt": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@allstak/js": "^0.3.0",
+    "@allstak/vue": "^0.1.0",
+    "@nuxt/kit": "^3.7.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^1.0.0",
+    "@types/node": "^22.0.0",
+    "nuxt": "^3.18.0",
+    "typescript": "^5.8.3",
+    "vitest": "^2.1.0",
+    "vue": "^3.4.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  }
+}