@keystrokehq/segment 0.0.1

package/dist/audiences.mjs

@@ -0,0 +1,205 @@
+import { createSegmentClient } from "./client.mjs";
+import { a as segmentLooseObjectSchema, n as segmentIdSchema } from "./common-CdGiJbjq.mjs";
+import { t as segmentOperation } from "./factory-CvfKfzMq.mjs";
+import { z } from "zod";
+
+//#region src/audiences.ts
+/**
+* segment/audiences.ts — Engage audiences (space-scoped). 8 actions total
+* (PLAN.md § 6.7).
+*/
+const audienceSchema = segmentLooseObjectSchema({
+	id: segmentIdSchema,
+	key: z.string().optional(),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	definition: z.record(z.string(), z.unknown()).optional(),
+	enabled: z.boolean().optional()
+});
+const membershipSchema = segmentLooseObjectSchema({
+	profileId: z.string().optional(),
+	isMember: z.boolean().optional(),
+	enteredAt: z.string().optional(),
+	exitedAt: z.string().optional()
+});
+const memberSchema = segmentLooseObjectSchema({
+	profileId: z.string(),
+	traits: z.record(z.string(), z.unknown()).optional(),
+	enteredAt: z.string().optional()
+});
+const previewResultSchema = segmentLooseObjectSchema({
+	count: z.number().optional(),
+	sample: z.array(z.record(z.string(), z.unknown())).optional()
+});
+const listAudiences = segmentOperation({
+	id: "segment.audiences.list",
+	name: "List audiences",
+	description: "List audiences defined in an Engage space.",
+	input: z.object({
+		spaceId: segmentIdSchema,
+		pageSize: z.number().int().positive().max(200).optional(),
+		pageToken: z.string().optional()
+	}),
+	output: z.object({
+		items: z.array(audienceSchema),
+		nextPageToken: z.string().optional()
+	}),
+	run: async (input, credentials) => {
+		const result = await createSegmentClient(credentials).publicApi.list(`/spaces/${encodeURIComponent(input.spaceId)}/audiences`, {
+			itemsKey: "audiences",
+			items: audienceSchema
+		}, { query: {
+			count: input.pageSize,
+			cursor: input.pageToken
+		} });
+		return {
+			items: [...result.items],
+			...result.nextPageToken !== void 0 ? { nextPageToken: result.nextPageToken } : {}
+		};
+	}
+});
+const getAudience = segmentOperation({
+	id: "segment.audiences.get",
+	name: "Get audience",
+	description: "Fetch an audience in an Engage space.",
+	input: z.object({
+		spaceId: segmentIdSchema,
+		id: segmentIdSchema
+	}),
+	output: audienceSchema,
+	run: async (input, credentials) => {
+		const body = await createSegmentClient(credentials).publicApi.request(`/spaces/${encodeURIComponent(input.spaceId)}/audiences/${encodeURIComponent(input.id)}`);
+		const rec = body;
+		return audienceSchema.parse(rec.data?.audience ?? body);
+	}
+});
+const createAudience = segmentOperation({
+	id: "segment.audiences.create",
+	name: "Create audience",
+	description: "Create a new audience.",
+	input: z.object({
+		spaceId: segmentIdSchema,
+		name: z.string().min(1),
+		description: z.string().optional(),
+		definition: z.record(z.string(), z.unknown()),
+		enabled: z.boolean().optional()
+	}),
+	output: audienceSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { spaceId, ...body } = input;
+		const response = await client.publicApi.request(`/spaces/${encodeURIComponent(spaceId)}/audiences`, {
+			method: "POST",
+			body
+		});
+		const rec = response;
+		return audienceSchema.parse(rec.data?.audience ?? response);
+	}
+});
+const updateAudience = segmentOperation({
+	id: "segment.audiences.update",
+	name: "Update audience",
+	description: "Patch an audience definition.",
+	input: z.object({
+		spaceId: segmentIdSchema,
+		id: segmentIdSchema,
+		name: z.string().optional(),
+		description: z.string().optional(),
+		definition: z.record(z.string(), z.unknown()).optional(),
+		enabled: z.boolean().optional()
+	}),
+	output: audienceSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { spaceId, id, ...body } = input;
+		const response = await client.publicApi.request(`/spaces/${encodeURIComponent(spaceId)}/audiences/${encodeURIComponent(id)}`, {
+			method: "PATCH",
+			body
+		});
+		const rec = response;
+		return audienceSchema.parse(rec.data?.audience ?? response);
+	}
+});
+const deleteAudience = segmentOperation({
+	id: "segment.audiences.delete",
+	name: "Delete audience",
+	description: "Delete an audience.",
+	input: z.object({
+		spaceId: segmentIdSchema,
+		id: segmentIdSchema
+	}),
+	output: z.object({ deleted: z.literal(true) }),
+	needsApproval: true,
+	run: async (input, credentials) => {
+		await createSegmentClient(credentials).publicApi.request(`/spaces/${encodeURIComponent(input.spaceId)}/audiences/${encodeURIComponent(input.id)}`, { method: "DELETE" });
+		return { deleted: true };
+	}
+});
+const previewAudience = segmentOperation({
+	id: "segment.audiences.preview",
+	name: "Preview audience",
+	description: "Run a preview compute over an audience definition without saving.",
+	input: z.object({
+		spaceId: segmentIdSchema,
+		definition: z.record(z.string(), z.unknown())
+	}),
+	output: previewResultSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const body = await createSegmentClient(credentials).publicApi.request(`/spaces/${encodeURIComponent(input.spaceId)}/audiences/previews`, {
+			method: "POST",
+			body: { definition: input.definition }
+		});
+		const rec = body;
+		return previewResultSchema.parse(rec.data?.preview ?? body);
+	}
+});
+const getAudienceMembership = segmentOperation({
+	id: "segment.audiences.getMembership",
+	name: "Get audience membership",
+	description: "Check whether a specific profile is a member of an audience.",
+	input: z.object({
+		spaceId: segmentIdSchema,
+		id: segmentIdSchema,
+		profileId: segmentIdSchema
+	}),
+	output: membershipSchema,
+	run: async (input, credentials) => {
+		const body = await createSegmentClient(credentials).publicApi.request(`/spaces/${encodeURIComponent(input.spaceId)}/audiences/${encodeURIComponent(input.id)}/membership/${encodeURIComponent(input.profileId)}`);
+		const rec = body;
+		return membershipSchema.parse(rec.data ?? body);
+	}
+});
+const listAudienceMembers = segmentOperation({
+	id: "segment.audiences.listMembers",
+	name: "List audience members",
+	description: "List the profiles currently in an audience.",
+	input: z.object({
+		spaceId: segmentIdSchema,
+		id: segmentIdSchema,
+		pageSize: z.number().int().positive().max(200).optional(),
+		pageToken: z.string().optional()
+	}),
+	output: z.object({
+		items: z.array(memberSchema),
+		nextPageToken: z.string().optional()
+	}),
+	run: async (input, credentials) => {
+		const result = await createSegmentClient(credentials).publicApi.list(`/spaces/${encodeURIComponent(input.spaceId)}/audiences/${encodeURIComponent(input.id)}/members`, {
+			itemsKey: "members",
+			items: memberSchema
+		}, { query: {
+			count: input.pageSize,
+			cursor: input.pageToken
+		} });
+		return {
+			items: [...result.items],
+			...result.nextPageToken !== void 0 ? { nextPageToken: result.nextPageToken } : {}
+		};
+	}
+});
+
+//#endregion
+export { audienceSchema, createAudience, deleteAudience, getAudience, getAudienceMembership, listAudienceMembers, listAudiences, previewAudience, updateAudience };

