@astroscope/relay 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 entwico GmbH
+
+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,237 @@
-# Temporary Holding Version
+# @astroscope/relay
 
-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.
+> **Disclaimer.** A technical tool, not legal advice: it forwards events only where your consent source says the visitor agreed, but compliance with GDPR, ePrivacy or any other law stays your responsibility. No guarantee, no liability.
+
+Consent-aware event relay for Astro. The site defines each event once, as the payloads of the destinations it is meant for. One `track()` puts the event on a bus in the browser and reports it from an action on the server. A destination takes its payload once the visitor consented to it. The package never binds to a consent management platform: the site answers the consent question through one function, and the server reads the browser's answers off a header the bus attaches to every request.
+
+What it solves:
+
+- **One definition per event.** `purchase` is the data layer push, the conversions api order and the affiliate sale in one place.
+- **Late destinations.** A cmp injects a pixel some time after consent. Events tracked before that wait on the bus until the destination is ready.
+- **Late consent.** Events tracked before the visitor chose stay in memory and flow once they accept.
+- **Double counting.** The browser pixel and the server-side conversions api fire under one event id.
+- **Forgotten gates.** An action never checks consent itself. The bus writes the `x-relay-consent` header onto every same-origin `fetch` and nowhere else, the middleware reads it, and the server `track()` reports to consented destinations only. Events live in memory; nothing is stored on the device.
+
+## Installation
+
+```bash
+pnpm add @astroscope/relay
+```
+
+Requires `@astroscope/node` as the adapter. React is optional, for `@astroscope/relay/react`.
+
+## Setup
+
+```ts
+// astro.config.ts
+import node from '@astroscope/node';
+import relay from '@astroscope/relay';
+import { defineConfig } from 'astro/config';
+
+export default defineConfig({
+  adapter: node(),
+  integrations: [relay()],
+});
+```
+
+The integration takes no options. It owns `src/relay/`, where a file's existence switches a half on:
+
+| File                  | Role                                                                                 |
+| --------------------- | ------------------------------------------------------------------------------------ |
+| `src/relay/client.ts` | The browser bus configuration, as its default export; loaded on every page           |
+| `src/relay/server.ts` | The registry of server destinations; what the server `track()` reports to           |
+| `src/relay/events.ts` | The events; a plain module the integration never touches                             |
+
+The middleware that reads the consent header is always added, so `relayConsent()` works regardless.
+
+## Events
+
+A definition takes the site's own objects and returns one payload per destination, under the destination's name, built with that destination's builders. The export is the key plus `Event`, one export per event, so an island bundles only the events it tracks and an event only an action imports never reaches the browser.
+
+```ts
+// src/relay/events.ts
+import { type ConversionUser, defineEvent } from '@astroscope/relay';
+import { ga4 } from '@astroscope/relay/ga4';
+import { openai } from '@astroscope/relay/openai';
+
+const toItem = (product: ProductCard) => ({ item_id: product.id, item_name: product.name, price: product.price, quantity: 1 });
+
+export const viewProductEvent = defineEvent('viewProduct', (product: ProductCard) => ({
+  ga4: ga4.viewItem({ items: [toItem(product)] }),
+  openai: openai.contentsViewed({ items: [{ id: product.id, name: product.name, price: product.price, quantity: 1 }], currency: 'EUR' }),
+}));
+
+export const selectOfferEvent = defineEvent('selectOffer', (offer: OfferCard) => ({
+  ga4: ga4.selectItem({ item_list_name: 'offers', items: [{ ...toItem(offer.product), affiliation: offer.seller }] }),
+}));
+
+export const searchEvent = defineEvent('search', (term: string) => ({ ga4: ga4.search({ search_term: term }) }));
+
+export const newsletterEvent = defineEvent('newsletter', (lead: { id?: string; user: ConversionUser }) => ({
+  id: lead.id,
+  ga4: ga4.signUp({ method: 'newsletter' }),
+  openai: openai.leadCreated(lead.user),
+}));
+```
+
+The optional `id` is the event's own id, an order number for example. Every destination on both sides then counts the conversion once. Without it, each `track()` call gets a fresh id.
+
+The ga4 and gtm builders cover GA4's recommended events, typed by their parameters. `ga4.event(name, params)` and `gtm.event(name, params)` take any other name. A tag-manager container keeps its own event names: `gtm.event('contactFormStatus', { status: 'success' })`.
+
+Payload types are checked by name through the `RelayDestinations` interface. Each destination entry adds its own; a site's own destination does the same:
+
+```ts
+export type CrmEvent = { kind: string; email: string };
+
+declare module '@astroscope/relay' {
+  interface RelayDestinations {
+    crm: CrmEvent;
+  }
+}
+```
+
+## Tracking in the browser
+
+An island calls `track()`. A page tracks from server-rendered html with `<Track>`. A link or button tracks on click through the `data-track` attribute, which the bus listens for itself, before hydration too.
+
+```ts
+import { track } from '@astroscope/relay/track';
+
+track(searchEvent(term));
+```
+
+```astro
+---
+import { trackAttribute } from '@astroscope/relay';
+import { Track } from '@astroscope/relay/astro';
+---
+<Track event={viewProductEvent(product)} />
+<a href={offer.url} rel="sponsored" data-track={trackAttribute(selectOfferEvent(offer))}>Zum Angebot</a>
+```
+
+```tsx
+import { Track } from '@astroscope/relay/react';
+
+<Track event={viewProductListEvent(products)} />
+```
+
+`@astroscope/relay/track` is the same import in an island and in an action: in the browser it is the bus, on the server the conversions reporter. `inlineTrack(event)` from the root entry gives the script body for hand-written html.
+
+### Batching list sightings
+
+A list is seen one item at a time as rows enter the viewport, while `view_item_list` is one event with all items. `collect()` folds the sightings into batches: one buffer per key, flushed after a quiet time, at most `max` items per batch. A string context is its own key; an object context needs a `key` function.
+
+```ts
+export const viewProductListItem = collect({
+  flush: (list: string, items: ListedItem[]) => track(viewProductListEvent(list, items)),
+  within: 500,
+  max: 16,
+});
+
+viewProductListItem(listName, item);
+```
+
+## The browser bus
+
+`src/relay/client.ts` default-exports `defineRelayClient({ destinations, consent, debug? })`. A promise is awaited. The destinations are registered under their names, the same keys the events put their payloads under. The consent source must cover exactly those names, which the types enforce.
+
+```ts
+// src/relay/client.ts
+import { ccm19 } from '@astroscope/relay/ccm19';
+import { defineRelayClient } from '@astroscope/relay/client';
+import { ga4Tag } from '@astroscope/relay/ga4';
+import { gtmContainer } from '@astroscope/relay/gtm';
+import { matomoTracker } from '@astroscope/relay/matomo';
+
+export default defineRelayClient({
+  destinations: { gtm: gtmContainer(), ga4: ga4Tag(), matomo: matomoTracker() },
+  consent: ccm19({
+    gtm: { embedding: Config.gtm.ccmEmbeddingId },
+    ga4: { cookie: (pattern) => pattern.startsWith('_ga') },
+    matomo: false,
+  }),
+  debug: () => localStorage.getItem('debug') === 'true',
+});
+```
+
+`ccm19()` takes one rule per destination: the embedding with this id, an accepted cookie pattern, a function returning the answer, or `false` for a destination that needs no consent. It re-checks when the visitor closes the widget. For another cmp, write a `ConsentSource` of your own: `names`, `of(name)`, and optionally `free` and `watch(notify)`. An answer of `undefined` means the cmp has not read the stored choice yet, so events wait instead of being dropped.
+
+A destination is a `name`, a `send(payload, meta)` and optionally `ready()`. It only sees events that carry a payload under its name. The bus polls `ready()` briefly and re-checks on the source's `watch`; `notifyRelay()` from `@astroscope/relay/client` re-checks by hand.
+
+```ts
+import type { Destination } from '@astroscope/relay/client';
+
+const crm: Destination<'crm'> = {
+  name: 'crm',
+  send: (event, meta) => sendToCrm(event, meta.id),
+};
+```
+
+`debug` logs every tracked event as a collapsed console group: what came in and, per destination, the payload or why it got nothing.
+
+## Reporting from the server
+
+The bus writes the consented destination names into the `x-relay-consent` header of every same-origin `fetch`. The middleware reads it, and `track()` in an action, an endpoint or a page sends each consented server destination its payload. The call returns the event id, so the browser can fire its pixel under the same one.
+
+```ts
+// src/actions/index.ts
+import { defineAction } from '@astroscope/node/guards';
+import { track } from '@astroscope/relay/track';
+import { z } from 'astro/zod';
+import { newsletterEvent } from '../relay/events';
+
+export const server = {
+  subscribe: defineAction({
+    input: z.object({ email: z.email() }),
+    handler: async ({ email }) => {
+      await subscribe(email);
+
+      return { eventId: track(newsletterEvent({ user: { email } })) };
+    },
+  }),
+};
+```
+
+```tsx
+// the island fires the pixels under the id the server used
+const { data } = await actions.subscribe({ email });
+
+track(newsletterEvent({ id: data.eventId, user: { email } }));
+```
+
+Outside a request, without the header, or for an excluded request `track()` reports nothing and still returns the id. A plain html form post carries no header and reports nothing.
+
+The server destinations are the registry `src/relay/server.ts`. It carries secrets, so the client build refuses to import it.
+
+```ts
+// src/relay/server.ts
+import { openAiConversions } from '@astroscope/relay/openai/server';
+import { defineRelayServer } from '@astroscope/relay/server';
+import { Config } from '@/config';
+
+export default defineRelayServer({
+  destinations: {
+    openai: openAiConversions({ apiKey: Config.openAi.apiKey, pixelId: Config.openAi.pixelId, integrationSource: 'my-site', countryCallingCode: '49' }),
+  },
+  exclude: (ctx) => ctx.locals.session.e2e,
+});
+```
+
+A server destination is a `name` and a `send(payload, meta)`, where `meta` adds the request: client address, headers, a cookie accessor and the source url. Its consent is the flag of its own name in the header. The `consent` map overrides that per name: `false` for a first-party record, or a function over the record to share another destination's flag, `crm: (record) => record.ga4`. `relayConsent()` from `@astroscope/relay/server` gives the record to anything else. `exclude` takes astroscope's path patterns or a predicate over the request context. `hashUser` and the normalizers are exported for a destination that matches on identifiers.
+
+## Destinations
+
+| Entry                             | Builders                                                                                         | Destination                                                                                                             |
+| --------------------------------- | ------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| `@astroscope/relay/ga4`           | `ga4.viewItem()`, `ga4.purchase()`, … and `ga4.event(name, params)`                              | `ga4Tag()`: the google tag via `gtag('event', …)`; installs the queue stub, ready once the tag loaded        |
+| `@astroscope/relay/gtm`           | `gtm.purchase(commerce, params?)`, … and `gtm.event(name, params)`                               | `gtmContainer()`: `dataLayer` pushes with `event_id`; consent is the container's own embedding              |
+| `@astroscope/relay/matomo`        | `matomo.event()`, `matomo.siteSearch()`, `matomo.order()`, `matomo.calls(…)`                      | `matomoTracker()`: the `_paq` queue; a cookieless setup is `false` in the consent source                    |
+| `@astroscope/relay/awin`          | `awin.sale({ amount, orderRef, currency, voucher?, parts? })`                                     | `awinMastertag({ advertiserId, testMode? })`: declares `AWIN.Tracking.Sale` and fires the fall-back pixel               |
+| `@astroscope/relay/openai`        | `openai.contentsViewed()`, `itemsAdded()`, `checkoutStarted()`, `orderCreated()`, `leadCreated()` | `openAiPixel({ countryCallingCode? })`: the openai ads pixel, identifiers hashed and sent through `init`       |
+| `@astroscope/relay/openai/server` | the same builders                                                                                | `openAiConversions({ apiKey, pixelId, integrationSource, countryCallingCode? })`: the conversions api                    |
+
+A destination of your own follows the same shape: builders for the payload, a browser destination, a server destination, all under one name. `wellKnownEvents(create)` from the root entry makes a builder set of the well-known events.
+
+## License
+
+MIT

