@uengage.io/platform-sdk 0.14.0 → 1.0.0

package/dist/events/client.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventsClient = createEventsClient;
+const client_sns_1 = require("@aws-sdk/client-sns");
+const ulid_1 = require("ulid");
+const errors_1 = require("../errors");
+const schema_1 = require("./schema");
+/** SNS caps PublishBatch at 10 entries per call. */
+const SNS_BATCH_MAX = 10;
+/**
+ * SNS caps a single message at 256 KB, and a whole PublishBatch request
+ * at the same 256 KB across all its entries.
+ */
+const SNS_MAX_BYTES = 262_144;
+/**
+ * Headroom left for the `type` / `domain` / `source` message attributes,
+ * which count toward the limit alongside the body. A few hundred bytes
+ * covers them; being conservative here costs nothing, since an envelope
+ * anywhere near the cap is a call-site mistake either way.
+ */
+const ATTRIBUTE_ALLOWANCE_BYTES = 1_024;
+const MAX_MESSAGE_BYTES = SNS_MAX_BYTES - ATTRIBUTE_ALLOWANCE_BYTES;
+/**
+ * Byte length of a UTF-8 string. `TextEncoder` rather than
+ * `Buffer.byteLength` so this file carries no Node built-in.
+ */
+const encoder = new TextEncoder();
+function byteLength(value) {
+    return encoder.encode(value).length;
+}
+/**
+ * Monotonic within this process: two events minted in the same
+ * millisecond still sort in emission order. Downstream consumers use the
+ * envelope `id` as the ordering and dedupe key, so this is load-bearing,
+ * not a nicety.
+ */
+const nextUlid = (0, ulid_1.monotonicFactory)();
+/**
+ * Build an isolated events client. Reads `PLATFORM_EVENTS_TOPIC_ARN` and
+ * friends from the environment for anything not passed explicitly, so a
+ * Lambda whose deploy stack injected the ARN needs no arguments.
+ */
+function createEventsClient(input = {}) {
+    let client = input.snsClient;
+    function topicArn() {
+        const arn = input.topicArn ?? env('PLATFORM_EVENTS_TOPIC_ARN');
+        if (!arn) {
+            throw new errors_1.ConfigError('events.publish: no topic ARN. Pass {topicArn} to createEventsClient or set PLATFORM_EVENTS_TOPIC_ARN.');
+        }
+        return arn;
+    }
+    function sns() {
+        if (!client) {
+            const region = input.region ?? regionFromArn(topicArn()) ?? env('AWS_REGION') ?? env('AWS_DEFAULT_REGION');
+            client = new client_sns_1.SNSClient(region ? { region } : {});
+        }
+        return client;
+    }
+    function source(override) {
+        return (override ??
+            input.source ??
+            env('PLATFORM_EVENTS_SOURCE') ??
+            env('SERVICE_NAME') ??
+            'platform-sdk');
+    }
+    function buildEnvelope(type, data, opts) {
+        const domain = (0, schema_1.domainForEventType)(type);
+        if (!domain) {
+            throw new errors_1.ValidationError(`events.publish: cannot route event type "${type}". It must be a dotted ` +
+                '"<resource>.<operation>" name whose resource maps to a known bus domain ' +
+                '(order, customer, menu, offer, loyalty, usage). Adding a domain is a one-line ' +
+                'edit in events/schema.ts and its two mirrors.');
+        }
+        const candidate = {
+            id: nextUlid(),
+            type,
+            domain,
+            source: source(opts.source),
+            version: schema_1.PLATFORM_EVENT_VERSION,
+            occurredAt: opts.occurredAt ?? isoNow(),
+            tenantId: opts.tenantId,
+            data,
+        };
+        const result = schema_1.platformEventSchema.safeParse(candidate);
+        if (!result.success) {
+            throw new errors_1.ValidationError(`events.publish: invalid envelope for "${type}"`, {
+                issues: result.error.issues,
+            });
+        }
+        return result.data;
+    }
+    /**
+     * Serialize and size-check one envelope.
+     *
+     * Checked before the publish rather than after the rejection because
+     * SNS's own error for an oversized message names neither the event nor
+     * the offending field, and on the PHP side the same failure disappears
+     * into `error_log`. Better to say which event and how big.
+     */
+    function serialize(event) {
+        const message = JSON.stringify(event);
+        const size = byteLength(message);
+        if (size > MAX_MESSAGE_BYTES) {
+            throw new errors_1.ValidationError(`events.publish: event ${event.id} ("${event.type}") serializes to ${size} bytes, ` +
+                `over the ${MAX_MESSAGE_BYTES}-byte ceiling (SNS caps a message at 256KB including ` +
+                'attributes). Put the payload somewhere addressable and reference it from `data`.');
+        }
+        return message;
+    }
+    return {
+        async publish(type, data, opts) {
+            const event = buildEnvelope(type, data, opts);
+            const message = serialize(event);
+            const arn = topicArn();
+            try {
+                await sns().send(new client_sns_1.PublishCommand({
+                    TopicArn: arn,
+                    Message: message,
+                    MessageAttributes: messageAttributes(event),
+                }));
+            }
+            catch (err) {
+                throw new errors_1.EventPublishError(`events.publish: SNS publish failed for "${type}"`, {
+                    failedEventIds: [event.id],
+                    cause: err,
+                });
+            }
+            return event;
+        },
+        async publishBatch(events) {
+            if (events.length === 0)
+                return [];
+            const envelopes = events.map((e) => buildEnvelope(e.type, e.data, e));
+            // Serialize (and size-check) everything up front, so an oversized
+            // event fails the call before any of its siblings are published.
+            const messages = new Map(envelopes.map((event) => [event.id, serialize(event)]));
+            const arn = topicArn();
+            const failed = [];
+            let firstError;
+            for (const group of chunkByBytes(envelopes, messages)) {
+                const entries = group.map((event) => ({
+                    Id: event.id,
+                    Message: messages.get(event.id),
+                    MessageAttributes: messageAttributes(event),
+                }));
+                try {
+                    const resp = await sns().send(new client_sns_1.PublishBatchCommand({ TopicArn: arn, PublishBatchRequestEntries: entries }));
+                    for (const f of resp.Failed ?? []) {
+                        if (f.Id)
+                            failed.push(f.Id);
+                    }
+                }
+                catch (err) {
+                    firstError = firstError ?? err;
+                    for (const event of group)
+                        failed.push(event.id);
+                }
+            }
+            if (failed.length > 0) {
+                throw new errors_1.EventPublishError(`events.publishBatch: ${failed.length}/${envelopes.length} event(s) did not reach the bus`, { failedEventIds: failed, cause: firstError });
+            }
+            return envelopes;
+        },
+    };
+}
+function messageAttributes(event) {
+    return {
+        type: { DataType: 'String', StringValue: event.type },
+        domain: { DataType: 'String', StringValue: event.domain },
+        source: { DataType: 'String', StringValue: event.source },
+    };
+}
+/** `arn:aws:sns:<region>:<account>:<name>` → `<region>`. */
+function regionFromArn(arn) {
+    const parts = arn.split(':');
+    return parts.length >= 4 && parts[3] ? parts[3] : undefined;
+}
+/** UTC ISO 8601, seconds precision — the format the envelope schema pins. */
+function isoNow() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+function env(name) {
+    if (typeof process === 'undefined')
+        return undefined;
+    const value = process.env?.[name];
+    return value === '' ? undefined : value;
+}
+/**
+ * Group envelopes into PublishBatch calls bounded by BOTH limits: at most
+ * 10 entries, and at most 256 KB of combined payload.
+ *
+ * The byte bound matters as soon as payloads get rich — ten 30 KB
+ * envelopes are each individually legal and collectively over the
+ * request cap, and SNS rejects the whole call rather than the overflow.
+ */
+function chunkByBytes(envelopes, messages) {
+    const out = [];
+    let current = [];
+    let currentBytes = 0;
+    for (const event of envelopes) {
+        const size = byteLength(messages.get(event.id)) + ATTRIBUTE_ALLOWANCE_BYTES;
+        const full = current.length >= SNS_BATCH_MAX;
+        const wouldOverflow = current.length > 0 && currentBytes + size > SNS_MAX_BYTES;
+        if (full || wouldOverflow) {
+            out.push(current);
+            current = [];
+            currentBytes = 0;
+        }
+        current.push(event);
+        currentBytes += size;
+    }
+    if (current.length > 0)
+        out.push(current);
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/events/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  SNSClient,\n  PublishCommand,\n  PublishBatchCommand,\n  type PublishBatchRequestEntry,\n  type MessageAttributeValue,\n} from '@aws-sdk/client-sns';\nimport { monotonicFactory } from 'ulid';\nimport { ConfigError, EventPublishError, ValidationError } from '../errors';\nimport {\n  domainForEventType,\n  platformEventSchema,\n  PLATFORM_EVENT_VERSION,\n  type PlatformEvent,\n} from './schema';\n\n/** SNS caps PublishBatch at 10 entries per call. */\nconst SNS_BATCH_MAX = 10;\n\n/**\n * SNS caps a single message at 256 KB, and a whole PublishBatch request\n * at the same 256 KB across all its entries.\n */\nconst SNS_MAX_BYTES = 262_144;\n\n/**\n * Headroom left for the `type` / `domain` / `source` message attributes,\n * which count toward the limit alongside the body. A few hundred bytes\n * covers them; being conservative here costs nothing, since an envelope\n * anywhere near the cap is a call-site mistake either way.\n */\nconst ATTRIBUTE_ALLOWANCE_BYTES = 1_024;\n\nconst MAX_MESSAGE_BYTES = SNS_MAX_BYTES - ATTRIBUTE_ALLOWANCE_BYTES;\n\n/**\n * Byte length of a UTF-8 string. `TextEncoder` rather than\n * `Buffer.byteLength` so this file carries no Node built-in.\n */\nconst encoder = new TextEncoder();\n\nfunction byteLength(value: string): number {\n  return encoder.encode(value).length;\n}\n\n/**\n * Monotonic within this process: two events minted in the same\n * millisecond still sort in emission order. Downstream consumers use the\n * envelope `id` as the ordering and dedupe key, so this is load-bearing,\n * not a nicety.\n */\nconst nextUlid = monotonicFactory();\n\n/** What a call site supplies; the SDK derives everything else. */\nexport interface PublishOptions {\n  /** uEngage business id the event belongs to. */\n  tenantId: string;\n  /**\n   * When the thing happened, if it wasn't now — e.g. replaying a\n   * transition read back off a DB row. UTC ISO 8601. Defaults to the\n   * moment `publish()` was called.\n   */\n  occurredAt?: string;\n  /** Overrides the client-level `source` for this one event. */\n  source?: string;\n}\n\nexport interface PublishBatchInput extends PublishOptions {\n  type: string;\n  data: Record<string, unknown>;\n}\n\nexport interface EventsClientInput {\n  /**\n   * Bus topic ARN. Defaults to `PLATFORM_EVENTS_TOPIC_ARN`.\n   */\n  topicArn?: string;\n  /**\n   * AWS region. Defaults to the region embedded in `topicArn`, then\n   * `AWS_REGION` / `AWS_DEFAULT_REGION`. Rarely needs setting.\n   */\n  region?: string;\n  /**\n   * Which system is emitting. Defaults to `PLATFORM_EVENTS_SOURCE`, then\n   * `SERVICE_NAME` (set on every platform Lambda by `LambdaService`),\n   * then `'platform-sdk'`.\n   */\n  source?: string;\n  /** Inject a pre-built SNS client (tests, custom credentials/retry config). */\n  snsClient?: SNSClient;\n}\n\nexport interface EventsClient {\n  /**\n   * Publish one event onto the platform event bus.\n   *\n   * Builds the envelope (monotonic ULID `id`, `occurredAt`, `version`,\n   * `domain` derived from the `type` prefix), validates it, and publishes\n   * with `type` / `domain` / `source` set as SNS message attributes so\n   * consumer filter policies match without deserialising the body.\n   *\n   * THROWS on failure — it does not fail open. Fail-open is the caller's\n   * call and it differs by call site: a legacy order-status transition\n   * must never be blocked by a bus outage (wrap in try/catch and log),\n   * whereas a service that needs the event delivered may want to retry.\n   * The PHP SDK's buffered client makes the fail-open choice explicitly\n   * for the legacy request path.\n   *\n   * @throws {ConfigError} no topic ARN configured\n   * @throws {ValidationError} the envelope failed schema validation\n   * @throws {EventPublishError} SNS rejected or errored on the publish\n   */\n  publish(\n    type: string,\n    data: Record<string, unknown>,\n    opts: PublishOptions,\n  ): Promise<PlatformEvent>;\n  /**\n   * Publish many events in one round trip, chunked at SNS's 10-per-call\n   * `PublishBatch` limit.\n   *\n   * All-or-nothing it is NOT: chunks are attempted independently, and a\n   * partial failure throws `EventPublishError` carrying the ids that did\n   * not land in `failedEventIds`. Envelope validation runs over the whole\n   * input first, so a malformed event fails the call before anything is\n   * published.\n   *\n   * @throws {ConfigError} no topic ARN configured\n   * @throws {ValidationError} any envelope failed schema validation\n   * @throws {EventPublishError} one or more events did not reach the bus\n   */\n  publishBatch(events: PublishBatchInput[]): Promise<PlatformEvent[]>;\n}\n\n/**\n * Build an isolated events client. Reads `PLATFORM_EVENTS_TOPIC_ARN` and\n * friends from the environment for anything not passed explicitly, so a\n * Lambda whose deploy stack injected the ARN needs no arguments.\n */\nexport function createEventsClient(input: EventsClientInput = {}): EventsClient {\n  let client: SNSClient | undefined = input.snsClient;\n\n  function topicArn(): string {\n    const arn = input.topicArn ?? env('PLATFORM_EVENTS_TOPIC_ARN');\n    if (!arn) {\n      throw new ConfigError(\n        'events.publish: no topic ARN. Pass {topicArn} to createEventsClient or set PLATFORM_EVENTS_TOPIC_ARN.',\n      );\n    }\n    return arn;\n  }\n\n  function sns(): SNSClient {\n    if (!client) {\n      const region =\n        input.region ?? regionFromArn(topicArn()) ?? env('AWS_REGION') ?? env('AWS_DEFAULT_REGION');\n      client = new SNSClient(region ? { region } : {});\n    }\n    return client;\n  }\n\n  function source(override?: string): string {\n    return (\n      override ??\n      input.source ??\n      env('PLATFORM_EVENTS_SOURCE') ??\n      env('SERVICE_NAME') ??\n      'platform-sdk'\n    );\n  }\n\n  function buildEnvelope(\n    type: string,\n    data: Record<string, unknown>,\n    opts: PublishOptions,\n  ): PlatformEvent {\n    const domain = domainForEventType(type);\n    if (!domain) {\n      throw new ValidationError(\n        `events.publish: cannot route event type \"${type}\". It must be a dotted ` +\n          '\"<resource>.<operation>\" name whose resource maps to a known bus domain ' +\n          '(order, customer, menu, offer, loyalty, usage). Adding a domain is a one-line ' +\n          'edit in events/schema.ts and its two mirrors.',\n      );\n    }\n    const candidate = {\n      id: nextUlid(),\n      type,\n      domain,\n      source: source(opts.source),\n      version: PLATFORM_EVENT_VERSION,\n      occurredAt: opts.occurredAt ?? isoNow(),\n      tenantId: opts.tenantId,\n      data,\n    };\n    const result = platformEventSchema.safeParse(candidate);\n    if (!result.success) {\n      throw new ValidationError(`events.publish: invalid envelope for \"${type}\"`, {\n        issues: result.error.issues,\n      });\n    }\n    return result.data;\n  }\n\n  /**\n   * Serialize and size-check one envelope.\n   *\n   * Checked before the publish rather than after the rejection because\n   * SNS's own error for an oversized message names neither the event nor\n   * the offending field, and on the PHP side the same failure disappears\n   * into `error_log`. Better to say which event and how big.\n   */\n  function serialize(event: PlatformEvent): string {\n    const message = JSON.stringify(event);\n    const size = byteLength(message);\n    if (size > MAX_MESSAGE_BYTES) {\n      throw new ValidationError(\n        `events.publish: event ${event.id} (\"${event.type}\") serializes to ${size} bytes, ` +\n          `over the ${MAX_MESSAGE_BYTES}-byte ceiling (SNS caps a message at 256KB including ` +\n          'attributes). Put the payload somewhere addressable and reference it from `data`.',\n      );\n    }\n    return message;\n  }\n\n  return {\n    async publish(type, data, opts) {\n      const event = buildEnvelope(type, data, opts);\n      const message = serialize(event);\n      const arn = topicArn();\n      try {\n        await sns().send(\n          new PublishCommand({\n            TopicArn: arn,\n            Message: message,\n            MessageAttributes: messageAttributes(event),\n          }),\n        );\n      } catch (err) {\n        throw new EventPublishError(`events.publish: SNS publish failed for \"${type}\"`, {\n          failedEventIds: [event.id],\n          cause: err,\n        });\n      }\n      return event;\n    },\n\n    async publishBatch(events) {\n      if (events.length === 0) return [];\n      const envelopes = events.map((e) => buildEnvelope(e.type, e.data, e));\n      // Serialize (and size-check) everything up front, so an oversized\n      // event fails the call before any of its siblings are published.\n      const messages = new Map(envelopes.map((event) => [event.id, serialize(event)]));\n      const arn = topicArn();\n\n      const failed: string[] = [];\n      let firstError: unknown;\n      for (const group of chunkByBytes(envelopes, messages)) {\n        const entries: PublishBatchRequestEntry[] = group.map((event) => ({\n          Id: event.id,\n          Message: messages.get(event.id) as string,\n          MessageAttributes: messageAttributes(event),\n        }));\n        try {\n          const resp = await sns().send(\n            new PublishBatchCommand({ TopicArn: arn, PublishBatchRequestEntries: entries }),\n          );\n          for (const f of resp.Failed ?? []) {\n            if (f.Id) failed.push(f.Id);\n          }\n        } catch (err) {\n          firstError = firstError ?? err;\n          for (const event of group) failed.push(event.id);\n        }\n      }\n\n      if (failed.length > 0) {\n        throw new EventPublishError(\n          `events.publishBatch: ${failed.length}/${envelopes.length} event(s) did not reach the bus`,\n          { failedEventIds: failed, cause: firstError },\n        );\n      }\n      return envelopes;\n    },\n  };\n}\n\nfunction messageAttributes(event: PlatformEvent): Record<string, MessageAttributeValue> {\n  return {\n    type: { DataType: 'String', StringValue: event.type },\n    domain: { DataType: 'String', StringValue: event.domain },\n    source: { DataType: 'String', StringValue: event.source },\n  };\n}\n\n/** `arn:aws:sns:<region>:<account>:<name>` → `<region>`. */\nfunction regionFromArn(arn: string): string | undefined {\n  const parts = arn.split(':');\n  return parts.length >= 4 && parts[3] ? parts[3] : undefined;\n}\n\n/** UTC ISO 8601, seconds precision — the format the envelope schema pins. */\nfunction isoNow(): string {\n  return new Date().toISOString().replace(/\\.\\d{3}Z$/, 'Z');\n}\n\nfunction env(name: string): string | undefined {\n  if (typeof process === 'undefined') return undefined;\n  const value = (process as { env?: Record<string, string | undefined> }).env?.[name];\n  return value === '' ? undefined : value;\n}\n\n/**\n * Group envelopes into PublishBatch calls bounded by BOTH limits: at most\n * 10 entries, and at most 256 KB of combined payload.\n *\n * The byte bound matters as soon as payloads get rich — ten 30 KB\n * envelopes are each individually legal and collectively over the\n * request cap, and SNS rejects the whole call rather than the overflow.\n */\nfunction chunkByBytes(\n  envelopes: PlatformEvent[],\n  messages: Map<string, string>,\n): PlatformEvent[][] {\n  const out: PlatformEvent[][] = [];\n  let current: PlatformEvent[] = [];\n  let currentBytes = 0;\n\n  for (const event of envelopes) {\n    const size = byteLength(messages.get(event.id) as string) + ATTRIBUTE_ALLOWANCE_BYTES;\n    const full = current.length >= SNS_BATCH_MAX;\n    const wouldOverflow = current.length > 0 && currentBytes + size > SNS_MAX_BYTES;\n    if (full || wouldOverflow) {\n      out.push(current);\n      current = [];\n      currentBytes = 0;\n    }\n    current.push(event);\n    currentBytes += size;\n  }\n  if (current.length > 0) out.push(current);\n  return out;\n}\n"]}

package/dist/events/index.d.ts

@@ -0,0 +1,15 @@
+import { type EventsClient } from './client';
+export { createEventsClient, type EventsClient, type EventsClientInput, type PublishOptions, type PublishBatchInput, } from './client';
+export { platformEventSchema, domainForEventType, DOMAIN_BY_RESOURCE, PLATFORM_EVENT_TYPES, PLATFORM_EVENT_VERSION, type PlatformEvent, type PlatformEventType, } from './schema';
+/**
+ * Lazily-built default events client, configured entirely from the
+ * environment (`PLATFORM_EVENTS_TOPIC_ARN`, `PLATFORM_EVENTS_SOURCE`).
+ *
+ * Lazy because constructing it eagerly would build an SNS client — and
+ * read config that may not be set — in every process that merely imports
+ * the SDK. Use `createEventsClient(...)` when you need an isolated client
+ * with its own topic, region, or injected SNS client.
+ */
+export declare const events: EventsClient;
+/** Test-only: drop the memoised default client so env changes take effect. */
+export declare function _resetEventsSingleton(): void;

package/dist/events/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.events = exports.PLATFORM_EVENT_VERSION = exports.PLATFORM_EVENT_TYPES = exports.DOMAIN_BY_RESOURCE = exports.domainForEventType = exports.platformEventSchema = exports.createEventsClient = void 0;
+exports._resetEventsSingleton = _resetEventsSingleton;
+const client_1 = require("./client");
+var client_2 = require("./client");
+Object.defineProperty(exports, "createEventsClient", { enumerable: true, get: function () { return client_2.createEventsClient; } });
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "platformEventSchema", { enumerable: true, get: function () { return schema_1.platformEventSchema; } });
+Object.defineProperty(exports, "domainForEventType", { enumerable: true, get: function () { return schema_1.domainForEventType; } });
+Object.defineProperty(exports, "DOMAIN_BY_RESOURCE", { enumerable: true, get: function () { return schema_1.DOMAIN_BY_RESOURCE; } });
+Object.defineProperty(exports, "PLATFORM_EVENT_TYPES", { enumerable: true, get: function () { return schema_1.PLATFORM_EVENT_TYPES; } });
+Object.defineProperty(exports, "PLATFORM_EVENT_VERSION", { enumerable: true, get: function () { return schema_1.PLATFORM_EVENT_VERSION; } });
+let singleton;
+/**
+ * Lazily-built default events client, configured entirely from the
+ * environment (`PLATFORM_EVENTS_TOPIC_ARN`, `PLATFORM_EVENTS_SOURCE`).
+ *
+ * Lazy because constructing it eagerly would build an SNS client — and
+ * read config that may not be set — in every process that merely imports
+ * the SDK. Use `createEventsClient(...)` when you need an isolated client
+ * with its own topic, region, or injected SNS client.
+ */
+exports.events = {
+    publish(type, data, opts) {
+        return defaultClient().publish(type, data, opts);
+    },
+    publishBatch(batch) {
+        return defaultClient().publishBatch(batch);
+    },
+};
+function defaultClient() {
+    if (!singleton)
+        singleton = (0, client_1.createEventsClient)();
+    return singleton;
+}
+/** Test-only: drop the memoised default client so env changes take effect. */
+function _resetEventsSingleton() {
+    singleton = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/events/schema.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+/** Dotted `resource.operation`, e.g. `order.status_changed`. */
+export declare const EVENT_TYPE_RE: RegExp;
+export declare const platformEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    domain: z.ZodString;
+    source: z.ZodString;
+    version: z.ZodNumber;
+    occurredAt: z.ZodString;
+    tenantId: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    id: string;
+    domain: string;
+    source: string;
+    version: number;
+    occurredAt: string;
+    tenantId: string;
+    data: Record<string, unknown>;
+}, {
+    type: string;
+    id: string;
+    domain: string;
+    source: string;
+    version: number;
+    occurredAt: string;
+    tenantId: string;
+    data: Record<string, unknown>;
+}>;
+export type PlatformEvent = z.infer<typeof platformEventSchema>;
+/** Event types the bus carries in phase 1. */
+export declare const PLATFORM_EVENT_TYPES: readonly ["order.created", "order.status_changed"];
+export type PlatformEventType = (typeof PLATFORM_EVENT_TYPES)[number];
+/** Current envelope version stamped on everything this SDK publishes. */
+export declare const PLATFORM_EVENT_VERSION = 1;
+/**
+ * Resource prefix → bus domain.
+ *
+ * An explicit map, not a pluralisation rule: the platform's domains are
+ * not uniformly plural (`orders` and `customers` are, `menu`, `loyalty`
+ * and `usage` are not).
+ *
+ * Copied from `packages/common/src/events/domains.json`, which is the
+ * single source of truth, because this package is published to npm and
+ * cannot import from a private workspace package. Exported so
+ * `test/events/domain-map.test.ts` can assert it against that JSON — the
+ * suite fails the moment the two drift.
+ */
+export declare const DOMAIN_BY_RESOURCE: Readonly<Record<string, string>>;
+/**
+ * The domain an event type belongs to, or null for a malformed type or
+ * an unregistered resource prefix. `publish()` treats null as an error:
+ * emitting onto a domain that does not exist is a call-site mistake, and
+ * nothing downstream is subscribed to catch it.
+ */
+export declare function domainForEventType(type: string): string | null;

package/dist/events/schema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMAIN_BY_RESOURCE = exports.PLATFORM_EVENT_VERSION = exports.PLATFORM_EVENT_TYPES = exports.platformEventSchema = exports.EVENT_TYPE_RE = void 0;
+exports.domainForEventType = domainForEventType;
+const zod_1 = require("zod");
+/**
+ * Platform event-bus envelope, publisher side.
+ *
+ * This mirrors `@uengage/common`'s `platformEventSchema` field for field.
+ * It is duplicated rather than imported because `@uengage/common` is a
+ * private workspace package and this SDK is published to npm — the same
+ * reason `audit/schema.ts` lives here instead of in common. The two are
+ * kept honest by `services/realtime/test/envelope.test.ts`, which
+ * validates an SDK-built envelope against the common schema.
+ */
+/** ULID: Crockford base32, 26 chars, excludes I/L/O/U. */
+const ULID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+/** Dotted `resource.operation`, e.g. `order.status_changed`. */
+exports.EVENT_TYPE_RE = /^[a-z][a-z0-9_]*\.[a-z][a-z0-9_]*$/;
+exports.platformEventSchema = zod_1.z.object({
+    id: zod_1.z.string().regex(ULID_RE, 'must be a ULID'),
+    type: zod_1.z.string().regex(exports.EVENT_TYPE_RE, 'must be "<resource>.<operation>"'),
+    domain: zod_1.z.string().regex(/^[a-z][a-z0-9_]*$/, 'must be a lowercase domain token'),
+    source: zod_1.z.string().min(1),
+    version: zod_1.z.number().int().positive(),
+    occurredAt: zod_1.z.string().datetime({ offset: false }),
+    tenantId: zod_1.z.string().min(1),
+    data: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+});
+/** Event types the bus carries in phase 1. */
+exports.PLATFORM_EVENT_TYPES = ['order.created', 'order.status_changed'];
+/** Current envelope version stamped on everything this SDK publishes. */
+exports.PLATFORM_EVENT_VERSION = 1;
+/**
+ * Resource prefix → bus domain.
+ *
+ * An explicit map, not a pluralisation rule: the platform's domains are
+ * not uniformly plural (`orders` and `customers` are, `menu`, `loyalty`
+ * and `usage` are not).
+ *
+ * Copied from `packages/common/src/events/domains.json`, which is the
+ * single source of truth, because this package is published to npm and
+ * cannot import from a private workspace package. Exported so
+ * `test/events/domain-map.test.ts` can assert it against that JSON — the
+ * suite fails the moment the two drift.
+ */
+exports.DOMAIN_BY_RESOURCE = {
+    order: 'orders',
+    customer: 'customers',
+    menu: 'menu',
+    offer: 'offers',
+    loyalty: 'loyalty',
+    usage: 'usage',
+};
+/**
+ * The domain an event type belongs to, or null for a malformed type or
+ * an unregistered resource prefix. `publish()` treats null as an error:
+ * emitting onto a domain that does not exist is a call-site mistake, and
+ * nothing downstream is subscribed to catch it.
+ */
+function domainForEventType(type) {
+    if (!exports.EVENT_TYPE_RE.test(type))
+        return null;
+    const resource = type.slice(0, type.indexOf('.'));
+    return exports.DOMAIN_BY_RESOURCE[resource] ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/realtime/connect.d.ts

@@ -0,0 +1,106 @@
+import { type RealtimeEvent } from './envelope';
+import { type RealtimeEndpoints, type RealtimeEnv } from './endpoints';
+/**
+ * The slice of the WebSocket API this client uses.
+ *
+ * Declared structurally rather than relying on a DOM lib: the SDK
+ * compiles against `lib: ES2022` only, and this keeps the client
+ * injectable so tests can drive the protocol with a fake socket.
+ */
+export interface MinimalWebSocket {
+    readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    onopen: ((ev: unknown) => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onerror: ((ev: unknown) => void) | null;
+    onclose: ((ev: {
+        code?: number;
+        reason?: string;
+    }) => void) | null;
+}
+export type WebSocketCtor = new (url: string, protocols?: string | string[]) => MinimalWebSocket;
+/** Where an event handed to `onUpdate` came from. */
+export interface UpdateMeta {
+    channel: string;
+    /**
+     * `'snapshot'` — the channel's last value, fetched from the last-value
+     * cache on subscribe or after a reconnect. `'live'` — delivered over
+     * the socket.
+     *
+     * Apps generally don't need to branch on this; the SDK has already
+     * ordered and de-duplicated both sources by ULID. It's there for
+     * telemetry and for UIs that want to distinguish "restored" from
+     * "just happened".
+     */
+    origin: 'snapshot' | 'live';
+}
+export interface SubscribeOptions {
+    /**
+     * Fires once with the channel's latest known value (if any), then on
+     * every live event. Never fires with an event older than one already
+     * delivered on this subscription.
+     */
+    onUpdate(event: RealtimeEvent, meta: UpdateMeta): void;
+    /**
+     * Subscription-level failures: a rejected subscribe, a malformed
+     * frame, a failed snapshot fetch. Transient socket drops are handled
+     * internally by the reconnect loop and are not surfaced here.
+     */
+    onError?(error: Error): void;
+    /**
+     * Replace the built-in last-value fetch for this channel. Return null
+     * when there is no snapshot. Useful when a domain has a better source
+     * of truth than the cache — e.g. falling back to the order-details API
+     * for an order whose transitions predate bus instrumentation.
+     */
+    getSnapshot?(channel: string): Promise<RealtimeEvent | null>;
+}
+export interface Subscription {
+    readonly channel: string;
+    unsubscribe(): void;
+}
+export interface RealtimeClient {
+    /**
+     * Subscribe to a channel. Channels are the only concept here — the
+     * realtime layer knows nothing about orders; `/orders/{id}` is a
+     * naming convention enforced by the service's namespace policy, not by
+     * this client.
+     *
+     * On this call, and again after every reconnect, the SDK opens the
+     * subscription *first* and only then fetches the channel's last value,
+     * so no event can fall between the snapshot and the stream.
+     */
+    subscribe(channel: string, options: SubscribeOptions): Subscription;
+    /** Close the shared socket and stop reconnecting. */
+    close(): void;
+}
+export interface RealtimeConnectOptions {
+    /** Resolves endpoints from the built-in table. Mutually exclusive with `endpoints`. */
+    env?: RealtimeEnv;
+    /** Explicit endpoints, for environments not in the table. */
+    endpoints?: RealtimeEndpoints;
+    /**
+     * Supplies the platform JWT. Called on connect, on every (re)subscribe,
+     * and again after a token-expiry reconnect — so returning a fresh token
+     * from your session store is enough to keep a long-lived connection
+     * authenticated.
+     */
+    getToken(): string | Promise<string>;
+    /** Inject a WebSocket implementation. Defaults to `globalThis.WebSocket`. */
+    webSocketImpl?: WebSocketCtor;
+    /** Inject a fetch implementation for snapshot fetches. Defaults to `globalThis.fetch`. */
+    fetchFn?: typeof fetch;
+    /** Backoff ceiling for reconnects. Default 30_000. */
+    maxReconnectDelayMs?: number;
+}
+export declare function connect(options: RealtimeConnectOptions): RealtimeClient;
+/**
+ * Full-jitter exponential backoff. Full jitter (rather than
+ * delay ± jitter) matters here because every tab watching an order
+ * reconnects on the same server-side event; without it they retry in
+ * lockstep.
+ */
+export declare function jitteredBackoff(attempt: number, maxDelayMs: number): number;