package/dist/client.d.mts

@@ -0,0 +1,90 @@
+import { n as SegmentRegion, t as SegmentCredentials } from "./integration-D2yRaKFR.mjs";
+import { z } from "zod";
+
+//#region src/client.d.ts
+declare const PUBLIC_API_HOSTS: Readonly<Record<SegmentRegion, string>>;
+declare const TRACKING_API_HOSTS: Readonly<Record<SegmentRegion, string>>;
+declare const PROFILE_API_HOST = "https://profiles.segment.com/v1";
+/** Segment-enforced hard limit for a single event body (Track/Identify/…). */
+declare const MAX_EVENT_BYTES: number;
+/** Segment-enforced hard limit for a `/v1/batch` envelope. */
+declare const MAX_BATCH_BYTES: number;
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+interface CreateSegmentClientOptions {
+  /** Override the global `fetch` (for tests, custom timeouts, etc.). */
+  readonly fetch?: FetchLike;
+  /** Maximum number of retries on 429/5xx. Defaults to 3. */
+  readonly maxRetries?: number;
+  /** Maximum overall backoff between retries in ms. Defaults to 10_000. */
+  readonly maxBackoffMs?: number;
+  /** Sleep function (override for tests). */
+  readonly sleep?: (ms: number) => Promise<void>;
+}
+type QueryPrimitive = string | number | boolean;
+type QueryValue = QueryPrimitive | readonly QueryPrimitive[] | undefined;
+interface PublicRequestOptions {
+  readonly method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+  readonly query?: Readonly<Record<string, QueryValue>>;
+  readonly body?: unknown;
+  readonly timeoutMs?: number;
+}
+interface ListOptions<TOut> {
+  readonly itemsKey: string;
+  readonly items: z.ZodType<TOut>;
+}
+interface ListResult<T> {
+  readonly items: readonly T[];
+  readonly nextPageToken?: string;
+  readonly totalEntries?: number;
+}
+interface BatchSplitChunk<T> {
+  readonly events: readonly T[];
+  readonly bytes: number;
+}
+interface BatchSplitResult<T> {
+  readonly chunks: readonly BatchSplitChunk<T>[];
+  readonly rejected: readonly {
+    readonly event: T;
+    readonly bytes: number;
+  }[];
+}
+declare function splitBatch<T>(events: readonly T[], options?: {
+  readonly maxBatchBytes?: number;
+  readonly maxEventBytes?: number;
+}): BatchSplitResult<T>;
+interface PublicApiClient {
+  readonly baseUrl: string;
+  readonly request: <T>(path: string, options?: PublicRequestOptions) => Promise<T>;
+  readonly list: <T>(path: string, listOpts: ListOptions<T>, requestOpts?: PublicRequestOptions) => Promise<ListResult<T>>;
+}
+interface TrackingApiClient {
+  readonly baseUrl: string;
+  /** Send a single tracking event. `method` defaults to the endpoint path
+   * (e.g. `identify`, `track`). `sourceId` selects which write key to use. */
+  readonly send: (method: TrackingMethod, payload: Record<string, unknown>, options?: {
+    readonly sourceId?: string;
+  }) => Promise<void>;
+  readonly batch: (events: readonly Record<string, unknown>[], options?: {
+    readonly sourceId?: string;
+  }) => Promise<{
+    readonly chunksSent: number;
+    readonly rejected: readonly Record<string, unknown>[];
+  }>;
+}
+interface ProfileApiClient {
+  readonly baseUrl: string;
+  readonly request: <T>(path: string, options?: PublicRequestOptions & {
+    readonly spaceId?: string;
+  }) => Promise<T>;
+}
+type TrackingMethod = 'identify' | 'track' | 'page' | 'screen' | 'group' | 'alias' | 'batch';
+interface SegmentClient {
+  readonly credentials: SegmentCredentials;
+  readonly region: SegmentRegion;
+  readonly publicApi: PublicApiClient;
+  readonly tracking: TrackingApiClient;
+  readonly profiles: ProfileApiClient;
+}
+declare function createSegmentClient(credentials: SegmentCredentials, options?: CreateSegmentClientOptions): SegmentClient;
+//#endregion
+export { BatchSplitChunk, BatchSplitResult, CreateSegmentClientOptions, FetchLike, ListOptions, ListResult, MAX_BATCH_BYTES, MAX_EVENT_BYTES, PROFILE_API_HOST, PUBLIC_API_HOSTS, ProfileApiClient, PublicApiClient, PublicRequestOptions, SegmentClient, TRACKING_API_HOSTS, TrackingApiClient, TrackingMethod, createSegmentClient, splitBatch };