package/dist/awin/index.d.ts

@@ -0,0 +1,57 @@
+import { a as Destination } from "../bus-Z7l8oJtS.js";
+/** the sale as the mastertag declares it under `AWIN.Tracking.Sale` */
+export type AwinSale = {
+  /** the order total with two decimals */
+  amount: string;
+  orderRef: string;
+  /** the commission groups and their amounts: `GROUP:amount|GROUP:amount` */
+  parts: string;
+  currency: string;
+  /** the voucher code used, or empty */
+  voucher: string;
+};
+declare module '@astroscope/relay' {
+  interface RelayDestinations {
+    awin: AwinSale;
+  }
+}
+export type AwinSaleParams = {
+  /** the order total */
+  amount: number;
+  orderRef: string;
+  currency: string;
+  voucher?: string | undefined;
+  /** the amount per commission group; default: the whole amount under `DEFAULT` */
+  parts?: Readonly<Record<string, number>> | undefined;
+};
+/** The awin builders: the sale an event definition puts under `awin`. */
+export declare const awin: {
+  sale: ({ amount, orderRef, currency, voucher, parts }: AwinSaleParams) => AwinSale;
+};
+type DeclaredSale = AwinSale & {
+  channel: 'aw';
+  test: '0' | '1';
+};
+declare global {
+  interface Window {
+    AWIN?: {
+      Tracking?: {
+        Sale?: DeclaredSale;
+        run?: () => void;
+      };
+    };
+  }
+}
+export type AwinMastertagOptions = {
+  advertiserId: string;
+  /** declare and fire the sales as test sales; default false */
+  testMode?: boolean | undefined;
+};
+/**
+ * The awin mastertag as a destination: the sale is declared under `AWIN.Tracking.Sale` for the
+ * mastertag (loaded by the cmp after consent, it parses the declaration when it loads, or is told
+ * to run when it is there already) and the fall-back pixel is fired right away.
+ */
+export declare function awinMastertag(options: AwinMastertagOptions): Destination<'awin'>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/awin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/awin/index.ts"],"mappings":";;YAGY;;EAEV;EACA;;EAEA;EACA;;EAEA;;;YAIU;IACR,MAAM;;;YAIE;;EAEV;EACA;EACA;EACA;;EAEA,QAAQ,SAAS;;;qBAIN;EAC4C,SAAA,QAAA,UAAA,UAAA,SAAA,SAAA,mBAAiB;;KAWrE,eAAe;EAClB;EACA;;QAGM;YACI;IACR;MACE;QACE,OAAO;QACP;;;;;YAMI;EACV;;EAEA;;;;;;;wBAQc,cAAc,SAAS,uBAAuB"}

