@uengage.io/platform-sdk 0.14.0 → 1.0.0

package/dist/realtime/envelope.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Dependency-free envelope guard for the browser realtime client.
+ *
+ * This mirrors `@uengage/common`'s `platformEventSchema` and the SDK's own
+ * `events/schema.ts`, but hand-rolled: the `/realtime` subpath ships with
+ * zero runtime dependencies (no zod, no Node built-ins) so it stays a few
+ * KB in a frontend bundle. Change one, change all three.
+ *
+ * NO DOMAIN CROSS-CHECK, deliberately — this is the one mirror that does
+ * not carry the resource→domain map, and it is not an oversight:
+ *
+ *   - It would be checking the wrong thing. The producing SDK derives
+ *     `domain` from `type` and the consuming service re-validates the pair
+ *     before it ever publishes to a channel. By the time an envelope
+ *     reaches a browser the pair has been checked twice server-side; a
+ *     third check can only reject, never repair.
+ *   - It would rot dangerously. A browser bundle sits in someone's cache
+ *     for weeks. Baking today's map into it means that the day a new
+ *     domain ships, every un-refreshed tab starts silently dropping live
+ *     events for it — a stale client rejecting the future, which is the
+ *     failure mode `validatePlatformEvent` is careful to avoid even
+ *     server-side.
+ *
+ * So the guard is structural only: shapes and types, not membership.
+ * `packages/platform-sdk/test/events/domain-map.test.ts` asserts that
+ * every canonical domain is accepted, and that an unlisted one is too.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asRealtimeEvent = asRealtimeEvent;
+exports.isNewer = isNewer;
+/** 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`. */
+const EVENT_TYPE_RE = /^[a-z][a-z0-9_]*\.[a-z][a-z0-9_]*$/;
+/**
+ * Structural check on an untrusted payload. Returns the event or null —
+ * never throws, because a single malformed frame must not tear down a
+ * live subscription.
+ */
+function asRealtimeEvent(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const v = value;
+    if (typeof v.id !== 'string' || !ULID_RE.test(v.id))
+        return null;
+    if (typeof v.type !== 'string' || !EVENT_TYPE_RE.test(v.type))
+        return null;
+    if (typeof v.domain !== 'string' || v.domain.length === 0)
+        return null;
+    if (typeof v.source !== 'string' || v.source.length === 0)
+        return null;
+    if (typeof v.version !== 'number' || !Number.isInteger(v.version) || v.version < 1)
+        return null;
+    if (typeof v.occurredAt !== 'string' || v.occurredAt.length === 0)
+        return null;
+    if (typeof v.tenantId !== 'string' || v.tenantId.length === 0)
+        return null;
+    if (typeof v.data !== 'object' || v.data === null || Array.isArray(v.data))
+        return null;
+    return v;
+}
+/**
+ * Ordering/dedupe guard, keyed on the envelope's monotonic ULID.
+ *
+ * ULIDs are lexicographically sortable by mint time, so a plain string
+ * compare orders events without parsing timestamps or knowing anything
+ * about the domain. This is what makes at-least-once delivery and the
+ * snapshot/stream race both harmless: whichever arrives second with an
+ * id <= the one already rendered is dropped.
+ */
+function isNewer(candidateId, seenId) {
+    if (seenId === undefined)
+        return true;
+    return candidateId > seenId;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/realtime/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `@uengage.io/platform-sdk/realtime` — browser-safe realtime client.
+ *
+ * A thin client for the platform's AppSync Events API: it owns the wire
+ * protocol, the keepalive watchdog, reconnect with jittered backoff,
+ * resubscribe, token refresh, snapshot catch-up on every (re)connect,
+ * and ULID-based ordering/dedupe. Apps own rendering and channel names.
+ *
+ * ```ts
+ * import { realtime } from '@uengage.io/platform-sdk/realtime';
+ *
+ * const client = realtime.connect({
+ *   env: 'prod',
+ *   getToken: () => session.jwt(),
+ * });
+ *
+ * const sub = client.subscribe(`/orders/${orderId}`, {
+ *   onUpdate(event, meta) { render(event.data); },
+ *   onError(err) { showOffline(err); },
+ * });
+ *
+ * sub.unsubscribe();
+ * ```
+ *
+ * This subpath is deliberately isolated from the SDK's main entry: zero
+ * runtime dependencies, no Node built-ins, no server auth code, so it
+ * stays a few KB in a frontend bundle and works unchanged in React
+ * Native. Do not import from `../` here.
+ */
+import { connect } from './connect';
+export declare const realtime: {
+    connect: typeof connect;
+};
+export { connect, jitteredBackoff, type RealtimeClient, type RealtimeConnectOptions, type Subscription, type SubscribeOptions, type UpdateMeta, type MinimalWebSocket, type WebSocketCtor, } from './connect';
+export { asRealtimeEvent, isNewer, type RealtimeEvent } from './envelope';
+export { API_BASE, endpointsFor, type RealtimeEndpoints, type RealtimeEnv } from './endpoints';
+export { EVENT_WS_SUBPROTOCOL, authHeader, authSubprotocol, base64UrlEncode } from './protocol';

package/dist/realtime/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64UrlEncode = exports.authSubprotocol = exports.authHeader = exports.EVENT_WS_SUBPROTOCOL = exports.endpointsFor = exports.API_BASE = exports.isNewer = exports.asRealtimeEvent = exports.jitteredBackoff = exports.connect = exports.realtime = void 0;
+/**
+ * `@uengage.io/platform-sdk/realtime` — browser-safe realtime client.
+ *
+ * A thin client for the platform's AppSync Events API: it owns the wire
+ * protocol, the keepalive watchdog, reconnect with jittered backoff,
+ * resubscribe, token refresh, snapshot catch-up on every (re)connect,
+ * and ULID-based ordering/dedupe. Apps own rendering and channel names.
+ *
+ * ```ts
+ * import { realtime } from '@uengage.io/platform-sdk/realtime';
+ *
+ * const client = realtime.connect({
+ *   env: 'prod',
+ *   getToken: () => session.jwt(),
+ * });
+ *
+ * const sub = client.subscribe(`/orders/${orderId}`, {
+ *   onUpdate(event, meta) { render(event.data); },
+ *   onError(err) { showOffline(err); },
+ * });
+ *
+ * sub.unsubscribe();
+ * ```
+ *
+ * This subpath is deliberately isolated from the SDK's main entry: zero
+ * runtime dependencies, no Node built-ins, no server auth code, so it
+ * stays a few KB in a frontend bundle and works unchanged in React
+ * Native. Do not import from `../` here.
+ */
+const connect_1 = require("./connect");
+exports.realtime = { connect: connect_1.connect };
+var connect_2 = require("./connect");
+Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return connect_2.connect; } });
+Object.defineProperty(exports, "jitteredBackoff", { enumerable: true, get: function () { return connect_2.jitteredBackoff; } });
+var envelope_1 = require("./envelope");
+Object.defineProperty(exports, "asRealtimeEvent", { enumerable: true, get: function () { return envelope_1.asRealtimeEvent; } });
+Object.defineProperty(exports, "isNewer", { enumerable: true, get: function () { return envelope_1.isNewer; } });
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "API_BASE", { enumerable: true, get: function () { return endpoints_1.API_BASE; } });
+Object.defineProperty(exports, "endpointsFor", { enumerable: true, get: function () { return endpoints_1.endpointsFor; } });
+var protocol_1 = require("./protocol");
+Object.defineProperty(exports, "EVENT_WS_SUBPROTOCOL", { enumerable: true, get: function () { return protocol_1.EVENT_WS_SUBPROTOCOL; } });
+Object.defineProperty(exports, "authHeader", { enumerable: true, get: function () { return protocol_1.authHeader; } });
+Object.defineProperty(exports, "authSubprotocol", { enumerable: true, get: function () { return protocol_1.authSubprotocol; } });
+Object.defineProperty(exports, "base64UrlEncode", { enumerable: true, get: function () { return protocol_1.base64UrlEncode; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/realtime/protocol.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The AppSync Events WebSocket wire protocol, as documented at
+ * https://docs.aws.amazon.com/appsync/latest/eventapi/event-api-websocket-protocol.html
+ *
+ * Everything here is pure data + string manipulation: no I/O, no
+ * dependencies, no Node built-ins. The socket lifecycle lives in
+ * `connect.ts`.
+ */
+/** WebSocket subprotocol that selects the Events (not GraphQL) protocol. */
+export declare const EVENT_WS_SUBPROTOCOL = "aws-appsync-event-ws";
+/**
+ * AppSync takes connection auth as a *subprotocol*, because a browser
+ * WebSocket cannot set request headers. The auth header object is
+ * JSON-encoded, base64url-encoded, and prefixed with `header-`.
+ */
+export declare function authSubprotocol(header: Record<string, string>): string;
+/**
+ * The auth object AppSync expects, for both the connection handshake and
+ * each `subscribe` frame. `host` must be the API's HTTP domain (not the
+ * realtime domain) — AppSync validates the signature/token against it.
+ */
+export declare function authHeader(httpHost: string, token: string): Record<string, string>;
+/**
+ * base64url with padding stripped. Uses `btoa` over UTF-8 bytes rather
+ * than `Buffer`, which does not exist in a browser.
+ */
+export declare function base64UrlEncode(input: string): string;
+export interface ConnectionAckFrame {
+    type: 'connection_ack';
+    /**
+     * How long the server will tolerate silence before it closes the
+     * connection. The client watchdog uses this rather than a hard-coded
+     * 60s so a server-side change doesn't strand us.
+     */
+    connectionTimeoutMs?: number;
+}
+export interface DataFrame {
+    type: 'data';
+    id: string;
+    /**
+     * The published payload, JSON-encoded *inside* the already-JSON frame.
+     * Double-encoded on the wire; `parseDataFrameEvent` unwraps both.
+     */
+    event: string;
+}
+export interface ErrorFrame {
+    type: 'connection_error' | 'subscribe_error' | 'publish_error';
+    id?: string;
+    errors?: Array<{
+        errorType?: string;
+        message?: string;
+    }>;
+}
+export type ServerFrame = ConnectionAckFrame | DataFrame | ErrorFrame | {
+    type: 'ka';
+} | {
+    type: 'subscribe_success';
+    id: string;
+} | {
+    type: 'unsubscribe_success';
+    id: string;
+} | {
+    type: string;
+    [k: string]: unknown;
+};
+export declare function parseServerFrame(raw: string): ServerFrame | null;
+/** Unwrap the inner JSON of a `data` frame. Null if it isn't parseable. */
+export declare function parseDataFrameEvent(frame: DataFrame): unknown;
+/** Human-readable text from an error frame, for `onError`. */
+export declare function errorFrameMessage(frame: ErrorFrame): string;
+export declare function connectionInitFrame(): string;
+export declare function subscribeFrame(id: string, channel: string, auth: Record<string, string>): string;
+export declare function unsubscribeFrame(id: string): string;

package/dist/realtime/protocol.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * The AppSync Events WebSocket wire protocol, as documented at
+ * https://docs.aws.amazon.com/appsync/latest/eventapi/event-api-websocket-protocol.html
+ *
+ * Everything here is pure data + string manipulation: no I/O, no
+ * dependencies, no Node built-ins. The socket lifecycle lives in
+ * `connect.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_WS_SUBPROTOCOL = void 0;
+exports.authSubprotocol = authSubprotocol;
+exports.authHeader = authHeader;
+exports.base64UrlEncode = base64UrlEncode;
+exports.parseServerFrame = parseServerFrame;
+exports.parseDataFrameEvent = parseDataFrameEvent;
+exports.errorFrameMessage = errorFrameMessage;
+exports.connectionInitFrame = connectionInitFrame;
+exports.subscribeFrame = subscribeFrame;
+exports.unsubscribeFrame = unsubscribeFrame;
+/** WebSocket subprotocol that selects the Events (not GraphQL) protocol. */
+exports.EVENT_WS_SUBPROTOCOL = 'aws-appsync-event-ws';
+/**
+ * AppSync takes connection auth as a *subprotocol*, because a browser
+ * WebSocket cannot set request headers. The auth header object is
+ * JSON-encoded, base64url-encoded, and prefixed with `header-`.
+ */
+function authSubprotocol(header) {
+    return `header-${base64UrlEncode(JSON.stringify(header))}`;
+}
+/**
+ * The auth object AppSync expects, for both the connection handshake and
+ * each `subscribe` frame. `host` must be the API's HTTP domain (not the
+ * realtime domain) — AppSync validates the signature/token against it.
+ */
+function authHeader(httpHost, token) {
+    return { host: httpHost, Authorization: token };
+}
+/**
+ * base64url with padding stripped. Uses `btoa` over UTF-8 bytes rather
+ * than `Buffer`, which does not exist in a browser.
+ */
+function base64UrlEncode(input) {
+    const bytes = new TextEncoder().encode(input);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+function parseServerFrame(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null)
+            return null;
+        const frame = parsed;
+        if (typeof frame.type !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Unwrap the inner JSON of a `data` frame. Null if it isn't parseable. */
+function parseDataFrameEvent(frame) {
+    try {
+        return JSON.parse(frame.event);
+    }
+    catch {
+        return null;
+    }
+}
+/** Human-readable text from an error frame, for `onError`. */
+function errorFrameMessage(frame) {
+    const parts = (frame.errors ?? [])
+        .map((e) => e.message ?? e.errorType)
+        .filter((m) => typeof m === 'string' && m.length > 0);
+    return parts.length > 0 ? parts.join('; ') : frame.type;
+}
+function connectionInitFrame() {
+    return JSON.stringify({ type: 'connection_init' });
+}
+function subscribeFrame(id, channel, auth) {
+    return JSON.stringify({ type: 'subscribe', id, channel, authorization: auth });
+}
+function unsubscribeFrame(id) {
+    return JSON.stringify({ type: 'unsubscribe', id });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/realtime/protocol.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The AppSync Events WebSocket wire protocol, as documented at\n * https://docs.aws.amazon.com/appsync/latest/eventapi/event-api-websocket-protocol.html\n *\n * Everything here is pure data + string manipulation: no I/O, no\n * dependencies, no Node built-ins. The socket lifecycle lives in\n * `connect.ts`.\n */\n\n/** WebSocket subprotocol that selects the Events (not GraphQL) protocol. */\nexport const EVENT_WS_SUBPROTOCOL = 'aws-appsync-event-ws';\n\n/**\n * AppSync takes connection auth as a *subprotocol*, because a browser\n * WebSocket cannot set request headers. The auth header object is\n * JSON-encoded, base64url-encoded, and prefixed with `header-`.\n */\nexport function authSubprotocol(header: Record<string, string>): string {\n  return `header-${base64UrlEncode(JSON.stringify(header))}`;\n}\n\n/**\n * The auth object AppSync expects, for both the connection handshake and\n * each `subscribe` frame. `host` must be the API's HTTP domain (not the\n * realtime domain) — AppSync validates the signature/token against it.\n */\nexport function authHeader(httpHost: string, token: string): Record<string, string> {\n  return { host: httpHost, Authorization: token };\n}\n\n/**\n * base64url with padding stripped. Uses `btoa` over UTF-8 bytes rather\n * than `Buffer`, which does not exist in a browser.\n */\nexport function base64UrlEncode(input: string): string {\n  const bytes = new TextEncoder().encode(input);\n  let binary = '';\n  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);\n  return btoa(binary).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n// ─── Frames ────────────────────────────────────────────────────────────\n\nexport interface ConnectionAckFrame {\n  type: 'connection_ack';\n  /**\n   * How long the server will tolerate silence before it closes the\n   * connection. The client watchdog uses this rather than a hard-coded\n   * 60s so a server-side change doesn't strand us.\n   */\n  connectionTimeoutMs?: number;\n}\n\nexport interface DataFrame {\n  type: 'data';\n  id: string;\n  /**\n   * The published payload, JSON-encoded *inside* the already-JSON frame.\n   * Double-encoded on the wire; `parseDataFrameEvent` unwraps both.\n   */\n  event: string;\n}\n\nexport interface ErrorFrame {\n  type: 'connection_error' | 'subscribe_error' | 'publish_error';\n  id?: string;\n  errors?: Array<{ errorType?: string; message?: string }>;\n}\n\nexport type ServerFrame =\n  | ConnectionAckFrame\n  | DataFrame\n  | ErrorFrame\n  | { type: 'ka' }\n  | { type: 'subscribe_success'; id: string }\n  | { type: 'unsubscribe_success'; id: string }\n  | { type: string; [k: string]: unknown };\n\nexport function parseServerFrame(raw: string): ServerFrame | null {\n  try {\n    const parsed = JSON.parse(raw) as unknown;\n    if (typeof parsed !== 'object' || parsed === null) return null;\n    const frame = parsed as { type?: unknown };\n    if (typeof frame.type !== 'string') return null;\n    return parsed as ServerFrame;\n  } catch {\n    return null;\n  }\n}\n\n/** Unwrap the inner JSON of a `data` frame. Null if it isn't parseable. */\nexport function parseDataFrameEvent(frame: DataFrame): unknown {\n  try {\n    return JSON.parse(frame.event) as unknown;\n  } catch {\n    return null;\n  }\n}\n\n/** Human-readable text from an error frame, for `onError`. */\nexport function errorFrameMessage(frame: ErrorFrame): string {\n  const parts = (frame.errors ?? [])\n    .map((e) => e.message ?? e.errorType)\n    .filter((m): m is string => typeof m === 'string' && m.length > 0);\n  return parts.length > 0 ? parts.join('; ') : frame.type;\n}\n\nexport function connectionInitFrame(): string {\n  return JSON.stringify({ type: 'connection_init' });\n}\n\nexport function subscribeFrame(id: string, channel: string, auth: Record<string, string>): string {\n  return JSON.stringify({ type: 'subscribe', id, channel, authorization: auth });\n}\n\nexport function unsubscribeFrame(id: string): string {\n  return JSON.stringify({ type: 'unsubscribe', id });\n}\n"]}

package/dist/zones/client.d.ts

@@ -1,5 +1,5 @@
 import { type PlatformAuth, type PlatformAuthInput, type PlatformConfigInput } from '../config';
-import type { ContainingInput, Zone, ZoneCreateInput, ZoneCreateResult, ZoneListOptions, ZoneListPage, ZonePatchInput, ZoneReplaceInput, ZoneSummary } from './schema';
+import type { ContainingInput, IntersectingInput, NearbyInput, Zone, ZoneCreateInput, ZoneCreateResult, ZoneListOptions, ZoneListPage, ZoneNearby, ZonePatchInput, ZoneReplaceInput, ZoneSummary } from './schema';
 export interface ZonesClient {
     config(input: PlatformConfigInput): ZonesClient;
     auth(input: PlatformAuthInput | PlatformAuth): ZonesClient;
@@ -29,6 +29,10 @@ export interface ZonesClient {
     containing(input: ContainingInput): Promise<ZoneSummary[]>;
     /** Sugar over containing({ point, ids: [zid] }). True iff the zone contains the point. */
     contains(zid: string, point: ContainingInput['point']): Promise<boolean>;
+    /** POST /v1/zones/nearby - zones within `radiusMeters` of a point, ordered by distance asc. */
+    nearby(input: NearbyInput): Promise<ZoneNearby[]>;
+    /** POST /v1/zones/intersecting - zones whose geometry overlaps the given geometry. */
+    intersecting(input: IntersectingInput): Promise<ZoneSummary[]>;
 }
 export declare class ZonesApiError extends Error {
     readonly status: number;

package/dist/zones/client.js

@@ -34,6 +34,22 @@ function assertPoint(label, point) {
         throw new Error(`zones.${label}: lng must be in [-180, 180] (got ${lng})`);
     }
 }
+function assertGeometry(label, geometry) {
+    const type = geometry?.type;
+    if (type !== 'Polygon' && type !== 'MultiPolygon') {
+        throw new Error(`zones.${label}: geometry.type must be Polygon or MultiPolygon (got ${JSON.stringify(type)})`);
+    }
+}
+function assertPositiveNumber(label, field, value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+        throw new Error(`zones.${label}: ${field} must be a positive number (got ${value})`);
+    }
+}
+function assertPositiveInt(label, field, value) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`zones.${label}: ${field} must be a positive integer (got ${value})`);
+    }
+}
 /**
  * Build the `zones` namespace.
  *
@@ -150,7 +166,40 @@ function createZonesClient(input = {}) {
             const matches = await client.containing({ point, ids: [zid] });
             return matches.length > 0;
         },
+        async nearby(input) {
+            if (!input || typeof input !== 'object') {
+                throw new Error('zones.nearby: input must include `point`');
+            }
+            assertPoint('nearby', input.point);
+            assertPositiveNumber('nearby', 'radiusMeters', input.radiusMeters);
+            if (input.limit !== undefined)
+                assertPositiveInt('nearby', 'limit', input.limit);
+            if (input.ids !== undefined) {
+                for (const zid of input.ids)
+                    assertUuid('nearby', zid);
+            }
+            const res = await send('POST', '/v1/zones/nearby', undefined, input);
+            const body = await expectJson(res);
+            return body.zones;
+        },
+        async intersecting(input) {
+            if (!input || typeof input !== 'object' || !input.geometry) {
+                throw new Error('zones.intersecting: input must include `geometry`');
+            }
+            assertGeometry('intersecting', input.geometry);
+            if (input.limit !== undefined)
+                assertPositiveInt('intersecting', 'limit', input.limit);
+            if (input.ids !== undefined) {
+                for (const zid of input.ids)
+                    assertUuid('intersecting', zid);
+            }
+            if (input.excludeZid !== undefined)
+                assertUuid('intersecting', input.excludeZid);
+            const res = await send('POST', '/v1/zones/intersecting', undefined, input);
+            const body = await expectJson(res);
+            return body.zones;
+        },
     };
     return client;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/zones/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { sendWithAuthRetry } from '../http';\nimport type {\n  ContainingInput,\n  Zone,\n  ZoneCreateInput,\n  ZoneCreateResult,\n  ZoneListOptions,\n  ZoneListPage,\n  ZonePatchInput,\n  ZoneReplaceInput,\n  ZoneSummary,\n} from './schema';\n\nconst UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\nexport interface ZonesClient {\n  config(input: PlatformConfigInput): ZonesClient;\n  auth(input: PlatformAuthInput | PlatformAuth): ZonesClient;\n\n  /** POST /v1/zones - create a single zone. */\n  create(input: ZoneCreateInput): Promise<ZoneCreateResult>;\n  /** GET /v1/zones/{zid} - returns the full zone or throws ZonesApiError(404). */\n  get(zid: string): Promise<Zone>;\n  /** PATCH /v1/zones/{zid} - shallow tag merge; null deletes a key. */\n  update(zid: string, input: ZonePatchInput): Promise<Zone>;\n  /** PUT /v1/zones/{zid} - full replace of geometry + tags. */\n  replace(zid: string, input: ZoneReplaceInput): Promise<Zone>;\n  /** DELETE /v1/zones/{zid} - 404 if not present. */\n  delete(zid: string): Promise<void>;\n  /** GET /v1/zones?tags=... - tag-filtered, keyset-paginated listing. */\n  list(opts?: ZoneListOptions): Promise<ZoneListPage>;\n  /** POST /v1/zones/batch/create - bounded array; returned in input order. */\n  createMany(zones: readonly ZoneCreateInput[]): Promise<{ zones: Array<{ zid: string }> }>;\n  /** POST /v1/zones/batch/delete - returns the count actually deleted. */\n  deleteMany(zids: readonly string[]): Promise<{ deleted: number }>;\n\n  /** POST /v1/zones/containing - the spatial primitive. */\n  containing(input: ContainingInput): Promise<ZoneSummary[]>;\n  /** Sugar over containing({ point, ids: [zid] }). True iff the zone contains the point. */\n  contains(zid: string, point: ContainingInput['point']): Promise<boolean>;\n}\n\nexport class ZonesApiError extends Error {\n  readonly status: number;\n  readonly body: string;\n\n  constructor(status: number, body: string) {\n    super(`zones API ${status}: ${body}`);\n    this.name = 'ZonesApiError';\n    this.status = status;\n    this.body = body;\n  }\n}\n\nfunction assertUuid(label: string, zid: string): void {\n  if (typeof zid !== 'string' || !UUID_REGEX.test(zid)) {\n    throw new Error(`zones.${label}: zid must be a uuid (got ${JSON.stringify(zid)})`);\n  }\n}\n\nfunction assertPoint(label: string, point: { lat: number; lng: number }): void {\n  const lat = point?.lat;\n  const lng = point?.lng;\n  if (typeof lat !== 'number' || typeof lng !== 'number') {\n    throw new Error(`zones.${label}: point must be { lat: number, lng: number }`);\n  }\n  if (!Number.isFinite(lat) || lat < -90 || lat > 90) {\n    throw new Error(`zones.${label}: lat must be in [-90, 90] (got ${lat})`);\n  }\n  if (!Number.isFinite(lng) || lng < -180 || lng > 180) {\n    throw new Error(`zones.${label}: lng must be in [-180, 180] (got ${lng})`);\n  }\n}\n\n/**\n * Build the `zones` namespace.\n *\n * Shape and contract mirror {@link createBusinessClient} - lazy config\n * resolution via {@link ConfigState}, shared 401-retry via\n * {@link sendWithAuthRetry}, immutable per-call config; no globals.\n *\n * Writes (`create`, `update`, `replace`, `delete`, batch ops) require a\n * service-actor token. Reads (`get`, `list`, `containing`, `contains`)\n * accept either a service-actor or a user-actor token. The SDK does not\n * enforce this - the server returns 401/403 and we surface it as\n * {@link ZonesApiError}.\n */\nexport function createZonesClient(input: PlatformConfigInput = {}): ZonesClient {\n  const state = new ConfigState();\n  state.apply(input);\n\n  async function send(\n    method: string,\n    path: string,\n    query?: string,\n    body?: unknown,\n  ): Promise<Response> {\n    const config = state.resolve();\n    const url = `${config.baseUrl}${path}${query ?? ''}`;\n    const payload = body === undefined ? undefined : JSON.stringify(body);\n    return sendWithAuthRetry(config, { method, path, url, body: payload });\n  }\n\n  async function expectJson<T>(res: Response): Promise<T> {\n    if (!res.ok) throw new ZonesApiError(res.status, await res.text());\n    return (await res.json()) as T;\n  }\n\n  const client: ZonesClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n\n    async create(input) {\n      if (!input || typeof input !== 'object') {\n        throw new Error('zones.create: input must be an object with `geometry`');\n      }\n      const res = await send('POST', '/v1/zones', undefined, input);\n      return expectJson<ZoneCreateResult>(res);\n    },\n\n    async get(zid) {\n      assertUuid('get', zid);\n      const res = await send('GET', `/v1/zones/${zid}`);\n      return expectJson<Zone>(res);\n    },\n\n    async update(zid, input) {\n      assertUuid('update', zid);\n      const res = await send('PATCH', `/v1/zones/${zid}`, undefined, input);\n      return expectJson<Zone>(res);\n    },\n\n    async replace(zid, input) {\n      assertUuid('replace', zid);\n      const res = await send('PUT', `/v1/zones/${zid}`, undefined, input);\n      return expectJson<Zone>(res);\n    },\n\n    async delete(zid) {\n      assertUuid('delete', zid);\n      const res = await send('DELETE', `/v1/zones/${zid}`);\n      if (res.status === 204) return;\n      if (!res.ok) throw new ZonesApiError(res.status, await res.text());\n    },\n\n    async list(opts = {}) {\n      const params = new URLSearchParams();\n      if (opts.tags !== undefined) params.set('tags', JSON.stringify(opts.tags));\n      if (opts.cursor !== undefined) params.set('cursor', opts.cursor);\n      if (opts.limit !== undefined) {\n        if (!Number.isInteger(opts.limit) || opts.limit <= 0) {\n          throw new Error(`zones.list: limit must be a positive integer (got ${opts.limit})`);\n        }\n        params.set('limit', String(opts.limit));\n      }\n      const qs = params.toString();\n      const res = await send('GET', '/v1/zones', qs.length ? `?${qs}` : undefined);\n      return expectJson<ZoneListPage>(res);\n    },\n\n    async createMany(zones) {\n      if (!Array.isArray(zones) || zones.length === 0) {\n        throw new Error('zones.createMany: zones must be a non-empty array');\n      }\n      const res = await send('POST', '/v1/zones/batch/create', undefined, { zones });\n      return expectJson<{ zones: Array<{ zid: string }> }>(res);\n    },\n\n    async deleteMany(zids) {\n      if (!Array.isArray(zids) || zids.length === 0) {\n        throw new Error('zones.deleteMany: zids must be a non-empty array');\n      }\n      for (const zid of zids) assertUuid('deleteMany', zid);\n      const res = await send('POST', '/v1/zones/batch/delete', undefined, { zids });\n      return expectJson<{ deleted: number }>(res);\n    },\n\n    async containing(input) {\n      if (!input || typeof input !== 'object') {\n        throw new Error('zones.containing: input must include `point`');\n      }\n      assertPoint('containing', input.point);\n      if (input.ids !== undefined) {\n        for (const zid of input.ids) assertUuid('containing', zid);\n      }\n      const res = await send('POST', '/v1/zones/containing', undefined, input);\n      const body = await expectJson<{ zones: ZoneSummary[] }>(res);\n      return body.zones;\n    },\n\n    async contains(zid, point) {\n      assertUuid('contains', zid);\n      const matches = await client.containing({ point, ids: [zid] });\n      return matches.length > 0;\n    },\n  };\n\n  return client;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/zones/client.ts"],"names":[],"mappings":";;;AAyHA,8CAmJC;AA5QD,sCAKmB;AACnB,kCAA4C;AAgB5C,MAAM,UAAU,GAAG,iEAAiE,CAAC;AAiCrF,MAAa,aAAc,SAAQ,KAAK;IAC7B,MAAM,CAAS;IACf,IAAI,CAAS;IAEtB,YAAY,MAAc,EAAE,IAAY;QACtC,KAAK,CAAC,aAAa,MAAM,KAAK,IAAI,EAAE,CAAC,CAAC;QACtC,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAVD,sCAUC;AAED,SAAS,UAAU,CAAC,KAAa,EAAE,GAAW;IAC5C,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,SAAS,KAAK,6BAA6B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACrF,CAAC;AACH,CAAC;AAED,SAAS,WAAW,CAAC,KAAa,EAAE,KAAmC;IACrE,MAAM,GAAG,GAAG,KAAK,EAAE,GAAG,CAAC;IACvB,MAAM,GAAG,GAAG,KAAK,EAAE,GAAG,CAAC;IACvB,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QACvD,MAAM,IAAI,KAAK,CAAC,SAAS,KAAK,8CAA8C,CAAC,CAAC;IAChF,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,GAAG,EAAE,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,SAAS,KAAK,mCAAmC,GAAG,GAAG,CAAC,CAAC;IAC3E,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,SAAS,KAAK,qCAAqC,GAAG,GAAG,CAAC,CAAC;IAC7E,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,KAAa,EAAE,QAAiB;IACtD,MAAM,IAAI,GAAI,QAAkD,EAAE,IAAI,CAAC;IACvE,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,cAAc,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CACb,SAAS,KAAK,wDAAwD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAC9F,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,oBAAoB,CAAC,KAAa,EAAE,KAAa,EAAE,KAAa;IACvE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QACvE,MAAM,IAAI,KAAK,CAAC,SAAS,KAAK,KAAK,KAAK,mCAAmC,KAAK,GAAG,CAAC,CAAC;IACvF,CAAC;AACH,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAa,EAAE,KAAa,EAAE,KAAa;IACpE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,SAAS,KAAK,KAAK,KAAK,oCAAoC,KAAK,GAAG,CAAC,CAAC;IACxF,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,iBAAiB,CAAC,QAA6B,EAAE;IAC/D,MAAM,KAAK,GAAG,IAAI,oBAAW,EAAE,CAAC;IAChC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAEnB,KAAK,UAAU,IAAI,CACjB,MAAc,EACd,IAAY,EACZ,KAAc,EACd,IAAc;QAEd,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,OAAO,GAAG,IAAI,GAAG,KAAK,IAAI,EAAE,EAAE,CAAC;QACrD,MAAM,OAAO,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACtE,OAAO,IAAA,wBAAiB,EAAC,MAAM,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;IACzE,CAAC;IAED,KAAK,UAAU,UAAU,CAAI,GAAa;QACxC,IAAI,CAAC,GAAG,CAAC,EAAE;YAAE,MAAM,IAAI,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;QACnE,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAM,CAAC;IACjC,CAAC;IAED,MAAM,MAAM,GAAgB;QAC1B,MAAM,CAAC,IAAI;YACT,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAClB,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,IAAI,CAAC,IAAI;YACP,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACpB,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,KAAK;YAChB,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBACxC,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;YAC3E,CAAC;YACD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YAC9D,OAAO,UAAU,CAAmB,GAAG,CAAC,CAAC;QAC3C,CAAC;QAED,KAAK,CAAC,GAAG,CAAC,GAAG;YACX,UAAU,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACvB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,EAAE,CAAC,CAAC;YAClD,OAAO,UAAU,CAAO,GAAG,CAAC,CAAC;QAC/B,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK;YACrB,UAAU,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAC1B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YACtE,OAAO,UAAU,CAAO,GAAG,CAAC,CAAC;QAC/B,CAAC;QAED,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK;YACtB,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;YAC3B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YACpE,OAAO,UAAU,CAAO,GAAG,CAAC,CAAC;QAC/B,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,GAAG;YACd,UAAU,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAC1B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,aAAa,GAAG,EAAE,CAAC,CAAC;YACrD,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG;gBAAE,OAAO;YAC/B,IAAI,CAAC,GAAG,CAAC,EAAE;gBAAE,MAAM,IAAI,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;QACrE,CAAC;QAED,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,EAAE;YAClB,MAAM,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;YACrC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;gBAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YAC3E,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;gBAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YACjE,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC7B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC;oBACrD,MAAM,IAAI,KAAK,CAAC,qDAAqD,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;gBACtF,CAAC;gBACD,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YAC1C,CAAC;YACD,MAAM,EAAE,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;YAC7B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;YAC7E,OAAO,UAAU,CAAe,GAAG,CAAC,CAAC;QACvC,CAAC;QAED,KAAK,CAAC,UAAU,CAAC,KAAK;YACpB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;YACvE,CAAC;YACD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,wBAAwB,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YAC/E,OAAO,UAAU,CAAoC,GAAG,CAAC,CAAC;QAC5D,CAAC;QAED,KAAK,CAAC,UAAU,CAAC,IAAI;YACnB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC9C,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;YACtE,CAAC;YACD,KAAK,MAAM,GAAG,IAAI,IAAI;gBAAE,UAAU,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;YACtD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,wBAAwB,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;YAC9E,OAAO,UAAU,CAAsB,GAAG,CAAC,CAAC;QAC9C,CAAC;QAED,KAAK,CAAC,UAAU,CAAC,KAAK;YACpB,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBACxC,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;YAClE,CAAC;YACD,WAAW,CAAC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YACvC,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;gBAC5B,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,GAAG;oBAAE,UAAU,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;YAC7D,CAAC;YACD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,sBAAsB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YACzE,MAAM,IAAI,GAAG,MAAM,UAAU,CAA2B,GAAG,CAAC,CAAC;YAC7D,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;QAED,KAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK;YACvB,UAAU,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;YAC5B,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC/D,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5B,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,KAAK;YAChB,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBACxC,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;YAC9D,CAAC;YACD,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YACnC,oBAAoB,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;YACnE,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;gBAAE,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YACjF,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;gBAC5B,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,GAAG;oBAAE,UAAU,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YACzD,CAAC;YACD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,kBAAkB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YACrE,MAAM,IAAI,GAAG,MAAM,UAAU,CAA0B,GAAG,CAAC,CAAC;YAC5D,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;QAED,KAAK,CAAC,YAAY,CAAC,KAAK;YACtB,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;gBAC3D,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;YACvE,CAAC;YACD,cAAc,CAAC,cAAc,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;YAC/C,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;gBAAE,iBAAiB,CAAC,cAAc,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YACvF,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;gBAC5B,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,GAAG;oBAAE,UAAU,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;YAC/D,CAAC;YACD,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS;gBAAE,UAAU,CAAC,cAAc,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;YACjF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,wBAAwB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YAC3E,MAAM,IAAI,GAAG,MAAM,UAAU,CAA2B,GAAG,CAAC,CAAC;YAC7D,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;KACF,CAAC;IAEF,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { sendWithAuthRetry } from '../http';\nimport type {\n  ContainingInput,\n  IntersectingInput,\n  NearbyInput,\n  Zone,\n  ZoneCreateInput,\n  ZoneCreateResult,\n  ZoneListOptions,\n  ZoneListPage,\n  ZoneNearby,\n  ZonePatchInput,\n  ZoneReplaceInput,\n  ZoneSummary,\n} from './schema';\n\nconst UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\nexport interface ZonesClient {\n  config(input: PlatformConfigInput): ZonesClient;\n  auth(input: PlatformAuthInput | PlatformAuth): ZonesClient;\n\n  /** POST /v1/zones - create a single zone. */\n  create(input: ZoneCreateInput): Promise<ZoneCreateResult>;\n  /** GET /v1/zones/{zid} - returns the full zone or throws ZonesApiError(404). */\n  get(zid: string): Promise<Zone>;\n  /** PATCH /v1/zones/{zid} - shallow tag merge; null deletes a key. */\n  update(zid: string, input: ZonePatchInput): Promise<Zone>;\n  /** PUT /v1/zones/{zid} - full replace of geometry + tags. */\n  replace(zid: string, input: ZoneReplaceInput): Promise<Zone>;\n  /** DELETE /v1/zones/{zid} - 404 if not present. */\n  delete(zid: string): Promise<void>;\n  /** GET /v1/zones?tags=... - tag-filtered, keyset-paginated listing. */\n  list(opts?: ZoneListOptions): Promise<ZoneListPage>;\n  /** POST /v1/zones/batch/create - bounded array; returned in input order. */\n  createMany(zones: readonly ZoneCreateInput[]): Promise<{ zones: Array<{ zid: string }> }>;\n  /** POST /v1/zones/batch/delete - returns the count actually deleted. */\n  deleteMany(zids: readonly string[]): Promise<{ deleted: number }>;\n\n  /** POST /v1/zones/containing - the spatial primitive. */\n  containing(input: ContainingInput): Promise<ZoneSummary[]>;\n  /** Sugar over containing({ point, ids: [zid] }). True iff the zone contains the point. */\n  contains(zid: string, point: ContainingInput['point']): Promise<boolean>;\n  /** POST /v1/zones/nearby - zones within `radiusMeters` of a point, ordered by distance asc. */\n  nearby(input: NearbyInput): Promise<ZoneNearby[]>;\n  /** POST /v1/zones/intersecting - zones whose geometry overlaps the given geometry. */\n  intersecting(input: IntersectingInput): Promise<ZoneSummary[]>;\n}\n\nexport class ZonesApiError extends Error {\n  readonly status: number;\n  readonly body: string;\n\n  constructor(status: number, body: string) {\n    super(`zones API ${status}: ${body}`);\n    this.name = 'ZonesApiError';\n    this.status = status;\n    this.body = body;\n  }\n}\n\nfunction assertUuid(label: string, zid: string): void {\n  if (typeof zid !== 'string' || !UUID_REGEX.test(zid)) {\n    throw new Error(`zones.${label}: zid must be a uuid (got ${JSON.stringify(zid)})`);\n  }\n}\n\nfunction assertPoint(label: string, point: { lat: number; lng: number }): void {\n  const lat = point?.lat;\n  const lng = point?.lng;\n  if (typeof lat !== 'number' || typeof lng !== 'number') {\n    throw new Error(`zones.${label}: point must be { lat: number, lng: number }`);\n  }\n  if (!Number.isFinite(lat) || lat < -90 || lat > 90) {\n    throw new Error(`zones.${label}: lat must be in [-90, 90] (got ${lat})`);\n  }\n  if (!Number.isFinite(lng) || lng < -180 || lng > 180) {\n    throw new Error(`zones.${label}: lng must be in [-180, 180] (got ${lng})`);\n  }\n}\n\nfunction assertGeometry(label: string, geometry: unknown): void {\n  const type = (geometry as { type?: unknown } | null | undefined)?.type;\n  if (type !== 'Polygon' && type !== 'MultiPolygon') {\n    throw new Error(\n      `zones.${label}: geometry.type must be Polygon or MultiPolygon (got ${JSON.stringify(type)})`,\n    );\n  }\n}\n\nfunction assertPositiveNumber(label: string, field: string, value: number): void {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {\n    throw new Error(`zones.${label}: ${field} must be a positive number (got ${value})`);\n  }\n}\n\nfunction assertPositiveInt(label: string, field: string, value: number): void {\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new Error(`zones.${label}: ${field} must be a positive integer (got ${value})`);\n  }\n}\n\n/**\n * Build the `zones` namespace.\n *\n * Shape and contract mirror {@link createBusinessClient} - lazy config\n * resolution via {@link ConfigState}, shared 401-retry via\n * {@link sendWithAuthRetry}, immutable per-call config; no globals.\n *\n * Writes (`create`, `update`, `replace`, `delete`, batch ops) require a\n * service-actor token. Reads (`get`, `list`, `containing`, `contains`)\n * accept either a service-actor or a user-actor token. The SDK does not\n * enforce this - the server returns 401/403 and we surface it as\n * {@link ZonesApiError}.\n */\nexport function createZonesClient(input: PlatformConfigInput = {}): ZonesClient {\n  const state = new ConfigState();\n  state.apply(input);\n\n  async function send(\n    method: string,\n    path: string,\n    query?: string,\n    body?: unknown,\n  ): Promise<Response> {\n    const config = state.resolve();\n    const url = `${config.baseUrl}${path}${query ?? ''}`;\n    const payload = body === undefined ? undefined : JSON.stringify(body);\n    return sendWithAuthRetry(config, { method, path, url, body: payload });\n  }\n\n  async function expectJson<T>(res: Response): Promise<T> {\n    if (!res.ok) throw new ZonesApiError(res.status, await res.text());\n    return (await res.json()) as T;\n  }\n\n  const client: ZonesClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n\n    async create(input) {\n      if (!input || typeof input !== 'object') {\n        throw new Error('zones.create: input must be an object with `geometry`');\n      }\n      const res = await send('POST', '/v1/zones', undefined, input);\n      return expectJson<ZoneCreateResult>(res);\n    },\n\n    async get(zid) {\n      assertUuid('get', zid);\n      const res = await send('GET', `/v1/zones/${zid}`);\n      return expectJson<Zone>(res);\n    },\n\n    async update(zid, input) {\n      assertUuid('update', zid);\n      const res = await send('PATCH', `/v1/zones/${zid}`, undefined, input);\n      return expectJson<Zone>(res);\n    },\n\n    async replace(zid, input) {\n      assertUuid('replace', zid);\n      const res = await send('PUT', `/v1/zones/${zid}`, undefined, input);\n      return expectJson<Zone>(res);\n    },\n\n    async delete(zid) {\n      assertUuid('delete', zid);\n      const res = await send('DELETE', `/v1/zones/${zid}`);\n      if (res.status === 204) return;\n      if (!res.ok) throw new ZonesApiError(res.status, await res.text());\n    },\n\n    async list(opts = {}) {\n      const params = new URLSearchParams();\n      if (opts.tags !== undefined) params.set('tags', JSON.stringify(opts.tags));\n      if (opts.cursor !== undefined) params.set('cursor', opts.cursor);\n      if (opts.limit !== undefined) {\n        if (!Number.isInteger(opts.limit) || opts.limit <= 0) {\n          throw new Error(`zones.list: limit must be a positive integer (got ${opts.limit})`);\n        }\n        params.set('limit', String(opts.limit));\n      }\n      const qs = params.toString();\n      const res = await send('GET', '/v1/zones', qs.length ? `?${qs}` : undefined);\n      return expectJson<ZoneListPage>(res);\n    },\n\n    async createMany(zones) {\n      if (!Array.isArray(zones) || zones.length === 0) {\n        throw new Error('zones.createMany: zones must be a non-empty array');\n      }\n      const res = await send('POST', '/v1/zones/batch/create', undefined, { zones });\n      return expectJson<{ zones: Array<{ zid: string }> }>(res);\n    },\n\n    async deleteMany(zids) {\n      if (!Array.isArray(zids) || zids.length === 0) {\n        throw new Error('zones.deleteMany: zids must be a non-empty array');\n      }\n      for (const zid of zids) assertUuid('deleteMany', zid);\n      const res = await send('POST', '/v1/zones/batch/delete', undefined, { zids });\n      return expectJson<{ deleted: number }>(res);\n    },\n\n    async containing(input) {\n      if (!input || typeof input !== 'object') {\n        throw new Error('zones.containing: input must include `point`');\n      }\n      assertPoint('containing', input.point);\n      if (input.ids !== undefined) {\n        for (const zid of input.ids) assertUuid('containing', zid);\n      }\n      const res = await send('POST', '/v1/zones/containing', undefined, input);\n      const body = await expectJson<{ zones: ZoneSummary[] }>(res);\n      return body.zones;\n    },\n\n    async contains(zid, point) {\n      assertUuid('contains', zid);\n      const matches = await client.containing({ point, ids: [zid] });\n      return matches.length > 0;\n    },\n\n    async nearby(input) {\n      if (!input || typeof input !== 'object') {\n        throw new Error('zones.nearby: input must include `point`');\n      }\n      assertPoint('nearby', input.point);\n      assertPositiveNumber('nearby', 'radiusMeters', input.radiusMeters);\n      if (input.limit !== undefined) assertPositiveInt('nearby', 'limit', input.limit);\n      if (input.ids !== undefined) {\n        for (const zid of input.ids) assertUuid('nearby', zid);\n      }\n      const res = await send('POST', '/v1/zones/nearby', undefined, input);\n      const body = await expectJson<{ zones: ZoneNearby[] }>(res);\n      return body.zones;\n    },\n\n    async intersecting(input) {\n      if (!input || typeof input !== 'object' || !input.geometry) {\n        throw new Error('zones.intersecting: input must include `geometry`');\n      }\n      assertGeometry('intersecting', input.geometry);\n      if (input.limit !== undefined) assertPositiveInt('intersecting', 'limit', input.limit);\n      if (input.ids !== undefined) {\n        for (const zid of input.ids) assertUuid('intersecting', zid);\n      }\n      if (input.excludeZid !== undefined) assertUuid('intersecting', input.excludeZid);\n      const res = await send('POST', '/v1/zones/intersecting', undefined, input);\n      const body = await expectJson<{ zones: ZoneSummary[] }>(res);\n      return body.zones;\n    },\n  };\n\n  return client;\n}\n"]}

package/dist/zones/schema.d.ts

@@ -63,6 +63,7 @@ export interface Zone {
     zid: string;
     geometry: GeoJsonMultiPolygon;
     tags: TagBag;
+    areaSqKm: number;
     createdAt: string;
     updatedAt: string;
 }
@@ -102,3 +103,23 @@ export interface ContainingInput {
     ids?: readonly string[];
     tags?: TagFilter;
 }
+export interface NearbyInput {
+    point: Point;
+    radiusMeters: number;
+    tags?: TagFilter;
+    ids?: readonly string[];
+    limit?: number;
+}
+/** The compact shape returned by `nearby`, with the distance from the query point. */
+export interface ZoneNearby {
+    zid: string;
+    tags: TagBag;
+    distanceMeters: number;
+}
+export interface IntersectingInput {
+    geometry: Geometry;
+    tags?: TagFilter;
+    ids?: readonly string[];
+    excludeZid?: string;
+    limit?: number;
+}

package/dist/zones/schema.js

@@ -13,4 +13,4 @@
  * order `[lng, lat]` per the GeoJSON spec.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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