package/dist/client.mjs

@@ -0,0 +1,337 @@
+import { t as SegmentApiError } from "./errors-4FGnrowW.mjs";
+import { z } from "zod";
+
+//#region src/client.ts
+/**
+* segment/client.ts
+*
+* Typed `fetch`-based client for all three Segment authentication surfaces:
+*
+*   - **Public API** (`api.segmentapis.com` US / `eu1.api.segmentapis.com`
+*     EU) — workspace-scoped Bearer token. Cursor pagination, retry on 429
+*     (respects `Retry-After`) and 5xx.
+*   - **Tracking API** (`api.segment.io` US / `events.eu1.segmentapis.com`
+*     EU) — HTTP Basic with per-source write key as username; no password.
+*     Enforces 500 KB per batch and 32 KB per event client-side and exposes a
+*     `splitBatch` helper for chunking.
+*   - **Profile API** (`profiles.segment.com`) — HTTP Basic with per-space
+*     access token as username.
+*
+* The official `@segment/public-api-sdk-typescript` package was considered and
+* rejected (see `IMPLEMENTATION_NOTES.md` § 3): it depends on the deprecated
+* `request` library and `bluebird`, neither of which is ESM-friendly or
+* usable in Cloudflare Workers / V8 isolates (our executor tier).
+*/
+const PUBLIC_API_HOSTS = {
+	us: "https://api.segmentapis.com",
+	eu: "https://eu1.api.segmentapis.com"
+};
+const TRACKING_API_HOSTS = {
+	us: "https://api.segment.io/v1",
+	eu: "https://events.eu1.segmentapis.com/v1"
+};
+const PROFILE_API_HOST = "https://profiles.segment.com/v1";
+/** Segment-enforced hard limit for a single event body (Track/Identify/…). */
+const MAX_EVENT_BYTES = 32 * 1024;
+/** Segment-enforced hard limit for a `/v1/batch` envelope. */
+const MAX_BATCH_BYTES = 500 * 1024;
+function splitBatch(events, options) {
+	const maxBatch = options?.maxBatchBytes ?? MAX_BATCH_BYTES;
+	const maxEvent = options?.maxEventBytes ?? MAX_EVENT_BYTES;
+	const chunks = [];
+	const rejected = [];
+	let current = [];
+	let currentBytes = envelopeBytes(0);
+	for (const event of events) {
+		const bytes = jsonByteLength(event);
+		if (bytes > maxEvent) {
+			rejected.push({
+				event,
+				bytes
+			});
+			continue;
+		}
+		const addition = bytes + 1;
+		if (currentBytes + addition > maxBatch && current.length > 0) {
+			chunks.push({
+				events: current,
+				bytes: currentBytes
+			});
+			current = [];
+			currentBytes = envelopeBytes(0);
+		}
+		current.push(event);
+		currentBytes += addition;
+	}
+	if (current.length > 0) chunks.push({
+		events: current,
+		bytes: currentBytes
+	});
+	return {
+		chunks,
+		rejected
+	};
+}
+function envelopeBytes(eventsBytes) {
+	return 12 + eventsBytes;
+}
+function jsonByteLength(value) {
+	return new TextEncoder().encode(JSON.stringify(value ?? null)).length;
+}
+const writeKeyMapSchema = z.record(z.string().min(1), z.string().min(1));
+function resolveWriteKey(credentials, context) {
+	const map = parseWriteKeyMap(credentials.SEGMENT_WRITE_KEYS_JSON);
+	if (context.sourceId && map?.[context.sourceId]) return map[context.sourceId];
+	const fallback = credentials.SEGMENT_DEFAULT_WRITE_KEY;
+	if (fallback) return fallback;
+	throw new SegmentApiError({
+		kind: "missing_credential",
+		message: context.sourceId ? `No Segment write key is configured for source "${context.sourceId}". Provide it in SEGMENT_WRITE_KEYS_JSON or set SEGMENT_DEFAULT_WRITE_KEY.` : "No Segment write key is configured. Pass a sourceId resolvable from SEGMENT_WRITE_KEYS_JSON, or set SEGMENT_DEFAULT_WRITE_KEY."
+	});
+}
+function parseWriteKeyMap(raw) {
+	if (!raw) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (cause) {
+		throw new SegmentApiError({
+			kind: "validation",
+			message: "SEGMENT_WRITE_KEYS_JSON is not valid JSON.",
+			cause
+		});
+	}
+	const result = writeKeyMapSchema.safeParse(parsed);
+	if (!result.success) throw new SegmentApiError({
+		kind: "validation",
+		message: "SEGMENT_WRITE_KEYS_JSON must be a JSON object of { sourceId: writeKey }.",
+		cause: result.error
+	});
+	return result.data;
+}
+async function runRequest(opts, runtime) {
+	const url = new URL(`${opts.baseUrl}${opts.path}`);
+	if (opts.query) appendQuery(url, opts.query);
+	const init = {
+		method: opts.method ?? "GET",
+		headers: {
+			Authorization: opts.authHeader,
+			Accept: opts.acceptHeader ?? "application/json",
+			...opts.body !== void 0 ? { "Content-Type": opts.contentType ?? "application/json" } : {}
+		},
+		...opts.body !== void 0 ? { body: JSON.stringify(opts.body) } : {}
+	};
+	for (let attempt = 0;; attempt += 1) {
+		let response;
+		try {
+			response = await runtime.fetch(url, init);
+		} catch (cause) {
+			if (attempt < runtime.maxRetries) {
+				await runtime.sleep(computeBackoff(attempt, runtime.maxBackoffMs));
+				continue;
+			}
+			throw new SegmentApiError({
+				kind: "network",
+				message: `Segment request failed (${opts.method ?? "GET"} ${opts.path}): ${stringifyError(cause)}`,
+				cause
+			});
+		}
+		if (response.status === 204) return;
+		const body = (response.headers.get("content-type") ?? "").includes("application/json") ? await response.json().catch(() => void 0) : await response.text().catch(() => "");
+		if (response.ok) return body;
+		if (response.status === 429 && attempt < runtime.maxRetries) {
+			const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+			await runtime.sleep(retryAfter ?? computeBackoff(attempt, runtime.maxBackoffMs));
+			continue;
+		}
+		if (response.status >= 500 && response.status < 600 && attempt < runtime.maxRetries) {
+			await runtime.sleep(computeBackoff(attempt, runtime.maxBackoffMs));
+			continue;
+		}
+		throw toSegmentError(response, body, opts);
+	}
+}
+function toSegmentError(response, body, opts) {
+	const kind = response.status === 401 || response.status === 403 ? "auth" : response.status === 413 ? "batch_too_large" : response.status === 429 ? "rate_limit" : "http";
+	const message = extractMessage(body) ?? `${opts.method ?? "GET"} ${opts.path} -> ${response.status}`;
+	const code = extractCode(body);
+	const requestId = response.headers.get("x-request-id") ?? void 0;
+	return new SegmentApiError({
+		kind,
+		status: response.status,
+		code,
+		requestId,
+		body,
+		message: `Segment API ${opts.method ?? "GET"} ${opts.path} failed (${response.status}): ${message}`
+	});
+}
+function extractMessage(body) {
+	if (!body || typeof body !== "object") return typeof body === "string" ? body : void 0;
+	const record = body;
+	if (typeof record.message === "string") return record.message;
+	if (typeof record.error === "string") return record.error;
+}
+function extractCode(body) {
+	if (!body || typeof body !== "object") return void 0;
+	const record = body;
+	if (typeof record.code === "string") return record.code;
+	if (typeof record.errorCode === "string") return record.errorCode;
+}
+function parseRetryAfter(value) {
+	if (!value) return void 0;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+	const dateMs = Date.parse(value);
+	if (!Number.isNaN(dateMs)) {
+		const delta = dateMs - Date.now();
+		return delta > 0 ? delta : 0;
+	}
+}
+function computeBackoff(attempt, maxBackoffMs) {
+	const base = Math.min(maxBackoffMs, 500 * 2 ** attempt);
+	const jitter = Math.random() * base * .25;
+	return Math.floor(base + jitter);
+}
+function stringifyError(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+function appendQuery(url, query) {
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) {
+			for (const entry of value) url.searchParams.append(key, String(entry));
+			continue;
+		}
+		url.searchParams.set(key, String(value));
+	}
+}
+function basicAuthHeader(usernameWithNoPassword) {
+	return `Basic ${typeof globalThis.btoa === "function" ? globalThis.btoa(`${usernameWithNoPassword}:`) : Buffer.from(`${usernameWithNoPassword}:`, "utf8").toString("base64")}`;
+}
+function createSegmentClient(credentials, options = {}) {
+	const region = credentials.SEGMENT_REGION ?? "us";
+	const runtime = {
+		fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
+		maxRetries: options.maxRetries ?? 3,
+		maxBackoffMs: options.maxBackoffMs ?? 1e4,
+		sleep: options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)))
+	};
+	const publicBase = PUBLIC_API_HOSTS[region];
+	const trackingBase = TRACKING_API_HOSTS[region];
+	const bearer = `Bearer ${credentials.SEGMENT_PUBLIC_API_TOKEN}`;
+	return {
+		credentials,
+		region,
+		publicApi: {
+			baseUrl: publicBase,
+			request: (path, opts = {}) => runRequest({
+				...opts,
+				baseUrl: publicBase,
+				path,
+				authHeader: bearer,
+				acceptHeader: "application/vnd.segment.v1+json"
+			}, runtime),
+			list: async (path, listOpts, requestOpts = {}) => {
+				return parseListResult(await runRequest({
+					...requestOpts,
+					baseUrl: publicBase,
+					path,
+					authHeader: bearer,
+					acceptHeader: "application/vnd.segment.v1+json"
+				}, runtime), listOpts);
+			}
+		},
+		tracking: {
+			baseUrl: trackingBase,
+			send: async (method, payload, opts = {}) => {
+				if (method === "batch") throw new SegmentApiError({
+					kind: "validation",
+					message: "Use client.tracking.batch(...) for batched events, not send(\"batch\", ...)."
+				});
+				const writeKey = resolveWriteKey(credentials, { sourceId: opts.sourceId });
+				const bytes = jsonByteLength(payload);
+				if (bytes > MAX_EVENT_BYTES) throw new SegmentApiError({
+					kind: "event_too_large",
+					message: `Segment tracking event is ${bytes} bytes; limit is ${MAX_EVENT_BYTES} bytes per request.`
+				});
+				await runRequest({
+					baseUrl: trackingBase,
+					path: `/${method}`,
+					method: "POST",
+					body: payload,
+					authHeader: basicAuthHeader(writeKey)
+				}, runtime);
+			},
+			batch: async (events, opts = {}) => {
+				const writeKey = resolveWriteKey(credentials, { sourceId: opts.sourceId });
+				const { chunks, rejected } = splitBatch(events);
+				for (const chunk of chunks) await runRequest({
+					baseUrl: trackingBase,
+					path: "/batch",
+					method: "POST",
+					body: { batch: chunk.events },
+					authHeader: basicAuthHeader(writeKey)
+				}, runtime);
+				return {
+					chunksSent: chunks.length,
+					rejected: rejected.map((r) => r.event)
+				};
+			}
+		},
+		profiles: {
+			baseUrl: PROFILE_API_HOST,
+			request: async (path, opts = {}) => {
+				const token = credentials.SEGMENT_PROFILE_API_TOKEN;
+				if (!token) throw new SegmentApiError({
+					kind: "missing_credential",
+					message: "Profile API access requires SEGMENT_PROFILE_API_TOKEN. Generate a per-space access token in Segment Engage settings and add it to the Keystroke connection."
+				});
+				const spaceId = opts.spaceId ?? credentials.SEGMENT_PROFILE_SPACE_ID;
+				if (!spaceId) throw new SegmentApiError({
+					kind: "missing_credential",
+					message: "Profile API calls require a spaceId — pass one as input, or set SEGMENT_PROFILE_SPACE_ID on the connection."
+				});
+				return runRequest({
+					...opts,
+					baseUrl: PROFILE_API_HOST,
+					path: path.replace("{spaceId}", encodeURIComponent(spaceId)),
+					authHeader: basicAuthHeader(token)
+				}, runtime);
+			}
+		}
+	};
+}
+function parseListResult(raw, opts) {
+	const body = unwrapListBody(raw);
+	const container = body.data ?? body;
+	const items = extractItems(container, opts.itemsKey).map((entry) => opts.items.parse(entry));
+	const pagination = extractPagination(container);
+	return {
+		items,
+		...pagination.next !== void 0 ? { nextPageToken: pagination.next } : {},
+		...pagination.totalEntries !== void 0 ? { totalEntries: pagination.totalEntries } : {}
+	};
+}
+function unwrapListBody(raw) {
+	if (!raw || typeof raw !== "object") return {};
+	return raw;
+}
+function extractItems(container, key) {
+	const value = container[key];
+	return Array.isArray(value) ? value : [];
+}
+function extractPagination(container) {
+	const pagination = container.pagination;
+	if (!pagination || typeof pagination !== "object") return {};
+	const record = pagination;
+	const next = typeof record.next === "string" ? record.next : void 0;
+	const totalEntries = typeof record.totalEntries === "number" ? record.totalEntries : void 0;
+	return {
+		...next !== void 0 ? { next } : {},
+		...totalEntries !== void 0 ? { totalEntries } : {}
+	};
+}
+
+//#endregion
+export { MAX_BATCH_BYTES, MAX_EVENT_BYTES, PROFILE_API_HOST, PUBLIC_API_HOSTS, TRACKING_API_HOSTS, createSegmentClient, splitBatch };