package/dist/awin/index.js

@@ -0,0 +1,54 @@
+// src/awin/index.ts
+/** The awin builders: the sale an event definition puts under `awin`. */
+const awin = { sale: ({ amount, orderRef, currency, voucher, parts }) => ({
+	amount: amount.toFixed(2),
+	orderRef,
+	parts: Object.entries(parts ?? { DEFAULT: amount }).map(([group, value]) => `${group}:${value.toFixed(2)}`).join("|"),
+	currency,
+	voucher: voucher ?? ""
+}) };
+/**
+* The awin mastertag as a destination: the sale is declared under `AWIN.Tracking.Sale` for the
+* mastertag (loaded by the cmp after consent, it parses the declaration when it loads, or is told
+* to run when it is there already) and the fall-back pixel is fired right away.
+*/
+function awinMastertag(options) {
+	const { advertiserId, testMode = false } = options;
+	return {
+		name: "awin",
+		send: (sale) => {
+			const declared = {
+				...sale,
+				channel: "aw",
+				test: testMode ? "1" : "0"
+			};
+			declareSale(declared);
+			fireFallbackPixel(advertiserId, declared);
+		}
+	};
+}
+function declareSale(sale) {
+	globalThis.window.AWIN ??= {};
+	globalThis.window.AWIN.Tracking ??= {};
+	globalThis.window.AWIN.Tracking.Sale = sale;
+	globalThis.window.AWIN.Tracking.run?.();
+}
+function fireFallbackPixel(advertiserId, sale) {
+	const params = new URLSearchParams({
+		tt: "ns",
+		tv: "2",
+		merchant: advertiserId,
+		amount: sale.amount,
+		ch: sale.channel,
+		parts: sale.parts,
+		ref: sale.orderRef,
+		cr: sale.currency,
+		vc: sale.voucher,
+		testmode: sale.test
+	});
+	const pixel = new Image(0, 0);
+	pixel.src = `https://www.awin1.com/sread.img?${params.toString()}`;
+}
+export { awin, awinMastertag };
+
+//# sourceMappingURL=index.js.map

