tracklane 0.6.0 → 0.7.0

package/README.md

@@ -91,7 +91,7 @@ build, so it is never ahead of the library.
 | -------- | -------------------- | ------ |
 | GA4      | Measurement Protocol | shipped |
 | Meta     | Conversions API      | shipped |
-| LinkedIn | Conversions API      | next   |
+| LinkedIn | Conversions API      | shipped |
 | PostHog  | Capture API          | shipped |
 | X        | Conversions API      | next   |
 

package/dist/{browser-_0LRgTpx.d.ts → browser-34-CHcxK.d.ts}

@@ -89,6 +89,41 @@ interface Ga4ServerConfig {
  */
 declare function ga4$1(credentials: Ga4ServerCredentials, config?: Ga4ServerConfig): ServerProvider;
 //#endregion
+//#region src/providers/linkedin.server.d.ts
+/** Credentials for LinkedIn's Conversions API. */
+interface LinkedinServerCredentials {
+  /** An access token authorized for the conversion's ad account. */
+  accessToken: string;
+}
+/** Configuration for the LinkedIn Conversions API provider. */
+interface LinkedinServerConfig {
+  /** Conversion IDs minted in Campaign Manager. `null` explicitly suppresses an event. */
+  events: Record<string, EventBinding<string>>;
+  /** LinkedIn's Marketing API version, in YYYYMM form. Defaults to `202609`. */
+  apiVersion?: string;
+}
+/**
+ * Sends event-specific conversions to LinkedIn's Conversions API.
+ * Value and currency become conversionValue; items, transaction_id, custom
+ * properties, traits and consent have no documented field on this endpoint.
+ * The host's deduplication ID becomes eventId, without generating one.
+ *
+ * @param credentials - The ad account's Conversions API access token.
+ * @param config - Canonical event to conversion ID map and API version.
+ * @returns A server provider for `createTracking`.
+ * @example
+ * ```ts
+ * import { createTracking, linkedin } from 'tracklane/server';
+ * const { track } = createTracking({
+ *   providers: [linkedin({ accessToken }, { events: { purchase: '12345' } })],
+ * });
+ * await track('purchase', { value: 15, currency: 'BRL' }, {
+ *   user: { email: 'buyer@example.com' }, dedupId: 'order-1',
+ * });
+ * ```
+ */
+declare function linkedin$1(credentials: LinkedinServerCredentials, config: LinkedinServerConfig): ServerProvider;
+//#endregion
 //#region src/providers/meta.server.d.ts
 /** Credentials for Meta's Conversions API. */
 interface MetaServerCredentials {
@@ -135,6 +170,11 @@ interface MetaServerConfig {
 /**
  * Meta's Conversions API.
  *
+ * If any item lacks a nonempty `item_id`, the complete `contents` list is
+ * omitted while totals and order metadata remain unchanged. This avoids
+ * presenting a partial order or inventing product identifiers. The error
+ * channel receives one payload-free warning after HTTP acceptance.
+ *
  * @param credentials - The pixel id and an access token.
  * @param config - Event overrides, the default action source, and Meta's own
  * levers: the API version, a test event code, and Limited Data Use.
@@ -326,8 +366,9 @@ type ProviderDefault = "passthrough" | "ignore";
  *
  * Fanning out to N vendors means no single call site can catch anything, so
  * this is the replica of the `try/catch` a host would have written around a
- * hand-made call. `severity` separates "this did not arrive" from "this
- * arrived, and here is something you should know".
+ * hand-made call. `severity` separates an observed failure from a caveat.
+ * Neither proves delivery: a browser command may only be queued, an HTTP
+ * success does not prove processing, and a network error may follow acceptance.
  *
  * It never carries event contents: the payload holds raw personal data by
  * design, and no library-owned surface re-emits it into a host's logs.
@@ -337,7 +378,7 @@ interface TrackingError {
   provider: string;
   /** The canonical event name being sent when this happened. */
   event: string;
-  /** `'error'` when the event did not arrive; `'warning'` when it arrived but is worth a look. */
+  /** `'error'` for an observed failure; `'warning'` for a caveat. Neither guarantees delivery. */
   severity: "error" | "warning";
   /** What happened, in one line, excluding the payload: event data never appears here. */
   message: string;
@@ -433,6 +474,8 @@ interface ServerTrackingOptions {
   /**
    * The one diagnostic channel. Without it the library is silent, exactly as
    * a hand-written vendor call is.
+   * Unmapped events on an `ignore` provider report warnings; explicit `null`
+   * exclusions stay silent. Attach a reporter in development to catch omissions.
    */
   onError?: (error: TrackingError) => void;
 }
@@ -499,8 +542,10 @@ interface Ga4BrowserConfig {
  * configures the property is yours. Use {@link ConsentState} through
  * `consent()` for changes after that.
  *
- * @param measurementId - The `G-` id of the data stream, matching the tag on
- * the page.
+ * With no measurement ID, events keep the tag's configured routing. Pass a
+ * measurement ID to address that destination through `send_to` instead.
+ * Neither form installs or configures the tag.
+ *
  * @param config - Rarely needed event name overrides.
  * @returns A provider for `createTracking` from `tracklane/browser`.
  *
@@ -509,13 +554,50 @@ interface Ga4BrowserConfig {
  * import { createTracking, ga4 } from 'tracklane/browser';
  *
  * // Google's own snippet is already in the page.
- * const { track } = createTracking({ providers: [ga4('G-XXXXXXX')] });
+ * const { track } = createTracking({ providers: [ga4()] });
  *
  * track('purchase', { transaction_id: 'T-1', value: 49.9, currency: 'BRL' });
  * ```
  */
+declare function ga4(config?: Ga4BrowserConfig): BrowserProvider;
+/**
+ * Addresses one configured Google destination instead of using the tag's
+ * default routing. Existing calls keep their `send_to` behavior.
+ *
+ * @param measurementId - The `G-` ID of the configured data stream.
+ * @param config - Rarely needed event name overrides.
+ * @returns A provider for `createTracking` from `tracklane/browser`.
+ * @example
+ * ```ts
+ * const provider = ga4('G-XXXXXXX', { events: { my_event: 'my_ga4_name' } });
+ * ```
+ */
 declare function ga4(measurementId: string, config?: Ga4BrowserConfig): BrowserProvider;
 //#endregion
+//#region src/providers/linkedin.browser.d.ts
+/** Configuration for the LinkedIn Insight Tag provider. */
+interface LinkedinBrowserConfig {
+  /** Conversion IDs minted in Campaign Manager. `null` explicitly suppresses an event. */
+  events: Record<string, EventBinding<string>>;
+}
+/**
+ * Calls the host-installed LinkedIn Insight Tag for event-specific conversions.
+ * LinkedIn has no event names, user-identification command or consent command.
+ * Items and custom parameters have no documented slot and are not forwarded.
+ *
+ * @param config - The canonical event to conversion ID map.
+ * @returns A browser provider; it does not install the Insight Tag.
+ * @example
+ * ```ts
+ * import { createTracking, linkedin } from 'tracklane/browser';
+ * const { track } = createTracking({
+ *   providers: [linkedin({ events: { purchase: '12345' } })],
+ * });
+ * track('purchase', { value: 15, currency: 'BRL' }, { dedupId: 'order-1' });
+ * ```
+ */
+declare function linkedin(config: LinkedinBrowserConfig): BrowserProvider;
+//#endregion
 //#region src/providers/meta.browser.d.ts
 /** Optional configuration for the Meta browser provider. */
 interface MetaBrowserConfig {
@@ -561,6 +643,11 @@ interface MetaBrowserConfig {
  * this adapter cannot deliver. Which pixels exist is declared by your snippet,
  * in `fbq('init')`.
  *
+ * If any item lacks a nonempty `item_id`, the complete `contents` list is
+ * omitted while totals and order metadata remain unchanged. This avoids
+ * presenting a partial order or inventing product identifiers. The error
+ * channel receives one payload-free warning after the browser command returns.
+ *
  * @param config - Event name overrides, merged over the built-in map.
  * @returns A provider for `createTracking` from `tracklane/browser`.
  *
@@ -648,8 +735,13 @@ interface BrowserProvider<Target = string> {
    * installs again, including providers that were already there.
    */
   install?(): void | Promise<void>;
-  /** Sends one event to this vendor. Throwing here reaches `onError`, not the caller. */
-  track(name: Target, data: EventData, options: TrackOptions): void;
+  /**
+   * Sends one event to this vendor. Throwing here reaches `onError`, not the caller.
+   * The optional report callback emits a payload-free warning; it is not proof
+   * of delivery or provider-side processing. Older three-argument providers
+   * and direct calls remain supported.
+   */
+  track(name: Target, data: EventData, options: TrackOptions, report?: (message: string) => void): void;
   /** Absent where the vendor keeps no user of its own. */
   identify?(user: UserData, traits?: Record<string, unknown>): void;
   /** Absent where the vendor documents no consent command. */
@@ -662,6 +754,8 @@ interface BrowserTrackingOptions {
   /**
    * The one diagnostic channel. Without it the library is silent, exactly as
    * a hand-written vendor call is.
+   * Unmapped events on an `ignore` provider report warnings; explicit `null`
+   * exclusions stay silent. Attach a reporter in development to catch omissions.
    */
   onError?: (error: TrackingError) => void;
 }
@@ -698,5 +792,5 @@ interface BrowserTracking {
  */
 declare function createTracking(options: BrowserTrackingOptions): BrowserTracking;
 //#endregion
-export { MetaServerCredentials as A, ProviderDefault as C, PosthogServerCredentials as D, PosthogServerConfig as E, VendorResponseError as F, isVendorResponseError as I, Ga4ServerConfig as M, Ga4ServerCredentials as N, posthog$1 as O, ga4$1 as P, EventItem as S, UserData as T, createTracking$1 as _, createTracking as a, EventBinding as b, MetaBrowserConfig as c, ga4 as d, EventContext as f, ServerTrackingOptions as g, ServerTracking as h, TrackOptions as i, meta$1 as j, MetaServerConfig as k, meta as l, ServerProvider as m, BrowserTracking as n, PosthogBrowserConfig as o, ResolvedContext as p, BrowserTrackingOptions as r, posthog as s, BrowserProvider as t, Ga4BrowserConfig as u, ActionSource as v, TrackingError as w, EventData as x, ConsentState as y };
-//# sourceMappingURL=browser-_0LRgTpx.d.ts.map
+export { posthog$1 as A, VendorResponseError as B, EventData as C, UserData as D, TrackingError as E, LinkedinServerCredentials as F, linkedin$1 as I, Ga4ServerConfig as L, MetaServerCredentials as M, meta$1 as N, PosthogServerConfig as O, LinkedinServerConfig as P, Ga4ServerCredentials as R, EventBinding as S, ProviderDefault as T, isVendorResponseError as V, ServerTracking as _, createTracking as a, ActionSource as b, MetaBrowserConfig as c, linkedin as d, Ga4BrowserConfig as f, ServerProvider as g, ResolvedContext as h, TrackOptions as i, MetaServerConfig as j, PosthogServerCredentials as k, meta as l, EventContext as m, BrowserTracking as n, PosthogBrowserConfig as o, ga4 as p, BrowserTrackingOptions as r, posthog as s, BrowserProvider as t, LinkedinBrowserConfig as u, ServerTrackingOptions as v, EventItem as w, ConsentState as x, createTracking$1 as y, ga4$1 as z };
+//# sourceMappingURL=browser-34-CHcxK.d.ts.map

package/dist/browser-DhzO5qPS.js

@@ -0,0 +1,432 @@
+import { i as resolveEvent, n as makeReporter, r as messageOf, t as assertUniqueProviders } from "./dispatch-B32jGhlh.js";
+//#region src/providers/ga4.browser.ts
+function gtagWindow() {
+	return typeof window === "undefined" ? void 0 : window;
+}
+/**
+* Sends a command, or fails the way a hand-written call would.
+*
+* Writing `gtag(…)` on a page without Google's snippet throws, and this
+* library replicates that rather than swallowing it: a silent no-op is how a
+* host ends up believing it is measuring something.
+*/
+function push$1(...args) {
+	const gtag = gtagWindow()?.gtag;
+	if (!gtag) throw new Error("ga4: window.gtag is not defined. Add Google's tag to the page before creating tracking.");
+	gtag(...args);
+}
+function ga4(measurementIdOrConfig = {}, config = {}) {
+	const measurementId = typeof measurementIdOrConfig === "string" ? measurementIdOrConfig : void 0;
+	const { events } = typeof measurementIdOrConfig === "string" ? config : measurementIdOrConfig;
+	return {
+		name: "ga4",
+		default: "passthrough",
+		...events ? { events } : {},
+		track(name, data, _options) {
+			push$1("event", name, measurementId === void 0 ? data : {
+				...data,
+				send_to: measurementId
+			});
+		},
+		identify(user, traits) {
+			if (user.userId !== void 0) push$1("set", { user_id: user.userId });
+			if (traits) push$1("set", "user_properties", traits);
+		},
+		consent(command, state) {
+			push$1("consent", command, state);
+		}
+	};
+}
+//#endregion
+//#region src/providers/linkedin.browser.ts
+/**
+* Calls the host-installed LinkedIn Insight Tag for event-specific conversions.
+* LinkedIn has no event names, user-identification command or consent command.
+* Items and custom parameters have no documented slot and are not forwarded.
+*
+* @param config - The canonical event to conversion ID map.
+* @returns A browser provider; it does not install the Insight Tag.
+* @example
+* ```ts
+* import { createTracking, linkedin } from 'tracklane/browser';
+* const { track } = createTracking({
+*   providers: [linkedin({ events: { purchase: '12345' } })],
+* });
+* track('purchase', { value: 15, currency: 'BRL' }, { dedupId: 'order-1' });
+* ```
+*/
+function linkedin(config) {
+	return {
+		name: "linkedin",
+		default: "ignore",
+		events: config.events,
+		track(name, data, options) {
+			const conversionId = Number(name);
+			if (!/^\d+$/.test(name) || !Number.isSafeInteger(conversionId) || conversionId <= 0) throw new Error("linkedin: conversion_id must be a positive safe integer from Campaign Manager");
+			const sdk = typeof window === "undefined" ? void 0 : window.lintrk;
+			if (!sdk) throw new Error("linkedin: window.lintrk is missing. Install the Insight Tag before tracking.");
+			const payload = { conversion_id: conversionId };
+			if (data.currency !== void 0) payload.conversion_currency = data.currency;
+			if (data.value !== void 0) payload.conversion_value = data.value;
+			if (options.dedupId !== void 0) payload.event_id = options.dedupId;
+			sdk("track", payload);
+		}
+	};
+}
+//#endregion
+//#region src/providers/meta.browser.ts
+/**
+* The names Meta accepts through `fbq('track')`. Anything else is a custom
+* event and goes through `trackCustom`, which is a different command rather
+* than a different argument.
+*
+* Seventeen standard events plus `PageView`, which Meta documents separately
+* from the seventeen and which the base snippet fires by itself.
+*/
+const STANDARD_EVENTS = [
+	"AddPaymentInfo",
+	"AddToCart",
+	"AddToWishlist",
+	"CompleteRegistration",
+	"Contact",
+	"CustomizeProduct",
+	"Donate",
+	"FindLocation",
+	"InitiateCheckout",
+	"Lead",
+	"PageView",
+	"Purchase",
+	"Schedule",
+	"Search",
+	"StartTrial",
+	"SubmitApplication",
+	"Subscribe",
+	"ViewContent"
+];
+/**
+* How Meta spells the canonical vocabulary, which is GA4's.
+*
+* Only canonical names appear here. Meta has eight more standard events with
+* no GA4 counterpart (`Subscribe`, `StartTrial`, `Schedule`, `Contact`,
+* `Donate`, `FindLocation`, `CustomizeProduct`, `SubmitApplication`), and
+* inventing canonical names for them would make this library the author of a
+* vocabulary it deliberately borrows. A host that fires those maps its own
+* event name to them through `events`.
+*
+* A canonical event with no standard counterpart is **not** dropped: it goes
+* to `trackCustom` under its own name, because by hand that event would have
+* been sent.
+*/
+const CANONICAL_EVENTS = {
+	page_view: "PageView",
+	view_item: "ViewContent",
+	search: "Search",
+	add_to_cart: "AddToCart",
+	add_to_wishlist: "AddToWishlist",
+	begin_checkout: "InitiateCheckout",
+	add_payment_info: "AddPaymentInfo",
+	purchase: "Purchase",
+	sign_up: "CompleteRegistration",
+	generate_lead: "Lead"
+};
+function fbqWindow() {
+	return typeof window === "undefined" ? void 0 : window;
+}
+/**
+* Sends a command, or fails the way a hand-written call would.
+*
+* Writing `fbq(…)` on a page without Meta's snippet throws, and this library
+* replicates that rather than swallowing it: a silent no-op is how a host
+* ends up believing it is measuring something.
+*/
+function push(...args) {
+	const fbq = fbqWindow()?.fbq;
+	if (!fbq) throw new Error("meta: window.fbq is not defined. Add Meta's pixel to the page before creating tracking.");
+	fbq(...args);
+}
+/**
+* GA4's `items` become Meta's `contents`, which is a closed shape: `id`,
+* `quantity`, `item_price` and `delivery_category`, and nothing else.
+*
+* The rest of a GA4 item, `item_name` and `item_brand`, is dropped rather than
+* forwarded, because a key Meta does not read inside `contents` looks mapped
+* and arrives nowhere. That is the failure mode this project keeps finding.
+*/
+function contents(items) {
+	if (items.some((item) => typeof item.item_id !== "string" || !item.item_id.trim())) return void 0;
+	return items.map((item) => {
+		const content = {};
+		if (item.item_id !== void 0) content.id = item.item_id;
+		if (item.quantity !== void 0) content.quantity = item.quantity;
+		if (item.price !== void 0) content.item_price = item.price;
+		return content;
+	});
+}
+/**
+* `value` and `currency` are spelled identically by both vendors, so they
+* pass through untouched. Everything the host named itself passes through
+* too: Meta keeps unknown keys as custom properties, which is exactly what a
+* hand-written call would have produced.
+*
+* `transaction_id` stays under its own name here. Meta's pixel documents no
+* order id among its object properties. `order_id` exists on the Conversions
+* API and not on this surface, so translating it would be inventing a slot.
+*/
+function pixelParams(data) {
+	const { items, ...rest } = data;
+	const params = { ...rest };
+	if (items) {
+		const mapped = contents(items);
+		if (mapped !== void 0) params.contents = mapped;
+		else delete params.contents;
+	}
+	return params;
+}
+/**
+* Meta's pixel has one consent switch where this library carries Google's
+* four signals, so the four are collapsed into it.
+*
+* The collapse is the strictest declared answer: any `denied` produces
+* `revoke`, and `grant` needs every declared signal to be `granted`. There is
+* no field to partition, so this is the only reduction that cannot widen a
+* denial, and widening is the one thing a projection must never do.
+*
+* A host that wants Meta to follow only its advertising category, and not its
+* analytics one, decides that before `createTracking` by leaving this
+* provider out, which is what `@tracklane/consent` exists to do.
+*/
+function collapse(state) {
+	const signals = [
+		state.ad_storage,
+		state.analytics_storage,
+		state.ad_user_data,
+		state.ad_personalization
+	].filter((signal) => signal !== void 0);
+	if (signals.length === 0) return void 0;
+	return signals.every((signal) => signal === "granted") ? "grant" : "revoke";
+}
+/**
+* The Meta pixel in the browser, through `fbq`.
+*
+* **This provider does not load Meta's pixel.** The base code belongs on the
+* page, installed the way
+* [Meta documents it](https://developers.facebook.com/docs/meta-pixel/get-started):
+* a snippet in the HTML, or a tag manager. This library talks to the pixel
+* that is already there; it never injects a third-party script and never
+* issues `fbq('init')`.
+*
+* Three consequences follow from that, and all three are Meta's rules rather
+* than ours:
+*
+* - **There is no `identify` here.** Meta accepts advanced matching only in
+*   the base code ("be sure to place advanced matching parameters in the
+*   pixel base code or the values will not be treated as manual advanced
+*   matching values"), and the base code is yours. Put `em`, `ph`, `fn`, `ln`
+*   in your own `fbq('init')`, where the pixel normalises and hashes them for
+*   you. On the server, where there is no snippet, the same identity travels
+*   in `context.user` and is hashed by the adapter.
+* - **The initial consent declaration is not ours.** Meta wants
+*   `fbq('consent', 'revoke')` before `init`, and by the time you hold what
+*   `createTracking` returns that moment has passed. Ours is every
+*   declaration after it, through `consent()`.
+* - **Limited Data Use is not ours either.** `fbq('dataProcessingOptions', …)`
+*   is documented as running before `init`. It belongs in your snippet. The
+*   server half, which has no snippet, carries it on its factory.
+*
+* **There is no pixel id here**, and that is deliberate rather than an
+* omission. `fbq('track')` reaches every pixel the page initialised, so an id
+* passed in would address nothing and the parameter would promise something
+* this adapter cannot deliver. Which pixels exist is declared by your snippet,
+* in `fbq('init')`.
+*
+* If any item lacks a nonempty `item_id`, the complete `contents` list is
+* omitted while totals and order metadata remain unchanged. This avoids
+* presenting a partial order or inventing product identifiers. The error
+* channel receives one payload-free warning after the browser command returns.
+*
+* @param config - Event name overrides, merged over the built-in map.
+* @returns A provider for `createTracking` from `tracklane/browser`.
+*
+* @example
+* ```ts
+* import { createTracking, meta } from 'tracklane/browser';
+*
+* // Meta's own base code is already in the page, and it named the pixel.
+* const { track } = createTracking({ providers: [meta()] });
+*
+* // fbq('track', 'Purchase', { value: 49.9, currency: 'BRL' }, { eventID: 'T-1' })
+* track('purchase', { value: 49.9, currency: 'BRL' }, { dedupId: 'T-1' });
+* ```
+*/
+function meta(config = {}) {
+	return {
+		name: "meta",
+		default: "passthrough",
+		events: {
+			...CANONICAL_EVENTS,
+			...config.events
+		},
+		track(name, data, options, report) {
+			const command = STANDARD_EVENTS.includes(name) ? "track" : "trackCustom";
+			const params = pixelParams(data);
+			const args = [
+				command,
+				name,
+				params
+			];
+			if (options.dedupId !== void 0) args.push({ eventID: options.dedupId });
+			push(...args);
+			if (data.items && params.contents === void 0) report?.("contents omitted: every item needs a nonempty item_id; totals were preserved");
+		},
+		consent(_command, state) {
+			const answer = collapse(state);
+			if (answer) push("consent", answer);
+		}
+	};
+}
+//#endregion
+//#region src/providers/posthog.browser.ts
+function posthogWindow() {
+	return typeof window === "undefined" ? void 0 : window;
+}
+/**
+* Returns the vendor SDK, or fails the way a hand-written call would.
+*
+* Calling `posthog.capture(...)` on a page without PostHog's snippet throws,
+* and this library replicates that rather than swallowing it: a silent no-op
+* is how a host ends up believing it is measuring something.
+*/
+function sdk() {
+	const instance = posthogWindow()?.posthog;
+	if (!instance) throw new Error("posthog: window.posthog is not defined. Add PostHog's snippet to the page before creating tracking.");
+	return instance;
+}
+/**
+* PostHog in the browser, through `posthog-js`.
+*
+* **This provider does not load PostHog's snippet.** It belongs on the page,
+* installed the way PostHog documents it: a snippet in the HTML, or a tag
+* manager. This library talks to the instance that is already there; it
+* never injects a third-party script into your page.
+*
+* @param config - Rarely needed event name overrides.
+* @returns A provider for `createTracking` from `tracklane/browser`.
+*
+* @example
+* ```ts
+* import { createTracking, posthog } from 'tracklane/browser';
+*
+* // PostHog's own snippet is already in the page.
+* const { track } = createTracking({ providers: [posthog()] });
+*
+* track('purchase', { transaction_id: 'T-1', value: 49.9, currency: 'BRL' });
+* ```
+*/
+function posthog(config = {}) {
+	const { events } = config;
+	return {
+		name: "posthog",
+		default: "passthrough",
+		...events ? { events } : {},
+		track(name, data, _options) {
+			sdk().capture(name, data);
+		},
+		identify(user, traits) {
+			if (user.userId !== void 0) sdk().identify(user.userId);
+			if (traits) sdk().setPersonProperties(traits);
+		},
+		consent(_command, state) {
+			const { analytics_storage } = state;
+			if (analytics_storage === "denied") sdk().opt_out_capturing();
+			else if (analytics_storage === "granted") sdk().opt_in_capturing();
+		}
+	};
+}
+//#endregion
+//#region src/browser.ts
+/**
+* Creates the browser tracking surface.
+*
+* Providers install eagerly, which is what pasting a vendor snippet does and
+* what lets each vendor record its own initial page view. Every vendor
+* shipped here queues its own commands until its script lands, so nothing is
+* lost to loading and this library needs no queue of its own.
+*
+* @param options - The providers to send to, and an optional error channel.
+* @returns The `track`, `identify` and `consent` calls.
+*
+* @example
+* ```ts
+* import { createTracking, ga4 } from 'tracklane/browser';
+*
+* const { track } = createTracking({ providers: [ga4('G-XXXXXXX')] });
+* track('purchase', { transaction_id: 'T-1', value: 49.9, currency: 'BRL' });
+* ```
+*/
+function createTracking(options) {
+	const { providers } = options;
+	assertUniqueProviders(providers);
+	const report = makeReporter(options.onError);
+	const fail = (provider, event, cause) => {
+		report({
+			provider,
+			event,
+			severity: "error",
+			message: messageOf(cause),
+			cause
+		});
+	};
+	for (const provider of providers) try {
+		const installing = provider.install?.();
+		Promise.resolve(installing).catch((cause) => {
+			fail(provider.name, "install", cause);
+		});
+	} catch (cause) {
+		fail(provider.name, "install", cause);
+	}
+	return {
+		track(name, data = {}, trackOptions = {}) {
+			for (const provider of providers) {
+				const target = resolveEvent(provider, name, (message) => {
+					report({
+						provider: provider.name,
+						event: name,
+						severity: "warning",
+						message
+					});
+				});
+				if (target === void 0) continue;
+				try {
+					provider.track(target, data, trackOptions, (message) => {
+						report({
+							provider: provider.name,
+							event: name,
+							severity: "warning",
+							message
+						});
+					});
+				} catch (cause) {
+					fail(provider.name, name, cause);
+				}
+			}
+		},
+		identify(user, traits) {
+			for (const provider of providers) try {
+				provider.identify?.(user, traits);
+			} catch (cause) {
+				fail(provider.name, "identify", cause);
+			}
+		},
+		consent(command, state) {
+			for (const provider of providers) try {
+				provider.consent?.(command, state);
+			} catch (cause) {
+				fail(provider.name, "consent", cause);
+			}
+		}
+	};
+}
+//#endregion
+export { ga4 as a, linkedin as i, posthog as n, meta as r, createTracking as t };
+
+//# sourceMappingURL=browser-DhzO5qPS.js.map