package/dist/common-CdGiJbjq.mjs

@@ -0,0 +1,56 @@
+import { z } from "zod";
+
+//#region src/schemas/common.ts
+/**
+* segment/schemas/common.ts
+*
+* Zod v4 primitives shared across every Segment domain. Each domain file
+* defines its own resource-shape schemas inline (AUTHORING.md § "inline
+* single-use schemas") and reuses these primitives.
+*/
+/** Non-empty trimmed string. */
+const segmentIdSchema = z.string().trim().min(1);
+/** ISO-8601 timestamp as emitted by Segment. Accept either a real ISO-8601
+* datetime or any non-empty string (Segment occasionally returns
+* human-readable dates for some `finishedAt` fields). */
+const segmentTimestampSchema = z.union([z.iso.datetime({ offset: true }), segmentIdSchema]);
+/** Forward-only cursor token the Public API returns on list endpoints under
+* `pagination.next`. */
+const segmentCursorSchema = z.string().min(1);
+/** A permissively-typed object. Used for provider fields we pass through
+* untouched (e.g. destination settings blobs whose shape depends on which
+* destination is configured). Parsed so we never leak unknown values into
+* typed outputs, but we accept any keys. */
+function segmentLooseObjectSchema(shape = {}) {
+	return z.object(shape).catchall(z.unknown());
+}
+/** Segment Public API pagination envelope. */
+const segmentPaginationSchema = z.object({
+	current: segmentCursorSchema.optional(),
+	next: segmentCursorSchema.optional(),
+	previous: segmentCursorSchema.optional(),
+	totalEntries: z.number().int().nonnegative().optional()
+}).partial();
+/** Common pagination input fields accepted by every list op. */
+const segmentPaginationInputSchema = z.object({
+	pageSize: z.number().int().positive().max(200).optional(),
+	pageToken: segmentCursorSchema.optional()
+});
+/** Segment label — `key:value`. */
+const segmentLabelSchema = z.object({
+	key: segmentIdSchema,
+	value: segmentIdSchema,
+	description: z.string().optional()
+});
+/** Envelope for a Public API list response. The actual payload key is the
+* resource name (`sources`, `destinations`, …); callers wrap with the
+* resource-specific schema. */
+function segmentListEnvelopeSchema(itemsKey, item) {
+	return segmentLooseObjectSchema({
+		[itemsKey]: z.array(item),
+		pagination: segmentPaginationSchema.optional()
+	});
+}
+
+//#endregion
+export { segmentLooseObjectSchema as a, segmentTimestampSchema as c, segmentListEnvelopeSchema as i, segmentIdSchema as n, segmentPaginationInputSchema as o, segmentLabelSchema as r, segmentPaginationSchema as s, segmentCursorSchema as t };