package/dist/awin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/awin/index.ts"],"sourcesContent":["import type { Destination } from '../client/bus.js';\n\n/** the sale as the mastertag declares it under `AWIN.Tracking.Sale` */\nexport type AwinSale = {\n  /** the order total with two decimals */\n  amount: string;\n  orderRef: string;\n  /** the commission groups and their amounts: `GROUP:amount|GROUP:amount` */\n  parts: string;\n  currency: string;\n  /** the voucher code used, or empty */\n  voucher: string;\n};\n\ndeclare module '@astroscope/relay' {\n  interface RelayDestinations {\n    awin: AwinSale;\n  }\n}\n\nexport type AwinSaleParams = {\n  /** the order total */\n  amount: number;\n  orderRef: string;\n  currency: string;\n  voucher?: string | undefined;\n  /** the amount per commission group; default: the whole amount under `DEFAULT` */\n  parts?: Readonly<Record<string, number>> | undefined;\n};\n\n/** The awin builders: the sale an event definition puts under `awin`. */\nexport const awin = {\n  sale: ({ amount, orderRef, currency, voucher, parts }: AwinSaleParams): AwinSale => ({\n    amount: amount.toFixed(2),\n    orderRef,\n    parts: Object.entries(parts ?? { DEFAULT: amount })\n      .map(([group, value]) => `${group}:${value.toFixed(2)}`)\n      .join('|'),\n    currency,\n    voucher: voucher ?? '',\n  }),\n};\n\ntype DeclaredSale = AwinSale & {\n  channel: 'aw';\n  test: '0' | '1';\n};\n\ndeclare global {\n  interface Window {\n    AWIN?: {\n      Tracking?: {\n        Sale?: DeclaredSale;\n        run?: () => void;\n      };\n    };\n  }\n}\n\nexport type AwinMastertagOptions = {\n  advertiserId: string;\n  /** declare and fire the sales as test sales; default false */\n  testMode?: boolean | undefined;\n};\n\n/**\n * The awin mastertag as a destination: the sale is declared under `AWIN.Tracking.Sale` for the\n * mastertag (loaded by the cmp after consent, it parses the declaration when it loads, or is told\n * to run when it is there already) and the fall-back pixel is fired right away.\n */\nexport function awinMastertag(options: AwinMastertagOptions): Destination<'awin'> {\n  const { advertiserId, testMode = false } = options;\n\n  return {\n    name: 'awin',\n    send: (sale) => {\n      const declared: DeclaredSale = { ...sale, channel: 'aw', test: testMode ? '1' : '0' };\n\n      declareSale(declared);\n      fireFallbackPixel(advertiserId, declared);\n    },\n  };\n}\n\nfunction declareSale(sale: DeclaredSale): void {\n  globalThis.window.AWIN ??= {};\n  globalThis.window.AWIN.Tracking ??= {};\n  globalThis.window.AWIN.Tracking.Sale = sale;\n\n  globalThis.window.AWIN.Tracking.run?.();\n}\n\nfunction fireFallbackPixel(advertiserId: string, sale: DeclaredSale): void {\n  const params = new URLSearchParams({\n    tt: 'ns',\n    tv: '2',\n    merchant: advertiserId,\n    amount: sale.amount,\n    ch: sale.channel,\n    parts: sale.parts,\n    ref: sale.orderRef,\n    cr: sale.currency,\n    vc: sale.voucher,\n    testmode: sale.test,\n  });\n\n  const pixel = new Image(0, 0);\n\n  pixel.src = `https://www.awin1.com/sread.img?${params.toString()}`;\n}\n"],"mappings":";;AA+BA,MAAa,OAAO,EAClB,OAAO,EAAE,QAAQ,UAAU,UAAU,SAAS,aAAuC;CACnF,QAAQ,OAAO,QAAQ,CAAC;CACxB;CACA,OAAO,OAAO,QAAQ,SAAS,EAAE,SAAS,OAAO,CAAC,CAAC,CAChD,KAAK,CAAC,OAAO,WAAW,GAAG,MAAM,GAAG,MAAM,QAAQ,CAAC,GAAG,CAAC,CACvD,KAAK,GAAG;CACX;CACA,SAAS,WAAW;AACtB,GACF;;;;;;AA6BA,SAAgB,cAAc,SAAoD;CAChF,MAAM,EAAE,cAAc,WAAW,UAAU;CAE3C,OAAO;EACL,MAAM;EACN,OAAO,SAAS;GACd,MAAM,WAAyB;IAAE,GAAG;IAAM,SAAS;IAAM,MAAM,WAAW,MAAM;GAAI;GAEpF,YAAY,QAAQ;GACpB,kBAAkB,cAAc,QAAQ;EAC1C;CACF;AACF;AAEA,SAAS,YAAY,MAA0B;CAC7C,WAAW,OAAO,SAAS,CAAC;CAC5B,WAAW,OAAO,KAAK,aAAa,CAAC;CACrC,WAAW,OAAO,KAAK,SAAS,OAAO;CAEvC,WAAW,OAAO,KAAK,SAAS,MAAM;AACxC;AAEA,SAAS,kBAAkB,cAAsB,MAA0B;CACzE,MAAM,SAAS,IAAI,gBAAgB;EACjC,IAAI;EACJ,IAAI;EACJ,UAAU;EACV,QAAQ,KAAK;EACb,IAAI,KAAK;EACT,OAAO,KAAK;EACZ,KAAK,KAAK;EACV,IAAI,KAAK;EACT,IAAI,KAAK;EACT,UAAU,KAAK;CACjB,CAAC;CAED,MAAM,QAAQ,IAAI,MAAM,GAAG,CAAC;CAE5B,MAAM,MAAM,mCAAmC,OAAO,SAAS;AACjE"}

