stitchkit 0.116.0 → 0.117.0

package/dist/entrypoints/telegram.js

@@ -5,7 +5,7 @@ import"../index-2kbysk9s.js";
 import"../index-n8z3rvzw.js";
 import {
   attemptExclusiveLock
-} from "../index-z3d6smer.js";
+} from "../index-tdpmfks8.js";
 import {
   TELEGRAM_SEND_FAILURE_REASONS2,
   classifyTelegramSendFailure2
@@ -908,11 +908,8 @@ function telegramOperatorSender(config) {
 }
 // src/telegram/outbound-budget.ts
 import { z as z5 } from "zod";
-var DEFAULT_MESSAGES_PER_SECOND = 24;
-var DEFAULT_RETRY_AFTER_FALLBACK_MS = 1000;
-var TOKEN = z5.string().min(1, "token must not be empty");
-var MESSAGES_PER_SECOND = z5.number().positive().max(1000);
-var RETRY_AFTER_FALLBACK_MS = z5.number().int().nonnegative().max(MAX_TIMER_MS);
+
+// src/telegram/outbound-cost.ts
 var SEND_METHODS = new Set([
   "sendMessage",
   "sendPhoto",
@@ -959,15 +956,69 @@ function sendCost(method, payload) {
   const value = payload[field];
   return Array.isArray(value) ? Math.max(1, value.length) : 1;
 }
-function createBudget(rate, fallback, now, sleepFor) {
-  const interval = 1000 / rate;
+function chatOf(payload) {
+  if (!isRecord(payload))
+    return;
+  const chat = payload.chat_id;
+  return typeof chat === "number" || typeof chat === "string" ? String(chat) : undefined;
+}
+
+// src/telegram/outbound-pauses.ts
+function createOutboundPauses({ tokenPauseChats, tokenPauseWindowMs }, now, onPause) {
+  const chatPauses = new Map;
+  const refusedChats = new Map;
+  let pausedUntil = Number.NEGATIVE_INFINITY;
+  const pauseEnd = (milliseconds) => {
+    if (Number.isNaN(milliseconds) || milliseconds < 0) {
+      throw new RangeError("pause must be a non-negative number of milliseconds");
+    }
+    return now() + (Number.isFinite(milliseconds) ? milliseconds : Number.MAX_SAFE_INTEGER);
+  };
+  const pauseToken = (milliseconds) => {
+    pausedUntil = Math.max(pausedUntil, pauseEnd(milliseconds));
+    onPause();
+  };
+  const forgetExpired = (current) => {
+    for (const [chat, until] of chatPauses)
+      if (until <= current)
+        chatPauses.delete(chat);
+    for (const [chat, at] of refusedChats) {
+      if (current - at > tokenPauseWindowMs)
+        refusedChats.delete(chat);
+    }
+  };
+  return {
+    resumesAt: (chat) => Math.max(pausedUntil, (chat === undefined ? undefined : chatPauses.get(chat)) ?? Number.NEGATIVE_INFINITY),
+    pauseToken,
+    pauseChat(chat, milliseconds) {
+      const until = pauseEnd(milliseconds);
+      const current = now();
+      forgetExpired(current);
+      chatPauses.set(chat, Math.max(chatPauses.get(chat) ?? until, until));
+      refusedChats.set(chat, current);
+      onPause();
+      if (refusedChats.size < tokenPauseChats)
+        return;
+      refusedChats.clear();
+      pauseToken(milliseconds);
+    },
+    pausedForMs: () => Math.max(0, pausedUntil - now()),
+    pausedChats() {
+      forgetExpired(now());
+      return chatPauses.size;
+    }
+  };
+}
+
+// src/telegram/outbound-queue.ts
+function createOutboundQueue(interval, now, sleepFor, pauses) {
   const queue = [];
   let nextGrantAt = now();
-  let pausedUntil = Number.NEGATIVE_INFINITY;
   let granted = 0;
   let messages = 0;
   let draining = false;
-  let wake;
+  let waking;
+  let wakingAt = Number.POSITIVE_INFINITY;
   const wait = async (milliseconds, signal) => {
     const delay = Math.min(MAX_TIMER_MS, Math.max(0, milliseconds));
     if (delay <= 0)
@@ -978,20 +1029,40 @@ function createBudget(rate, fallback, now, sleepFor) {
     else
       await pending;
   };
-  const wakeWaiting = () => {
-    const current = wake;
-    wake = undefined;
+  const wake = () => {
+    const current = waking;
+    waking = undefined;
     current?.abort();
   };
-  const nextWaiter = () => queue.find((waiter) => waiter.lane === "interactive") ?? queue[0];
+  const nextWaiter = (current) => {
+    let bulk;
+    let held;
+    for (const waiter of queue) {
+      if (pauses.resumesAt(waiter.chat) > current) {
+        if (held === undefined || pauses.resumesAt(waiter.chat) < pauses.resumesAt(held.chat)) {
+          held = waiter;
+        }
+      } else if (waiter.lane === "interactive") {
+        return waiter;
+      } else {
+        bulk ??= waiter;
+      }
+    }
+    return bulk ?? held;
+  };
+  const detach = (waiter) => {
+    if (waiter.onAbort)
+      waiter.signal?.removeEventListener("abort", waiter.onAbort);
+    waiter.expiry?.abort();
+  };
   const remove = (waiter) => {
     const index = queue.indexOf(waiter);
     if (index === -1)
       return;
-    const next = nextWaiter() === waiter;
+    const next = nextWaiter(now()) === waiter;
     queue.splice(index, 1);
     if (next)
-      wakeWaiting();
+      wake();
   };
   const drain = async () => {
     if (draining)
@@ -999,38 +1070,38 @@ function createBudget(rate, fallback, now, sleepFor) {
     draining = true;
     try {
       while (queue.length > 0) {
-        const head = nextWaiter();
+        const current = now();
+        const head = nextWaiter(current);
         if (head === undefined)
           break;
         if (head.signal?.aborted) {
           remove(head);
           continue;
         }
-        const current = now();
-        const at = Math.max(current, nextGrantAt, pausedUntil);
+        const at = Math.max(current, nextGrantAt, pauses.resumesAt(head.chat));
         if (at > current) {
           const controller = new AbortController;
-          wake = controller;
+          waking = controller;
+          wakingAt = at;
           try {
             await wait(at - current, controller.signal);
           } catch (error) {
             if (!controller.signal.aborted) {
               for (const waiter of queue.splice(0)) {
-                if (waiter.onAbort)
-                  waiter.signal?.removeEventListener("abort", waiter.onAbort);
+                detach(waiter);
                 waiter.reject(error);
               }
               return;
             }
           } finally {
-            if (wake === controller)
-              wake = undefined;
+            if (waking === controller)
+              waking = undefined;
+            wakingAt = Number.POSITIVE_INFINITY;
           }
           continue;
         }
         queue.splice(queue.indexOf(head), 1);
-        if (head.onAbort)
-          head.signal?.removeEventListener("abort", head.onAbort);
+        detach(head);
         nextGrantAt = at + head.cost * interval;
         granted += 1;
         messages += head.cost;
@@ -1042,67 +1113,115 @@ function createBudget(rate, fallback, now, sleepFor) {
         drain();
     }
   };
-  const acquire = (cost, signal, options) => {
-    if (!Number.isSafeInteger(cost) || cost < 1) {
-      return Promise.reject(new RangeError("cost must be an integer of at least one message"));
-    }
-    if (signal?.aborted)
-      return Promise.reject(signal.reason);
-    return new Promise((resolve, reject) => {
-      const waiter = {
-        cost,
-        lane: options?.lane ?? "interactive",
-        resolve,
-        reject,
-        ...signal && { signal }
-      };
-      if (signal) {
-        const onAbort = () => {
-          remove(waiter);
-          reject(signal.reason);
-        };
-        waiter.onAbort = onAbort;
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      queue.push(waiter);
-      drain();
+  const expireAfter = (waiter, maxWaitMs, reject) => {
+    waiter.expiry = new AbortController;
+    wait(maxWaitMs, waiter.expiry.signal).then(() => {
+      if (!queue.includes(waiter))
+        return;
+      remove(waiter);
+      detach(waiter);
+      reject(new TelegramNotDispatchedError2("queue", "the Telegram request waited longer than maxWaitMs for its turn"));
+    }, () => {
+      return;
     });
   };
-  const pauseFor = (milliseconds) => {
-    if (Number.isNaN(milliseconds) || milliseconds < 0) {
-      throw new RangeError("pause must be a non-negative number of milliseconds");
-    }
-    const duration = Number.isFinite(milliseconds) ? milliseconds : Number.MAX_SAFE_INTEGER;
-    pausedUntil = Math.max(pausedUntil, now() + duration);
-    wakeWaiting();
+  return {
+    acquire(cost, signal, options) {
+      if (!Number.isSafeInteger(cost) || cost < 1) {
+        return Promise.reject(new RangeError("cost must be an integer of at least one message"));
+      }
+      if (signal?.aborted)
+        return Promise.reject(signal.reason);
+      const maxWaitMs = options?.maxWaitMs;
+      if (maxWaitMs !== undefined && (!Number.isSafeInteger(maxWaitMs) || maxWaitMs < 1 || maxWaitMs > MAX_TIMER_MS)) {
+        return Promise.reject(new RangeError(`maxWaitMs must be an integer from 1 to ${MAX_TIMER_MS}`));
+      }
+      const chat = options?.chatId === undefined ? undefined : String(options.chatId);
+      return new Promise((resolve, reject) => {
+        const waiter = {
+          cost,
+          lane: options?.lane ?? "interactive",
+          chat,
+          resolve,
+          reject,
+          ...signal && { signal }
+        };
+        if (signal) {
+          const onAbort = () => {
+            remove(waiter);
+            detach(waiter);
+            reject(signal.reason);
+          };
+          waiter.onAbort = onAbort;
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        if (maxWaitMs !== undefined)
+          expireAfter(waiter, maxWaitMs, reject);
+        queue.push(waiter);
+        if (Math.max(now(), nextGrantAt, pauses.resumesAt(chat)) < wakingAt)
+          wake();
+        drain();
+      });
+    },
+    wake,
+    wait,
+    counts: () => ({
+      granted,
+      messages,
+      queued: queue.length,
+      queuedBulk: queue.filter((waiter) => waiter.lane === "bulk").length
+    })
   };
-  const pauseAfter = (error) => {
+}
+
+// src/telegram/outbound-budget.ts
+var DEFAULT_MESSAGES_PER_SECOND = 24;
+var DEFAULT_RETRY_AFTER_FALLBACK_MS = 1000;
+var DEFAULT_TOKEN_PAUSE_CHATS = 3;
+var DEFAULT_TOKEN_PAUSE_WINDOW_MS = 5000;
+var TOKEN = z5.string().min(1, "token must not be empty");
+var MESSAGES_PER_SECOND = z5.number().positive().max(1000);
+var RETRY_AFTER_FALLBACK_MS = z5.number().int().nonnegative().max(MAX_TIMER_MS);
+var TOKEN_PAUSE_CHATS = z5.number().int().min(2).max(1000);
+var TOKEN_PAUSE_WINDOW_MS = z5.number().int().positive().max(MAX_TIMER_MS);
+function createBudget(policy, now, sleepFor) {
+  const { rate, fallback } = policy;
+  const pauses = createOutboundPauses(policy, now, () => queue.wake());
+  const queue = createOutboundQueue(1000 / rate, now, sleepFor, pauses);
+  const pauseAfter = (error, options) => {
     const failure = classifyTelegramSendFailure2(error);
     if (failure.reason !== "rate-limited")
       return;
-    pauseFor(failure.retryAfterSeconds === undefined ? fallback : failure.retryAfterSeconds * 1000);
+    const milliseconds = failure.retryAfterSeconds === undefined ? fallback : failure.retryAfterSeconds * 1000;
+    if (options?.chatId === undefined)
+      pauses.pauseToken(milliseconds);
+    else
+      pauses.pauseChat(String(options.chatId), milliseconds);
   };
-  const waitUntilResumed = async (signal) => {
+  const waitUntilResumed = async (signal, options) => {
+    const chat = options?.chatId === undefined ? undefined : String(options.chatId);
     while (true) {
       if (signal?.aborted)
         throw signal.reason;
-      const remaining = pausedUntil - now();
+      const remaining = pauses.resumesAt(chat) - now();
       if (remaining <= 0)
         return;
-      await wait(Math.min(remaining, MAX_TIMER_MS), signal);
+      await queue.wait(Math.min(remaining, MAX_TIMER_MS), signal);
     }
   };
   const run = async (method, payload, signal, send, options) => {
     if (signal?.aborted)
       throw signal.reason;
     const cost = sendCost(method, payload);
+    const chatId = options?.chatId ?? chatOf(payload);
+    const call = chatId === undefined ? {} : { chatId };
     if (cost > 0)
-      await acquire(cost, signal, options);
+      await queue.acquire(cost, signal, { ...options, ...call });
     if (signal?.aborted)
       throw signal.reason;
     const pauseOnRefusal = (refusal) => {
-      if (cost > 0)
-        pauseAfter(refusal);
+      if (cost > 0 && options?.refusal !== "call")
+        pauseAfter(refusal, call);
     };
     let result;
     try {
@@ -1115,22 +1234,19 @@ function createBudget(rate, fallback, now, sleepFor) {
       pauseOnRefusal(result);
     return result;
   };
-  const budget = {
+  return {
     run,
-    acquire,
-    pause: pauseFor,
+    acquire: queue.acquire,
+    pause: pauses.pauseToken,
     pauseAfter,
     waitUntilResumed,
     stats: () => ({
-      granted,
-      messages,
-      queued: queue.length,
-      queuedBulk: queue.filter((waiter) => waiter.lane === "bulk").length,
+      ...queue.counts(),
       messagesPerSecond: rate,
-      pausedForMs: Math.max(0, pausedUntil - now())
+      pausedForMs: pauses.pausedForMs(),
+      pausedChats: pauses.pausedChats()
     })
   };
-  return budget;
 }
 var budgets = new Map;
 function keyOf(token) {
@@ -1140,20 +1256,24 @@ function telegramOutboundBudget(config) {
   const token = TOKEN.parse(config.token);
   const rate = MESSAGES_PER_SECOND.parse(config.messagesPerSecond ?? DEFAULT_MESSAGES_PER_SECOND);
   const fallback = RETRY_AFTER_FALLBACK_MS.parse(config.retryAfterFallbackMs ?? DEFAULT_RETRY_AFTER_FALLBACK_MS);
+  const tokenPauseChats = TOKEN_PAUSE_CHATS.parse(config.tokenPauseChats ?? DEFAULT_TOKEN_PAUSE_CHATS);
+  const tokenPauseWindowMs = TOKEN_PAUSE_WINDOW_MS.parse(config.tokenPauseWindowMs ?? DEFAULT_TOKEN_PAUSE_WINDOW_MS);
   const key = keyOf(token);
   const existing = budgets.get(key);
   if (existing) {
-    const same = existing.rate === rate && existing.fallback === fallback && existing.nowOption === config.now && existing.sleepOption === config.sleep;
+    const same = existing.rate === rate && existing.fallback === fallback && existing.tokenPauseChats === tokenPauseChats && existing.tokenPauseWindowMs === tokenPauseWindowMs && existing.nowOption === config.now && existing.sleepOption === config.sleep;
     if (!same) {
       throw new Error("a Telegram outbound budget already exists for this token with different options");
     }
     return existing.budget;
   }
-  const budget = createBudget(rate, fallback, config.now ?? (() => performance.now()), config.sleep ?? sleep);
+  const budget = createBudget({ rate, fallback, tokenPauseChats, tokenPauseWindowMs }, config.now ?? (() => performance.now()), config.sleep ?? sleep);
   budgets.set(key, {
     budget,
     rate,
     fallback,
+    tokenPauseChats,
+    tokenPauseWindowMs,
     nowOption: config.now,
     sleepOption: config.sleep
   });

package/dist/entrypoints/tracking/contract.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `stitchkit/tracking/contract` — the wire shapes of tracking: the contract
+ * factory, the event and visit schemas, and the performance sample with its
+ * trust threshold. It brings `zod`, so it belongs to the server and to a shared
+ * contract, and browser code that sends events does not import it. → ADR 0280.
+ */
+export { createTrackingContract, type TrackingContractConfig, type TrackingContractEndpoints, } from '../../tracking/contract.js';
+export { type PerformanceSample, PerformanceSampleSchema, type PerformanceVitals, PerformanceVitalsSchema, } from '../../tracking/performance/schema.js';
+export { type PerformanceMetricSummary, summarizePerformanceMetric, } from '../../tracking/performance/summary.js';
+export { type AttributionData, AttributionDataSchema, createTrackingSchemas, DEFAULT_BUILD_ID_PATTERN, type TrackEventsRequest, type TrackEventsResponse, TrackEventsResponseSchema, type TrackingDisposition, TrackingDispositionSchema, type TrackingDispositionStatus, TrackingDispositionStatusSchema, type TrackingEventEnvelope, type TrackingEventShape, type TrackingOutboxState, TrackingOutboxStateSchema, type TrackingSchemas, type TrackingSchemasConfig, type UtmData, UtmDataSchema, type VisitBootstrapResponse, VisitBootstrapResponseSchema, type VisitEntryContext, type VisitEntryContextShape, } from '../../tracking/schemas.js';
+//# sourceMappingURL=contract.d.ts.map

package/dist/entrypoints/tracking/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/tracking/contract.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,GAC/B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,uBAAuB,GACxB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,KAAK,wBAAwB,EAC7B,0BAA0B,GAC3B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,KAAK,eAAe,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,OAAO,EACZ,aAAa,EACb,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,GAC5B,MAAM,wBAAwB,CAAC"}

package/dist/entrypoints/tracking/contract.js

@@ -0,0 +1,162 @@
+import"../../index-m38ej7e5.js";
+import {
+  defineContract2
+} from "../../index-d9hq291n.js";
+
+// src/tracking/schemas.ts
+import { z } from "zod";
+var UtmDataSchema = z.object({
+  source: z.string().max(200).optional(),
+  medium: z.string().max(200).optional(),
+  campaign: z.string().max(200).optional(),
+  content: z.string().max(200).optional(),
+  term: z.string().max(200).optional()
+});
+var AttributionDataSchema = z.object({
+  utm: UtmDataSchema.optional(),
+  referrer: z.string().optional(),
+  landingPage: z.string().optional()
+});
+var DEFAULT_BUILD_ID_PATTERN = /^(dev|[a-f0-9]{7,40})$/;
+var TrackingDispositionStatusSchema = z.enum([
+  "accepted",
+  "duplicate",
+  "identity-invalid",
+  "excluded-bot"
+]);
+var TrackingDispositionSchema = z.object({
+  eventId: z.uuid(),
+  status: TrackingDispositionStatusSchema
+});
+var TrackEventsResponseSchema = z.object({
+  accepted: z.number().int().nonnegative(),
+  dispositions: z.array(TrackingDispositionSchema)
+});
+var VisitBootstrapResponseSchema = z.object({
+  visitId: z.uuid(),
+  expiresAt: z.iso.datetime()
+});
+var TrackingOutboxStateSchema = z.enum(["available", "unavailable"]);
+function trackingEventShape(eventTypes) {
+  return {
+    eventId: z.uuid(),
+    visitId: z.uuid(),
+    browserStreamId: z.uuid(),
+    browserSequence: z.number().int().nonnegative(),
+    type: z.enum(eventTypes),
+    page: z.string().max(2000),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    clientTimestamp: z.number()
+  };
+}
+function visitEntryContextShape(buildIdPattern) {
+  return {
+    browserStreamId: z.uuid(),
+    previousVisitId: z.uuid().optional(),
+    origin: z.url().max(500),
+    landingPath: z.string().startsWith("/").max(300).regex(/^[^?#]*$/),
+    referrer: z.url().max(2000).optional(),
+    utm: UtmDataSchema.optional(),
+    displayMode: z.enum(["browser", "standalone"]),
+    screenWidth: z.number().int().positive().max(20000),
+    screenHeight: z.number().int().positive().max(20000),
+    buildId: z.string().regex(buildIdPattern),
+    outboxState: TrackingOutboxStateSchema,
+    outboxQueued: z.number().int().nonnegative().max(1000),
+    outboxDropped: z.number().int().nonnegative()
+  };
+}
+function createTrackingSchemas(config) {
+  const base = z.object(trackingEventShape(config.eventTypes));
+  const event = config.eventExtras ? base.extend(config.eventExtras.shape) : base;
+  const buildIdPattern = config.buildIdPattern ?? DEFAULT_BUILD_ID_PATTERN;
+  const maxEvents = config.maxEventsPerBatch ?? 50;
+  return {
+    event,
+    request: z.object({
+      buildId: z.string().regex(buildIdPattern),
+      events: z.array(event).min(1).max(maxEvents),
+      utm: UtmDataSchema.optional()
+    }),
+    response: TrackEventsResponseSchema,
+    disposition: TrackingDispositionSchema,
+    entry: z.object(visitEntryContextShape(buildIdPattern)),
+    bootstrap: VisitBootstrapResponseSchema
+  };
+}
+
+// src/tracking/contract.ts
+function createTrackingContract(config) {
+  const schemas = createTrackingSchemas(config);
+  return defineContract2({ prefix: config.prefix ?? "tracking", scope: config.scope }, {
+    bootstrap: {
+      method: "POST",
+      path: "/visit",
+      expose: ["HTTP"],
+      desc: "Issue or renew a browser visit lease",
+      input: schemas.entry,
+      output: schemas.bootstrap
+    },
+    track: {
+      method: "POST",
+      path: "/events",
+      expose: ["HTTP"],
+      desc: "Batch track browser events",
+      input: schemas.request,
+      output: schemas.response,
+      safelistedBody: true,
+      maxJsonBodyBytes: config.maxJsonBodyBytes ?? 256 * 1024
+    }
+  });
+}
+// src/tracking/performance/schema.ts
+import { z as z2 } from "zod";
+var BoundedMsSchema = z2.number().nonnegative().max(3600000).nullable();
+var PerformanceVitalsSchema = z2.object({
+  lcpMs: BoundedMsSchema,
+  inpMs: BoundedMsSchema,
+  fcpMs: BoundedMsSchema,
+  ttfbMs: BoundedMsSchema,
+  cls: z2.number().nonnegative().max(100).nullable()
+});
+var PerformanceSampleSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  id: z2.string().min(1).max(64),
+  kind: z2.enum(["early", "final"]),
+  route: z2.string().min(1).max(2000),
+  buildId: z2.string().min(1).max(64),
+  visitId: z2.string().min(1).max(128).nullable(),
+  deviceClass: z2.enum(["mobile", "desktop"]),
+  navigationType: z2.string().min(1).max(32).nullable(),
+  vitals: PerformanceVitalsSchema,
+  capturedAt: z2.number().int().nonnegative()
+});
+// src/tracking/performance/summary.ts
+var DEFAULT_MIN_SAMPLES = 100;
+function percentile(ascending, rank) {
+  return ascending[Math.ceil(ascending.length * rank) - 1] ?? null;
+}
+function summarizePerformanceMetric(values, options = {}) {
+  const present = values.filter((value) => value !== null).sort((left, right) => left - right);
+  const trusted = present.length >= (options.minSamples ?? DEFAULT_MIN_SAMPLES);
+  return {
+    samples: present.length,
+    p75: percentile(present, 0.75),
+    p95: trusted ? percentile(present, 0.95) : null
+  };
+}
+export {
+  AttributionDataSchema,
+  DEFAULT_BUILD_ID_PATTERN,
+  PerformanceSampleSchema,
+  PerformanceVitalsSchema,
+  TrackEventsResponseSchema,
+  TrackingDispositionSchema,
+  TrackingDispositionStatusSchema,
+  TrackingOutboxStateSchema,
+  UtmDataSchema,
+  VisitBootstrapResponseSchema,
+  createTrackingContract,
+  createTrackingSchemas,
+  summarizePerformanceMetric
+};

package/dist/entrypoints/tracking/performance.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `stitchkit/tracking/performance` — Web Vitals from real visitors, collected
+ * after the page has loaded. The sample's schema and the report's trust threshold
+ * are `stitchkit/tracking/contract`; tables and reports stay the application's.
+ * Importing this needs the optional peer `web-vitals`. → ADR 0280.
+ */
+export { createPerformanceCollector, isLabUserAgent, type PerformanceCollector, type PerformanceCollectorConfig, type PerformanceHost, type VitalsLibrary, type VitalsMetric, type VitalsObserver, } from '../../tracking/performance/collector.js';
+//# sourceMappingURL=performance.d.ts.map

package/dist/entrypoints/tracking/performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/tracking/performance.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,0BAA0B,EAC1B,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,cAAc,GACpB,MAAM,sCAAsC,CAAC"}