@storewatch/node 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Edin Skeja
+
+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

@@ -1,3 +1,22 @@
-# Temporary Holding Version
+# @storewatch/node
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Storewatch server SDK. Your backend is the source of truth for money: orders,
+payments and refunds sent from here are what revenue is built on.
+
+```ts
+import { createStorewatch, eventIdFor } from "@storewatch/node";
+
+const storewatch = createStorewatch({ secretKey: process.env.STOREWATCH_SECRET_KEY!, endpoint: process.env.STOREWATCH_ENDPOINT! });
+
+storewatch.track("order_completed", {
+  sessionId, // the shopper's browser session, e.g. from cart metadata
+  eventId: eventIdFor("order_completed", order.id), // retries count once
+  properties: { orderId: order.id, total: { amount: 129900, currency: "SEK" }, items: [] },
+});
+
+await storewatch.flush(); // before a serverless function returns
+```
+
+`track` never throws and never waits for the network. Events are validated
+locally, so mistakes show up in your logs. For trace links, pass
+`traceContext: otelTraceContext` from `@storewatch/node/otel`. ESM and CommonJS.

package/dist/index.cjs

@@ -0,0 +1,197 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SDK_VERSION: () => SDK_VERSION,
+  StorewatchError: () => StorewatchError,
+  createStorewatch: () => createStorewatch,
+  eventIdFor: () => eventIdFor
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_crypto = require("crypto");
+var import_schema = require("@storewatch/schema");
+var import_constants = require("@storewatch/schema/constants");
+var SDK_VERSION = "0.2.0";
+var StorewatchError = class extends Error {
+  kind;
+  details;
+  // No parameter properties: the source stays erasable TypeScript (Node's type stripping can run it).
+  constructor(kind, message, details = {}) {
+    super(message);
+    this.name = "StorewatchError";
+    this.kind = kind;
+    this.details = details;
+  }
+};
+function eventIdFor(...parts) {
+  const hex = (0, import_node_crypto.createHash)("sha256").update(parts.join("")).digest("hex");
+  const variant = (parseInt(hex.slice(16, 17), 16) & 3 | 8).toString(16);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-8${hex.slice(13, 16)}-${variant}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+function defaultOnError() {
+  let last = 0;
+  let suppressed = 0;
+  return (error) => {
+    const now = Date.now();
+    if (now - last < 6e4) {
+      suppressed++;
+      return;
+    }
+    last = now;
+    const extra = suppressed > 0 ? ` (${suppressed} similar messages suppressed)` : "";
+    suppressed = 0;
+    console.warn(`[storewatch] ${error.message}${extra}`);
+  };
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function createStorewatch(options) {
+  const { endpoint } = options;
+  const flushIntervalMs = options.flushIntervalMs ?? 1e3;
+  const flushAt = Math.min(options.flushAt ?? 50, import_constants.LIMITS.batchMaxEvents);
+  const maxQueue = options.maxQueue ?? 5e3;
+  const maxAttempts = options.maxAttempts ?? 6;
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const report = options.onError ?? defaultOnError();
+  const doFetch = options.fetch ?? fetch;
+  if (!options.secretKey?.startsWith("sw_sk_")) {
+    report(new StorewatchError("invalid_event", "secretKey must be a Storewatch secret key (sw_sk_\u2026); events will not be sent."));
+  }
+  let queue = [];
+  let timer;
+  let draining = null;
+  let stopped = false;
+  const safeReport = (error) => {
+    try {
+      report(error);
+    } catch {
+    }
+  };
+  function ensureTimer() {
+    if (timer || stopped) return;
+    timer = setInterval(() => void flush(), flushIntervalMs);
+    timer.unref?.();
+  }
+  async function send(batch) {
+    for (let attempt = 1; ; attempt++) {
+      let status = 0;
+      try {
+        const res = await doFetch(endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json", "x-storewatch-key": options.secretKey },
+          body: JSON.stringify({ sentAt: (/* @__PURE__ */ new Date()).toISOString(), batch }),
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        status = res.status;
+        if (status === 202) {
+          const body = await res.json().catch(() => null);
+          for (const r of body?.rejected ?? []) {
+            safeReport(new StorewatchError("rejected", `ingest rejected event ${r.eventId ?? "?"}: ${r.issues.map((i) => `${i.path} ${i.message}`).join("; ")}`, r));
+          }
+          return;
+        }
+        if (status !== 429 && status < 500) {
+          safeReport(new StorewatchError("rejected", `ingest refused the batch (${status}); ${batch.length} events dropped`, { status }));
+          return;
+        }
+      } catch {
+      }
+      if (attempt >= maxAttempts || stopped) {
+        safeReport(new StorewatchError("delivery_failed", `could not deliver ${batch.length} events after ${attempt} attempts${status ? ` (last status ${status})` : ""}`, { status }));
+        return;
+      }
+      await sleep(Math.min(3e4, 500 * 2 ** (attempt - 1)) * (0.75 + Math.random() * 0.5));
+    }
+  }
+  async function drain() {
+    while (queue.length > 0) {
+      const batch = queue.splice(0, flushAt);
+      await send(batch);
+    }
+  }
+  function flush() {
+    draining ??= drain().finally(() => {
+      draining = null;
+    });
+    return draining;
+  }
+  return {
+    track(name, o) {
+      try {
+        if (stopped) return;
+        const trace = o.context?.trace === void 0 ? safeTrace(options.traceContext) : void 0;
+        const event = {
+          eventId: o.eventId ?? (0, import_node_crypto.randomUUID)(),
+          name,
+          timestamp: o.timestamp === void 0 ? (/* @__PURE__ */ new Date()).toISOString() : new Date(o.timestamp).toISOString(),
+          sessionId: o.sessionId,
+          ...o.anonymousId ? { anonymousId: o.anonymousId } : {},
+          ...o.customerId ? { customerId: o.customerId } : {},
+          properties: o.properties,
+          context: { ...trace ? { trace } : {}, ...o.context, library: { name: "@storewatch/node", version: SDK_VERSION } }
+        };
+        const result = (0, import_schema.validateEvent)(event);
+        if (!result.ok) {
+          safeReport(
+            new StorewatchError("invalid_event", `${name} not sent: ${result.issues.map((i) => `${i.path || "event"} ${i.message}`).join("; ")}`, {
+              eventId: event.eventId,
+              issues: result.issues
+            })
+          );
+          return;
+        }
+        queue.push(event);
+        if (queue.length > maxQueue) {
+          queue.splice(0, queue.length - maxQueue);
+          safeReport(new StorewatchError("queue_full", `queue full (${maxQueue}); dropped the oldest events`));
+        }
+        ensureTimer();
+        if (queue.length >= flushAt) void flush();
+      } catch (error) {
+        safeReport(new StorewatchError("invalid_event", `${String(name)} not sent: ${error instanceof Error ? error.message : String(error)}`));
+      }
+    },
+    flush,
+    async shutdown(waitMs = 5e3) {
+      if (timer) clearInterval(timer);
+      timer = void 0;
+      await Promise.race([flush(), sleep(waitMs)]);
+      stopped = true;
+    },
+    get pending() {
+      return queue.length;
+    }
+  };
+  function safeTrace(get) {
+    try {
+      const t = get?.();
+      return t && /^[0-9a-f]{32}$/.test(t.traceId) && t.traceId !== "0".repeat(32) ? t : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SDK_VERSION,
+  StorewatchError,
+  createStorewatch,
+  eventIdFor
+});

package/dist/index.d.cts

@@ -0,0 +1,77 @@
+import type { CanonicalEventName, CanonicalProperties, EventContext } from "@storewatch/schema";
+import { type ValidationIssue } from "@storewatch/schema";
+export declare const SDK_VERSION = "0.2.0";
+/** Canonical events get their typed properties; anything else is a custom event. */
+export type EventProperties<N extends string> = N extends CanonicalEventName ? CanonicalProperties[N] : Record<string, unknown>;
+export type TrackOptions<N extends string> = {
+    /**
+     * The shopper's browser session, so the server event joins their live
+     * journey (e.g. from cart metadata). Without one, the event still counts
+     * (an order is an order) but isn't tied to a visitor.
+     */
+    sessionId: string;
+    properties: EventProperties<N>;
+    /**
+     * Make this deterministic for anything that can be retried (see
+     * `eventIdFor`): ingest drops events whose id it has already seen.
+     */
+    eventId?: string;
+    /** When it happened. Default: now. */
+    timestamp?: Date | string;
+    /** The merchant's own customer id. Hashed per project at ingest; never stored raw. */
+    customerId?: string;
+    anonymousId?: string;
+    context?: Omit<EventContext, "library">;
+};
+export type StorewatchErrorKind = "invalid_event" | "rejected" | "delivery_failed" | "queue_full";
+export declare class StorewatchError extends Error {
+    readonly kind: StorewatchErrorKind;
+    readonly details: {
+        eventId?: string;
+        issues?: ValidationIssue[];
+        status?: number;
+    };
+    constructor(kind: StorewatchErrorKind, message: string, details?: StorewatchError["details"]);
+}
+export type TraceContext = {
+    traceId: string;
+    spanId?: string;
+};
+export type StorewatchOptions = {
+    /** Secret key (sw_sk_…). Server-side only, never in a browser bundle. */
+    secretKey: string;
+    /** Your ingest URL, e.g. https://ingest.example.com/v1/batch. */
+    endpoint: string;
+    /** Batches are sent at least this often. Default 1000 ms. */
+    flushIntervalMs?: number;
+    /** …or as soon as this many events are queued. Default 50. */
+    flushAt?: number;
+    /** Events kept while ingest is unreachable; the oldest are dropped beyond it. Default 5000. */
+    maxQueue?: number;
+    /** Delivery attempts per batch before it is dropped. Default 6 (about a minute of backoff). */
+    maxAttempts?: number;
+    /** Per-request timeout. Default 10 s. */
+    timeoutMs?: number;
+    /** The active trace, attached to every event (see `@storewatch/node/otel`). */
+    traceContext?: () => TraceContext | undefined;
+    /** Delivery and validation problems. Default: a rate-limited console.warn. */
+    onError?: (error: StorewatchError) => void;
+    /** For tests and unusual runtimes. */
+    fetch?: typeof fetch;
+};
+export type Storewatch = {
+    track<N extends string>(name: N, options: TrackOptions<N>): void;
+    /** Sends everything queued; resolves when done (or given up). */
+    flush(): Promise<void>;
+    /** Flushes, then stops the timer. Waits at most `timeoutMs` (default 5 s). */
+    shutdown(timeoutMs?: number): Promise<void>;
+    /** Events waiting to be sent. */
+    readonly pending: number;
+};
+/**
+ * A stable event id from parts that identify the fact, e.g.
+ * `eventIdFor("order_completed", orderId)`. Re-running the same handler then
+ * produces the same id, and ingest keeps the event once.
+ */
+export declare function eventIdFor(...parts: string[]): string;
+export declare function createStorewatch(options: StorewatchOptions): Storewatch;

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import type { CanonicalEventName, CanonicalProperties, EventContext } from "@storewatch/schema";
+import { type ValidationIssue } from "@storewatch/schema";
+export declare const SDK_VERSION = "0.2.0";
+/** Canonical events get their typed properties; anything else is a custom event. */
+export type EventProperties<N extends string> = N extends CanonicalEventName ? CanonicalProperties[N] : Record<string, unknown>;
+export type TrackOptions<N extends string> = {
+    /**
+     * The shopper's browser session, so the server event joins their live
+     * journey (e.g. from cart metadata). Without one, the event still counts
+     * (an order is an order) but isn't tied to a visitor.
+     */
+    sessionId: string;
+    properties: EventProperties<N>;
+    /**
+     * Make this deterministic for anything that can be retried (see
+     * `eventIdFor`): ingest drops events whose id it has already seen.
+     */
+    eventId?: string;
+    /** When it happened. Default: now. */
+    timestamp?: Date | string;
+    /** The merchant's own customer id. Hashed per project at ingest; never stored raw. */
+    customerId?: string;
+    anonymousId?: string;
+    context?: Omit<EventContext, "library">;
+};
+export type StorewatchErrorKind = "invalid_event" | "rejected" | "delivery_failed" | "queue_full";
+export declare class StorewatchError extends Error {
+    readonly kind: StorewatchErrorKind;
+    readonly details: {
+        eventId?: string;
+        issues?: ValidationIssue[];
+        status?: number;
+    };
+    constructor(kind: StorewatchErrorKind, message: string, details?: StorewatchError["details"]);
+}
+export type TraceContext = {
+    traceId: string;
+    spanId?: string;
+};
+export type StorewatchOptions = {
+    /** Secret key (sw_sk_…). Server-side only, never in a browser bundle. */
+    secretKey: string;
+    /** Your ingest URL, e.g. https://ingest.example.com/v1/batch. */
+    endpoint: string;
+    /** Batches are sent at least this often. Default 1000 ms. */
+    flushIntervalMs?: number;
+    /** …or as soon as this many events are queued. Default 50. */
+    flushAt?: number;
+    /** Events kept while ingest is unreachable; the oldest are dropped beyond it. Default 5000. */
+    maxQueue?: number;
+    /** Delivery attempts per batch before it is dropped. Default 6 (about a minute of backoff). */
+    maxAttempts?: number;
+    /** Per-request timeout. Default 10 s. */
+    timeoutMs?: number;
+    /** The active trace, attached to every event (see `@storewatch/node/otel`). */
+    traceContext?: () => TraceContext | undefined;
+    /** Delivery and validation problems. Default: a rate-limited console.warn. */
+    onError?: (error: StorewatchError) => void;
+    /** For tests and unusual runtimes. */
+    fetch?: typeof fetch;
+};
+export type Storewatch = {
+    track<N extends string>(name: N, options: TrackOptions<N>): void;
+    /** Sends everything queued; resolves when done (or given up). */
+    flush(): Promise<void>;
+    /** Flushes, then stops the timer. Waits at most `timeoutMs` (default 5 s). */
+    shutdown(timeoutMs?: number): Promise<void>;
+    /** Events waiting to be sent. */
+    readonly pending: number;
+};
+/**
+ * A stable event id from parts that identify the fact, e.g.
+ * `eventIdFor("order_completed", orderId)`. Re-running the same handler then
+ * produces the same id, and ingest keeps the event once.
+ */
+export declare function eventIdFor(...parts: string[]): string;
+export declare function createStorewatch(options: StorewatchOptions): Storewatch;

package/dist/index.js

@@ -0,0 +1,169 @@
+// src/index.ts
+import { createHash, randomUUID } from "crypto";
+import { validateEvent } from "@storewatch/schema";
+import { LIMITS } from "@storewatch/schema/constants";
+var SDK_VERSION = "0.2.0";
+var StorewatchError = class extends Error {
+  kind;
+  details;
+  // No parameter properties: the source stays erasable TypeScript (Node's type stripping can run it).
+  constructor(kind, message, details = {}) {
+    super(message);
+    this.name = "StorewatchError";
+    this.kind = kind;
+    this.details = details;
+  }
+};
+function eventIdFor(...parts) {
+  const hex = createHash("sha256").update(parts.join("")).digest("hex");
+  const variant = (parseInt(hex.slice(16, 17), 16) & 3 | 8).toString(16);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-8${hex.slice(13, 16)}-${variant}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+function defaultOnError() {
+  let last = 0;
+  let suppressed = 0;
+  return (error) => {
+    const now = Date.now();
+    if (now - last < 6e4) {
+      suppressed++;
+      return;
+    }
+    last = now;
+    const extra = suppressed > 0 ? ` (${suppressed} similar messages suppressed)` : "";
+    suppressed = 0;
+    console.warn(`[storewatch] ${error.message}${extra}`);
+  };
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function createStorewatch(options) {
+  const { endpoint } = options;
+  const flushIntervalMs = options.flushIntervalMs ?? 1e3;
+  const flushAt = Math.min(options.flushAt ?? 50, LIMITS.batchMaxEvents);
+  const maxQueue = options.maxQueue ?? 5e3;
+  const maxAttempts = options.maxAttempts ?? 6;
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const report = options.onError ?? defaultOnError();
+  const doFetch = options.fetch ?? fetch;
+  if (!options.secretKey?.startsWith("sw_sk_")) {
+    report(new StorewatchError("invalid_event", "secretKey must be a Storewatch secret key (sw_sk_\u2026); events will not be sent."));
+  }
+  let queue = [];
+  let timer;
+  let draining = null;
+  let stopped = false;
+  const safeReport = (error) => {
+    try {
+      report(error);
+    } catch {
+    }
+  };
+  function ensureTimer() {
+    if (timer || stopped) return;
+    timer = setInterval(() => void flush(), flushIntervalMs);
+    timer.unref?.();
+  }
+  async function send(batch) {
+    for (let attempt = 1; ; attempt++) {
+      let status = 0;
+      try {
+        const res = await doFetch(endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json", "x-storewatch-key": options.secretKey },
+          body: JSON.stringify({ sentAt: (/* @__PURE__ */ new Date()).toISOString(), batch }),
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        status = res.status;
+        if (status === 202) {
+          const body = await res.json().catch(() => null);
+          for (const r of body?.rejected ?? []) {
+            safeReport(new StorewatchError("rejected", `ingest rejected event ${r.eventId ?? "?"}: ${r.issues.map((i) => `${i.path} ${i.message}`).join("; ")}`, r));
+          }
+          return;
+        }
+        if (status !== 429 && status < 500) {
+          safeReport(new StorewatchError("rejected", `ingest refused the batch (${status}); ${batch.length} events dropped`, { status }));
+          return;
+        }
+      } catch {
+      }
+      if (attempt >= maxAttempts || stopped) {
+        safeReport(new StorewatchError("delivery_failed", `could not deliver ${batch.length} events after ${attempt} attempts${status ? ` (last status ${status})` : ""}`, { status }));
+        return;
+      }
+      await sleep(Math.min(3e4, 500 * 2 ** (attempt - 1)) * (0.75 + Math.random() * 0.5));
+    }
+  }
+  async function drain() {
+    while (queue.length > 0) {
+      const batch = queue.splice(0, flushAt);
+      await send(batch);
+    }
+  }
+  function flush() {
+    draining ??= drain().finally(() => {
+      draining = null;
+    });
+    return draining;
+  }
+  return {
+    track(name, o) {
+      try {
+        if (stopped) return;
+        const trace = o.context?.trace === void 0 ? safeTrace(options.traceContext) : void 0;
+        const event = {
+          eventId: o.eventId ?? randomUUID(),
+          name,
+          timestamp: o.timestamp === void 0 ? (/* @__PURE__ */ new Date()).toISOString() : new Date(o.timestamp).toISOString(),
+          sessionId: o.sessionId,
+          ...o.anonymousId ? { anonymousId: o.anonymousId } : {},
+          ...o.customerId ? { customerId: o.customerId } : {},
+          properties: o.properties,
+          context: { ...trace ? { trace } : {}, ...o.context, library: { name: "@storewatch/node", version: SDK_VERSION } }
+        };
+        const result = validateEvent(event);
+        if (!result.ok) {
+          safeReport(
+            new StorewatchError("invalid_event", `${name} not sent: ${result.issues.map((i) => `${i.path || "event"} ${i.message}`).join("; ")}`, {
+              eventId: event.eventId,
+              issues: result.issues
+            })
+          );
+          return;
+        }
+        queue.push(event);
+        if (queue.length > maxQueue) {
+          queue.splice(0, queue.length - maxQueue);
+          safeReport(new StorewatchError("queue_full", `queue full (${maxQueue}); dropped the oldest events`));
+        }
+        ensureTimer();
+        if (queue.length >= flushAt) void flush();
+      } catch (error) {
+        safeReport(new StorewatchError("invalid_event", `${String(name)} not sent: ${error instanceof Error ? error.message : String(error)}`));
+      }
+    },
+    flush,
+    async shutdown(waitMs = 5e3) {
+      if (timer) clearInterval(timer);
+      timer = void 0;
+      await Promise.race([flush(), sleep(waitMs)]);
+      stopped = true;
+    },
+    get pending() {
+      return queue.length;
+    }
+  };
+  function safeTrace(get) {
+    try {
+      const t = get?.();
+      return t && /^[0-9a-f]{32}$/.test(t.traceId) && t.traceId !== "0".repeat(32) ? t : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+}
+export {
+  SDK_VERSION,
+  StorewatchError,
+  createStorewatch,
+  eventIdFor
+};

package/dist/otel.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/otel.ts
+var otel_exports = {};
+__export(otel_exports, {
+  otelTraceContext: () => otelTraceContext
+});
+module.exports = __toCommonJS(otel_exports);
+var import_api = require("@opentelemetry/api");
+function otelTraceContext() {
+  const ctx = import_api.trace.getActiveSpan()?.spanContext();
+  if (!ctx || !(0, import_api.isSpanContextValid)(ctx)) return void 0;
+  return { traceId: ctx.traceId, spanId: ctx.spanId };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  otelTraceContext
+});

package/dist/otel.d.cts

@@ -0,0 +1,2 @@
+import type { TraceContext } from "./index.cjs";
+export declare function otelTraceContext(): TraceContext | undefined;

package/dist/otel.d.ts

@@ -0,0 +1,2 @@
+import type { TraceContext } from "./index.js";
+export declare function otelTraceContext(): TraceContext | undefined;

package/dist/otel.js

@@ -0,0 +1,10 @@
+// src/otel.ts
+import { isSpanContextValid, trace } from "@opentelemetry/api";
+function otelTraceContext() {
+  const ctx = trace.getActiveSpan()?.spanContext();
+  if (!ctx || !isSpanContextValid(ctx)) return void 0;
+  return { traceId: ctx.traceId, spanId: ctx.spanId };
+}
+export {
+  otelTraceContext
+};

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@storewatch/node",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Storewatch server SDK: authoritative orders and payments from your backend.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./otel": {
+      "import": {
+        "types": "./dist/otel.d.ts",
+        "default": "./dist/otel.js"
+      },
+      "require": {
+        "types": "./dist/otel.d.cts",
+        "default": "./dist/otel.cjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "dependencies": {
+    "@storewatch/schema": "0.2.0"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "tsup": "^9.0.0",
+    "@storewatch/config": "0.0.0"
+  },
+  "keywords": [
+    "storewatch",
+    "analytics",
+    "ecommerce"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsup && tsc -p tsconfig.build.json && node ../../scripts/dual-dts.mjs dist",
+    "typecheck": "tsc -p .",
+    "test": "vitest run"
+  }
 }