package/dist/bus-Z7l8oJtS.d.ts

@@ -0,0 +1,48 @@
+import { i as DestinationName, l as RelayDestinations, n as ConsentRecord, p as TrackInput, r as ConsentSource, s as EventMeta, t as ConsentAnswer } from "./shared-CSwqcxPI.js";
+/** one consumer of the bus: a tag, a pixel, a tracker, a log — it takes the payload built for it */
+type Destination<N extends DestinationName = DestinationName> = {
+  /** the destination's name: its key in every event and in the registration, its flag in the consent header */
+  name: N;
+  /** whether the destination's sdk is there to take events; default: always */
+  ready?: (() => boolean) | undefined;
+  send: (payload: RelayDestinations[N], meta: EventMeta) => void;
+};
+/** a destination of any registered name */
+type AnyDestination = { [N in DestinationName]: Destination<N>; }[DestinationName];
+/** the destinations by name: the key an event's payload sits under, which is also the destination's own name */
+type Destinations = { [N in DestinationName]?: Destination<N> | undefined; };
+type RelayConfig<P extends Destinations = Destinations> = {
+  destinations: P;
+  /** the consent of exactly the registered destinations; `NoInfer` keeps `destinations` the only source of the names */
+  consent: ConsentSource<NoInfer<keyof P & string>>;
+  /**
+   * log every tracked event to the console, with what each destination got or why not; a function is asked per event
+   */
+  debug?: boolean | (() => boolean) | undefined;
+};
+/** a consent source for whichever names: what the bus holds, as any `RelayConfig` narrows to it */
+type ConsentHolder = Omit<ConsentSource, 'of'> & {
+  of: (name: never) => ConsentAnswer;
+};
+/** the configuration as the bus takes it, whichever names it was typed for */
+type BusConfig = Omit<RelayConfig, 'consent'> & {
+  consent: ConsentHolder;
+};
+type Bus = {
+  /** register the destinations; events tracked earlier are delivered now */
+  configure: (config: BusConfig) => void;
+  /** put an event on the bus; returns its id */
+  track: (input: TrackInput) => string;
+  /** re-check the destinations' consent and readiness: after the cmp's choice changed or a destination sdk appeared */
+  notify: () => void;
+  /** the consent as known now, by destination name: what a request to the server carries */
+  consent: () => ConsentRecord;
+};
+type BusEnvironment = {
+  now?: (() => number) | undefined;
+  /** schedules a readiness re-check; returns the cancel */
+  schedule?: ((callback: () => void, ms: number) => () => void) | undefined;
+};
+declare function createBus(env?: BusEnvironment): Bus;
+export { Destination as a, createBus as c, BusEnvironment as i, Bus as n, Destinations as o, BusConfig as r, RelayConfig as s, AnyDestination as t };
+//# sourceMappingURL=bus-Z7l8oJtS.d.ts.map

package/dist/bus-Z7l8oJtS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bus-Z7l8oJtS.d.ts","names":[],"sources":["../src/client/bus.ts"],"mappings":";;KAiBY,YAAY,UAAU,kBAAkB;;EAElD,MAAM;;EAEN;EACA,OAAO,SAAS,kBAAkB,IAAI,MAAM;;;KAIlC,oBAAoB,KAAK,kBAAkB,YAAY,MAAK;;KAG5D,kBAAkB,KAAK,mBAAmB,YAAY;KAEtD,YAAY,UAAU,eAAe;EAC/C,cAAc;;EAEd,SAAS,cAAc,cAAc;;;;EAIrC;;;KAIG,gBAAgB,KAAK;EAAyB,KAAK,gBAAgB;;;KAG5D,YAAY,KAAK;EAA4B,SAAS;;KAEtD;;EAEV,YAAY,QAAQ;;EAEpB,QAAQ,OAAO;;EAEf;;EAEA,eAAe;;KAGL;EACV;;EAEA,aAAa,sBAAsB;;iBA0BrB,UAAU,MAAK,iBAAsB"}

package/dist/ccm19/index.d.ts

@@ -0,0 +1,33 @@
+import { i as DestinationName, r as ConsentSource, t as ConsentAnswer } from "../shared-CSwqcxPI.js";
+type Ccm19 = {
+  /** the accepted cookie name patterns, e.g. `_ga_*`; empty before a choice */
+  acceptedCookies?: readonly string[] | undefined;
+  /** the accepted embeddings; empty before a choice */
+  acceptedEmbeddings?: readonly {
+    id: string;
+    name: string;
+  }[] | undefined;
+};
+declare global {
+  interface Window {
+    /** what ccm19 exposes once its script has run */
+    CCM?: Ccm19 | undefined;
+  }
+}
+/**
+ * How a destination's consent is read from ccm19: the embedding with this id is accepted (a missing id
+ * never is), an accepted cookie pattern matches, an answer of your own, or `false` for a destination
+ * that needs none.
+ */
+export type Ccm19Rule = (() => ConsentAnswer) | false | {
+  embedding: string | undefined;
+} | {
+  cookie: (pattern: string) => boolean;
+};
+/**
+ * The consent source over ccm19: a rule per destination, `undefined` until ccm19 has run, re-checked
+ * when the visitor closes the widget.
+ */
+export declare function ccm19<N extends DestinationName>(rules: { [K in N]: Ccm19Rule; }): ConsentSource<N>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/ccm19/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/ccm19/index.ts"],"mappings":";KAEK;;EAEH;;EAEA;IAAgC;IAAY;;;QAGtC;YACI;;IAER,MAAM;;;;;;;;YASE,mBACD;EAEL;;EACA,SAAS;;;;;;wBAyBC,MAAM,UAAU,iBAAiB,UAAU,KAAK,IAAI,eAAc,cAAc"}

package/dist/ccm19/index.js

@@ -0,0 +1,29 @@
+// src/ccm19/index.ts
+const ccm = () => globalThis.window.CCM;
+function answer(rule) {
+	if (rule === false) return true;
+	if (typeof rule === "function") return rule();
+	const current = ccm();
+	if ("embedding" in rule) {
+		const embeddings = current?.acceptedEmbeddings;
+		if (!embeddings) return void 0;
+		return rule.embedding !== void 0 && embeddings.some((embedding) => embedding.id === rule.embedding);
+	}
+	return current?.acceptedCookies?.some((pattern) => rule.cookie(pattern));
+}
+/**
+* The consent source over ccm19: a rule per destination, `undefined` until ccm19 has run, re-checked
+* when the visitor closes the widget.
+*/
+function ccm19(rules) {
+	const entries = Object.entries(rules);
+	return {
+		names: entries.map(([name]) => name),
+		free: entries.filter(([, rule]) => rule === false).map(([name]) => name),
+		of: (name) => answer(rules[name]),
+		watch: (notify) => globalThis.window.addEventListener("ccm19WidgetClosed", notify)
+	};
+}
+export { ccm19 };
+
+//# sourceMappingURL=index.js.map

package/dist/ccm19/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/ccm19/index.ts"],"sourcesContent":["import type { ConsentAnswer, ConsentSource, DestinationName } from '../shared.js';\n\ntype Ccm19 = {\n  /** the accepted cookie name patterns, e.g. `_ga_*`; empty before a choice */\n  acceptedCookies?: readonly string[] | undefined;\n  /** the accepted embeddings; empty before a choice */\n  acceptedEmbeddings?: readonly { id: string; name: string }[] | undefined;\n};\n\ndeclare global {\n  interface Window {\n    /** what ccm19 exposes once its script has run */\n    CCM?: Ccm19 | undefined;\n  }\n}\n\n/**\n * How a destination's consent is read from ccm19: the embedding with this id is accepted (a missing id\n * never is), an accepted cookie pattern matches, an answer of your own, or `false` for a destination\n * that needs none.\n */\nexport type Ccm19Rule =\n  | (() => ConsentAnswer)\n  | false\n  | { embedding: string | undefined }\n  | { cookie: (pattern: string) => boolean };\n\nconst ccm = (): Ccm19 | undefined => globalThis.window.CCM;\n\nfunction answer(rule: Ccm19Rule): ConsentAnswer {\n  if (rule === false) return true;\n  if (typeof rule === 'function') return rule();\n\n  const current = ccm();\n\n  if ('embedding' in rule) {\n    const embeddings = current?.acceptedEmbeddings;\n\n    if (!embeddings) return undefined;\n\n    return rule.embedding !== undefined && embeddings.some((embedding) => embedding.id === rule.embedding);\n  }\n\n  return current?.acceptedCookies?.some((pattern) => rule.cookie(pattern));\n}\n\n/**\n * The consent source over ccm19: a rule per destination, `undefined` until ccm19 has run, re-checked\n * when the visitor closes the widget.\n */\nexport function ccm19<N extends DestinationName>(rules: { [K in N]: Ccm19Rule }): ConsentSource<N> {\n  const entries = Object.entries(rules) as [N, Ccm19Rule][];\n\n  return {\n    names: entries.map(([name]) => name),\n    free: entries.filter(([, rule]) => rule === false).map(([name]) => name),\n    of: (name) => answer(rules[name]),\n    watch: (notify) => globalThis.window.addEventListener('ccm19WidgetClosed', notify),\n  };\n}\n"],"mappings":";AA2BA,MAAM,YAA+B,WAAW,OAAO;AAEvD,SAAS,OAAO,MAAgC;CAC9C,IAAI,SAAS,OAAO,OAAO;CAC3B,IAAI,OAAO,SAAS,YAAY,OAAO,KAAK;CAE5C,MAAM,UAAU,IAAI;CAEpB,IAAI,eAAe,MAAM;EACvB,MAAM,aAAa,SAAS;EAE5B,IAAI,CAAC,YAAY,OAAO,KAAA;EAExB,OAAO,KAAK,cAAc,KAAA,KAAa,WAAW,MAAM,cAAc,UAAU,OAAO,KAAK,SAAS;CACvG;CAEA,OAAO,SAAS,iBAAiB,MAAM,YAAY,KAAK,OAAO,OAAO,CAAC;AACzE;;;;;AAMA,SAAgB,MAAiC,OAAkD;CACjG,MAAM,UAAU,OAAO,QAAQ,KAAK;CAEpC,OAAO;EACL,OAAO,QAAQ,KAAK,CAAC,UAAU,IAAI;EACnC,MAAM,QAAQ,QAAQ,GAAG,UAAU,SAAS,KAAK,CAAC,CAAC,KAAK,CAAC,UAAU,IAAI;EACvE,KAAK,SAAS,OAAO,MAAM,KAAK;EAChC,QAAQ,WAAW,WAAW,OAAO,iBAAiB,qBAAqB,MAAM;CACnF;AACF"}

package/dist/client/index.d.ts

@@ -0,0 +1,16 @@
+import { a as Destination, c as createBus, i as BusEnvironment, n as Bus, o as Destinations, r as BusConfig, s as RelayConfig, t as AnyDestination } from "../bus-Z7l8oJtS.js";
+/**
+ * Types the browser half: the default export of `src/relay/client.ts`, which the integration loads
+ * on every page and configures the bus with. A promise is awaited, for a setup that has to wait
+ * for something first.
+ */
+export declare function defineRelayClient<P extends Destinations>(config: RelayConfig<P> | Promise<RelayConfig<P>>): RelayConfig<P> | Promise<RelayConfig<P>>;
+/**
+ * Registers the destinations; events tracked earlier are delivered now. The integration does this with
+ * the client module's default export.
+ */
+export declare function configureRelay<P extends Destinations>(config: RelayConfig<P>): void;
+/** re-checks the destinations' consent and readiness: after the cmp's choice changed or a destination sdk appeared */
+export declare function notifyRelay(): void;
+export { type AnyDestination, type Bus, type BusConfig, type BusEnvironment, type Destination, type Destinations, type RelayConfig, createBus };
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/client/index.ts"],"mappings":";;;;;;wBAWgB,kBAAkB,UAAU,cAC1C,QAAQ,YAAY,KAAK,QAAQ,YAAY,MAC5C,YAAY,KAAK,QAAQ,YAAY;;;;;wBAQxB,eAAe,UAAU,cAAc,QAAQ,YAAY;;wBAK3D"}

package/dist/client/index.js

@@ -0,0 +1,24 @@
+import { n as createBus, t as bus } from "../instance-Bu0EMJ_-.js";
+// src/client/index.ts
+/**
+* Types the browser half: the default export of `src/relay/client.ts`, which the integration loads
+* on every page and configures the bus with. A promise is awaited, for a setup that has to wait
+* for something first.
+*/
+function defineRelayClient(config) {
+	return config;
+}
+/**
+* Registers the destinations; events tracked earlier are delivered now. The integration does this with
+* the client module's default export.
+*/
+function configureRelay(config) {
+	bus.configure(config);
+}
+/** re-checks the destinations' consent and readiness: after the cmp's choice changed or a destination sdk appeared */
+function notifyRelay() {
+	bus.notify();
+}
+export { configureRelay, createBus, defineRelayClient, notifyRelay };
+
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/client/index.ts"],"sourcesContent":["import type { Destinations, RelayConfig } from './bus.js';\nimport { bus } from './instance.js';\n\nexport type { AnyDestination, Bus, BusConfig, BusEnvironment, Destination, Destinations, RelayConfig } from './bus.js';\nexport { createBus } from './bus.js';\n\n/**\n * Types the browser half: the default export of `src/relay/client.ts`, which the integration loads\n * on every page and configures the bus with. A promise is awaited, for a setup that has to wait\n * for something first.\n */\nexport function defineRelayClient<P extends Destinations>(\n  config: RelayConfig<P> | Promise<RelayConfig<P>>,\n): RelayConfig<P> | Promise<RelayConfig<P>> {\n  return config;\n}\n\n/**\n * Registers the destinations; events tracked earlier are delivered now. The integration does this with\n * the client module's default export.\n */\nexport function configureRelay<P extends Destinations>(config: RelayConfig<P>): void {\n  bus.configure(config);\n}\n\n/** re-checks the destinations' consent and readiness: after the cmp's choice changed or a destination sdk appeared */\nexport function notifyRelay(): void {\n  bus.notify();\n}\n"],"mappings":";;;;;;;AAWA,SAAgB,kBACd,QAC0C;CAC1C,OAAO;AACT;;;;;AAMA,SAAgB,eAAuC,QAA8B;CACnF,IAAI,UAAU,MAAM;AACtB;;AAGA,SAAgB,cAAoB;CAClC,IAAI,OAAO;AACb"}

package/dist/client/track.d.ts

@@ -0,0 +1,4 @@
+import { f as TrackFunction } from "../shared-CSwqcxPI.js";
+/** records that something happened: the event, with the payloads of the destinations it is meant for; returns its id */
+export declare const track: TrackFunction;
+//# sourceMappingURL=track.d.ts.map

package/dist/client/track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.d.ts","names":[],"sources":["../../src/client/track.ts"],"mappings":";;qBAIa,OAAO"}

package/dist/client/track.js

@@ -0,0 +1,7 @@
+import { t as bus } from "../instance-Bu0EMJ_-.js";
+// src/client/track.ts
+/** records that something happened: the event, with the payloads of the destinations it is meant for; returns its id */
+const track = (input) => bus.track(input);
+export { track };
+
+//# sourceMappingURL=track.js.map

package/dist/client/track.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.js","names":[],"sources":["../../src/client/track.ts"],"sourcesContent":["import type { TrackFunction } from '../shared.js';\nimport { bus } from './instance.js';\n\n/** records that something happened: the event, with the payloads of the destinations it is meant for; returns its id */\nexport const track: TrackFunction = (input) => bus.track(input);\n"],"mappings":";;;AAIA,MAAa,SAAwB,UAAU,IAAI,MAAM,KAAK"}

package/dist/collect-DRl177oR.d.ts

@@ -0,0 +1,31 @@
+import { p as TrackInput } from "./shared-CSwqcxPI.js";
+/**
+ * The body of an inline script that tracks an event from hand-written html, before or after the
+ * bus is installed; `<Track>` is the same thing as an Astro component.
+ */
+declare function inlineTrack(input: TrackInput): string;
+/** a collector's options; the context identifies the batch and is handed back with it */
+type CollectOptions<Ctx, Item> = {
+  /** takes one batch: the context of its first sighting and the items collected under that key */
+  flush: (context: Ctx, items: Item[]) => void;
+  /** the quiet time after the last sighting before the batch goes out, in ms; default 500 */
+  within?: number | undefined;
+  /** the items a batch carries at most, 1 or more; a fuller buffer goes out as several batches; default unlimited */
+  max?: number | undefined;
+};
+/** a string context is its own key; any other context needs a key function */
+type KeyOption<Ctx> = Ctx extends string ? {
+  key?: ((context: Ctx) => string) | undefined;
+} : {
+  key: (context: Ctx) => string;
+};
+/**
+ * Folds single sightings into batched events: a list of items is seen one item at a time as the
+ * rows enter the viewport, while `view_item_list` is one event with the items. The collector
+ * keeps a buffer per key and flushes it after the quiet time, in chunks of at most `max` items.
+ * Buffers are shared by every caller of the collector, so sightings with the same key from
+ * several components go out as one batch.
+ */
+declare function collect<Ctx, Item>(options: CollectOptions<Ctx, Item> & KeyOption<Ctx>): (context: Ctx, item: Item) => void;
+export { collect as n, inlineTrack as r, CollectOptions as t };
+//# sourceMappingURL=collect-DRl177oR.d.ts.map

package/dist/collect-DRl177oR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-DRl177oR.d.ts","names":[],"sources":["../src/inline.ts","../src/collect.ts"],"mappings":";;;;;iBAMgB,YAAY,OAAO;;KCLvB,eAAe,KAAK;;EAE9B,QAAQ,SAAS,KAAK,OAAO;;EAE7B;;EAEA;;;KAIG,UAAU,OAAO;EAChB,QAAQ,SAAS;;EACjB,MAAM,SAAS;;;;;;;;;iBAiBL,QAAQ,KAAK,MAC3B,SAAS,eAAe,KAAK,QAAQ,UAAU,QAC7C,SAAS,KAAK,MAAM"}