@aeroswarm/core 0.2.11 → 0.2.13

package/README.md

@@ -54,6 +54,27 @@ Both `FusedTrackEvent` and `AlertEvent` carry an optional `airportId` (ICAO code
 
 `positionSchema`, `velocitySchema`, `currentTrackSchema`, `streamEnvelopeSchema`, `sourceHeartbeatSchema`, `wsSubscribeSchema`, `apiSuccessSchema`, `apiErrorSchema`, `apiResponseSchema` + inferred input types (`CurrentTrackInput`, `WsSubscribeInput`, `StreamEnvelopeInput`).
 
+### `api` — one response format for every REST endpoint (`@aeroswarm/core/api`)
+
+So that a developer who adds an endpoint does not invent a new shape. The WebSocket has its own strict envelope (`streamEnvelopeSchema`); this is the REST counterpart, and its error has the same fields as the WS `stream.error` payload.
+
+```ts
+import { ok, fail, toResponse } from "@aeroswarm/core/api";
+
+return toResponse(ok(rows, { count: rows.length }));      // { ok: true, data: rows, meta: { serverTime, count } }
+return toResponse(fail("NOT_FOUND", "no such track"));    // 404 { ok: false, error: { code, message, recoverable } }
+```
+
+| | |
+|---|---|
+| Success | `{ "ok": true, "data": <T>, "meta": { "serverTime": 1730000000000, "count"?, "nextCursor"?, "truncated"? } }` |
+| Failure | `{ "ok": false, "error": { "code", "message", "recoverable", "details"? } }` |
+| Codes | `UNAUTHORIZED` 401, `FORBIDDEN` 403, `NOT_FOUND` 404, `BAD_REQUEST` 400, `CONFLICT` 409, `RATE_LIMITED` 429, `UNAVAILABLE` 503, `INTERNAL` 500. `recoverable` is true for the last three and for rate limits. A client must tolerate codes it does not know. |
+| Conventions | times are epoch milliseconds (as in the WS); positions are `{ lat, lon }` (arrays `[lon, lat]` only inside GeoJSON); ids are strings; lists page with `nextCursor` |
+| Older servers | an endpoint that existed before this format keeps its old shape unless the request asks for the envelope: `wantsEnvelope(url, headers)` is true for the header `x-aero-envelope: 1` (`ENVELOPE_HEADER`) or `?envelope=1`. `@aeroswarm/replay-server` does this. |
+
+Also exported: `statusFor(code)`, `codeForStatus(status)`, `API_ERROR_CODES`, and the schemas `apiResponseSchema(dataSchema)`, `apiSuccessSchema`, `apiErrorSchema`, `apiMetaSchema`. Checklist for a new endpoint: answer with `ok()` / `fail()`; for a new WS message type, add it to `streamEnvelopeSchema` (turn on `validateOutgoing` in `@aeroswarm/live-server` in your tests to catch a type that was not added).
+
 ### `config` — environment access
 
 | Export | Purpose |

package/dist/api/index.d.ts

@@ -0,0 +1,45 @@
+export { apiErrorSchema, apiMetaSchema, apiResponseSchema, apiSuccessSchema } from '../validation/index.js';
+import 'zod';
+
+declare const API_ERROR_CODES: readonly ["UNAUTHORIZED", "FORBIDDEN", "NOT_FOUND", "BAD_REQUEST", "CONFLICT", "RATE_LIMITED", "UNAVAILABLE", "INTERNAL"];
+type ApiErrorCode = (typeof API_ERROR_CODES)[number];
+interface ApiMeta {
+    serverTime: number;
+    count?: number;
+    nextCursor?: string;
+    truncated?: boolean;
+}
+interface ApiOk<T> {
+    ok: true;
+    data: T;
+    meta?: ApiMeta;
+}
+interface ApiErr {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        recoverable: boolean;
+        details?: unknown;
+    };
+}
+type ApiResponse<T> = ApiOk<T> | ApiErr;
+declare const statusFor: (code: ApiErrorCode) => number;
+/** The code for an HTTP status from a server that does not send one. */
+declare function codeForStatus(status: number): ApiErrorCode;
+/** `meta.serverTime` is always set; pass `count`, `nextCursor` or `truncated` for lists. */
+declare function ok<T>(data: T, meta?: Partial<ApiMeta>): ApiOk<T>;
+declare function fail(code: ApiErrorCode, message: string, details?: unknown): ApiErr;
+/** A standard `Response`: JSON, status 200 for success, `statusFor(code)` for a failure. */
+declare function toResponse(body: ApiOk<unknown> | ApiErr, status?: number): Response;
+/**
+ * Servers that existed before this format keep answering in their old shape unless the
+ * request asks for the envelope, so clients that were written against the old shape do
+ * not break. Ask with the header (or `?envelope=1`, for a plain browser request).
+ */
+declare const ENVELOPE_HEADER = "x-aero-envelope";
+declare function wantsEnvelope(url: URL, headers?: {
+    get(name: string): string | null;
+}): boolean;
+
+export { API_ERROR_CODES, type ApiErr, type ApiErrorCode, type ApiMeta, type ApiOk, type ApiResponse, ENVELOPE_HEADER, codeForStatus, fail, ok, statusFor, toResponse, wantsEnvelope };

package/dist/api/index.js

@@ -0,0 +1,75 @@
+import {
+  apiErrorSchema,
+  apiMetaSchema,
+  apiResponseSchema,
+  apiSuccessSchema
+} from "../chunk-7SUMR3X2.js";
+
+// src/api/index.ts
+var API_ERROR_CODES = [
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "NOT_FOUND",
+  "BAD_REQUEST",
+  "CONFLICT",
+  "RATE_LIMITED",
+  "UNAVAILABLE",
+  "INTERNAL"
+];
+var STATUS = {
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  BAD_REQUEST: 400,
+  CONFLICT: 409,
+  RATE_LIMITED: 429,
+  UNAVAILABLE: 503,
+  INTERNAL: 500
+};
+var RECOVERABLE = /* @__PURE__ */ new Set(["RATE_LIMITED", "UNAVAILABLE", "INTERNAL"]);
+var statusFor = (code) => STATUS[code];
+function codeForStatus(status) {
+  for (const code of API_ERROR_CODES) if (STATUS[code] === status) return code;
+  if (status >= 500) return "INTERNAL";
+  return "BAD_REQUEST";
+}
+function ok(data, meta = {}) {
+  return { ok: true, data, meta: { serverTime: Date.now(), ...meta } };
+}
+function fail(code, message, details) {
+  return {
+    ok: false,
+    error: {
+      code,
+      message,
+      recoverable: RECOVERABLE.has(code),
+      ...details !== void 0 && { details }
+    }
+  };
+}
+function toResponse(body, status) {
+  const code = body.ok ? void 0 : body.error.code;
+  const resolved = status ?? (body.ok ? 200 : (code && STATUS[code]) ?? 500);
+  return new Response(JSON.stringify(body), {
+    status: resolved,
+    headers: { "content-type": "application/json" }
+  });
+}
+var ENVELOPE_HEADER = "x-aero-envelope";
+function wantsEnvelope(url, headers) {
+  return url.searchParams.get("envelope") === "1" || headers?.get(ENVELOPE_HEADER) === "1";
+}
+export {
+  API_ERROR_CODES,
+  ENVELOPE_HEADER,
+  apiErrorSchema,
+  apiMetaSchema,
+  apiResponseSchema,
+  apiSuccessSchema,
+  codeForStatus,
+  fail,
+  ok,
+  statusFor,
+  toResponse,
+  wantsEnvelope
+};

package/dist/{chunk-ZYX6U3ZK.js → chunk-7SUMR3X2.js}

@@ -27,6 +27,10 @@ var flightPlanSummarySchema = z.object({
   status: z.enum(["filed", "delayed", "departed", "arrived", "cancelled"]),
   phase: z.enum(["ARRIVAL", "DEPARTURE", "OVERFLIGHT", "UNKNOWN"])
 });
+var dataSourceSchema = z.object({
+  sac: z.number().int().min(0).max(255),
+  sic: z.number().int().min(0).max(255)
+});
 var currentTrackSchema = z.object({
   trackId: z.string(),
   source: z.enum(["ADSB", "ASTERIX_CAT010", "ASTERIX_CAT011", "ASTERIX_CAT020", "ASTERIX_CAT021", "ASTERIX_CAT048", "ASTERIX_CAT062", "FUSED"]),
@@ -35,7 +39,12 @@ var currentTrackSchema = z.object({
   squawk: z.string().nullable(),
   targetType: z.enum(["aircraft", "vehicle", "unknown"]).optional(),
   vehicleFleet: z.number().optional(),
+  aircraftType: z.string().optional(),
+  wake: z.string().optional(),
+  route: z.object({ adep: z.string().optional(), ades: z.string().optional() }).optional(),
+  onGround: z.boolean().optional(),
   airportId: z.string().optional(),
+  dataSource: dataSourceSchema.optional(),
   lat: z.number().min(-90).max(90).nullable(),
   lon: z.number().min(-180).max(180).nullable(),
   altitudeFt: z.number().nullable(),
@@ -119,13 +128,26 @@ var wsUpdateFilterSchema = z.object({
   maxUpdateHz: z.number().min(1).max(60).optional(),
   maxTracks: z.number().int().min(1).max(1e4).nullable().optional()
 });
-var apiSuccessSchema = (dataSchema) => z.object({ ok: z.literal(true), data: dataSchema });
+var apiMetaSchema = z.object({
+  /** The server's clock when it answered (ms). */
+  serverTime: z.number(),
+  /** Number of items, for list responses. */
+  count: z.number().int().nonnegative().optional(),
+  /** Pass back to get the next page. */
+  nextCursor: z.string().optional(),
+  /** The server returned fewer items than matched (a `limit`, or thinning). */
+  truncated: z.boolean().optional()
+});
+var apiSuccessSchema = (dataSchema) => z.object({ ok: z.literal(true), data: dataSchema, meta: apiMetaSchema.optional() });
 var apiErrorSchema = z.object({
   ok: z.literal(false),
   error: z.object({
+    /** Stable machine-readable code, e.g. "NOT_FOUND". A client must tolerate codes it does not know. */
     code: z.string(),
     message: z.string(),
-    recoverable: z.boolean()
+    /** Retrying the same request later may succeed. Same field as the WS `stream.error` payload. */
+    recoverable: z.boolean(),
+    details: z.unknown().optional()
   })
 });
 var apiResponseSchema = (dataSchema) => z.union([apiSuccessSchema(dataSchema), apiErrorSchema]);
@@ -134,11 +156,13 @@ export {
   positionSchema,
   velocitySchema,
   flightPlanSummarySchema,
+  dataSourceSchema,
   currentTrackSchema,
   streamEnvelopeSchema,
   sourceHeartbeatSchema,
   wsSubscribeSchema,
   wsUpdateFilterSchema,
+  apiMetaSchema,
   apiSuccessSchema,
   apiErrorSchema,
   apiResponseSchema

package/dist/{chunk-J2UTSYKD.js → chunk-UROKN5FM.js}

@@ -83,7 +83,12 @@ function toCurrentTrack(fused, staleAfterMs = 15e3, lostAfterMs = 9e4) {
     squawk: fused.identity.squawk ?? null,
     ...fused.identity.targetType !== void 0 && { targetType: fused.identity.targetType },
     ...fused.identity.vehicleFleet !== void 0 && { vehicleFleet: fused.identity.vehicleFleet },
+    ...fused.identity.aircraftType !== void 0 && { aircraftType: fused.identity.aircraftType },
+    ...fused.identity.wake !== void 0 && { wake: fused.identity.wake },
+    ...fused.route !== void 0 && { route: fused.route },
+    ...fused.position?.onGround !== void 0 && { onGround: fused.position.onGround },
     ...fused.airportId !== void 0 && { airportId: fused.airportId },
+    ...fused.dataSource !== void 0 && { dataSource: fused.dataSource },
     lat: fused.position?.lat ?? null,
     lon: fused.position?.lon ?? null,
     altitudeFt: fused.position?.alt ?? null,

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { SourceHealthEvent, FusedTrackEvent } from './types/index.js';
-export { AeroConnectionStatus, AeroRecoverableError, AftnMessagePayload, AssignedRoute, Bbox, ConfidenceBudget, CurrentTrack, FlightPhase, FlightPlan, FlightPlanEvent, FlightPlanStatus, FlightPlanSummary, Position, Protocol, RouteAssignment, SourceStatus, StreamEnvelope, TargetType, TrackSource, TrackStatus, Velocity } from './types/index.js';
+export { AeroConnectionStatus, AeroRecoverableError, AftnMessagePayload, AssignedRoute, Bbox, ConfidenceBudget, CurrentTrack, DataSource, FlightPhase, FlightPlan, FlightPlanEvent, FlightPlanStatus, FlightPlanSummary, Position, Protocol, RouteAssignment, SourceStatus, StreamEnvelope, TargetDetails, TargetType, TrackSource, TrackStatus, Velocity } from './types/index.js';
 import { TopicName } from './utils/index.js';
 export { EMERGENCY_SQUAWKS, LOST_AFTER_MS, MACH1_KT, PolylineDistance, STALE_AFTER_MS, TOPICS, clamp, createEventId, createEventUid, createNanoid, createSessionId, createTrackId, distanceToPolylineM, haversineKm, isInsideBbox, isRenderableTrack, toCurrentTrack } from './utils/index.js';
 export { applyFlightPlanEvent, flightPhase, flightPlanId, normalizeCallsign, pickMatchingPlan, summarizeFlightPlan } from './flightplan/index.js';
-export { CurrentTrackInput, StreamEnvelopeInput, WsSubscribeInput, apiErrorSchema, apiResponseSchema, apiSuccessSchema, currentTrackSchema, flightPlanSummarySchema, positionSchema, sourceHeartbeatSchema, streamEnvelopeSchema, velocitySchema, wsSubscribeSchema, wsUpdateFilterSchema } from './validation/index.js';
+export { CurrentTrackInput, StreamEnvelopeInput, WsSubscribeInput, apiErrorSchema, apiMetaSchema, apiResponseSchema, apiSuccessSchema, currentTrackSchema, dataSourceSchema, flightPlanSummarySchema, positionSchema, sourceHeartbeatSchema, streamEnvelopeSchema, velocitySchema, wsSubscribeSchema, wsUpdateFilterSchema } from './validation/index.js';
 import pino, { Logger } from 'pino';
 import { Registry, Counter, Gauge } from 'prom-client';
 import { Redis } from 'ioredis';

package/dist/index.js

@@ -24,12 +24,14 @@ import {
   isInsideBbox,
   isRenderableTrack,
   toCurrentTrack
-} from "./chunk-J2UTSYKD.js";
+} from "./chunk-UROKN5FM.js";
 import {
   apiErrorSchema,
+  apiMetaSchema,
   apiResponseSchema,
   apiSuccessSchema,
   currentTrackSchema,
+  dataSourceSchema,
   flightPlanSummarySchema,
   positionSchema,
   sourceHeartbeatSchema,
@@ -37,7 +39,7 @@ import {
   velocitySchema,
   wsSubscribeSchema,
   wsUpdateFilterSchema
-} from "./chunk-ZYX6U3ZK.js";
+} from "./chunk-7SUMR3X2.js";
 
 // src/config/index.ts
 import { config } from "dotenv";
@@ -535,6 +537,7 @@ export {
   TOPICS,
   TOPIC_REGISTRY,
   apiErrorSchema,
+  apiMetaSchema,
   apiResponseSchema,
   apiSuccessSchema,
   applyFlightPlanEvent,
@@ -551,6 +554,7 @@ export {
   createSessionId,
   createTrackId,
   currentTrackSchema,
+  dataSourceSchema,
   deleteTrack,
   disconnectProducer,
   disconnectRedis,

package/dist/types/index.d.ts

@@ -22,6 +22,25 @@ type Protocol = "adsb" | "asterix-cat010" | "asterix-cat011" | "asterix-cat020"
 type Bbox = [minLon: number, minLat: number, maxLon: number, maxLat: number];
 /** Surface target classification (A-SMGCS CAT010/011). Absent for en-route tracks. */
 type TargetType = "aircraft" | "vehicle" | "unknown";
+/** ASTERIX Data Source Identifier (I010 / I020 / I021 / I048 ...): which sensor or ground
+ *  station reported a track, as System Area Code / System Identification Code (0-255 each). */
+interface DataSource {
+    sac: number;
+    sic: number;
+}
+/** Facts a sensor reports about a target besides its position and identity. All optional: a sensor sends what it has. */
+interface TargetDetails {
+    /** Track number the sensor assigned */
+    trackNumber?: number;
+    /** Time of the report as the sensor stamped it, seconds since midnight UTC */
+    timeOfDay?: number;
+    /** ADS-B emitter category (CAT021 ECAT) */
+    emitterCategory?: number;
+    /** Footprint of a surface target, metres, and the way it points, degrees */
+    lengthM?: number;
+    widthM?: number;
+    orientationDeg?: number;
+}
 interface FusedTrackEvent {
     trackId: string;
     sources: [string, ...string[]];
@@ -33,8 +52,21 @@ interface FusedTrackEvent {
         squawk?: string;
         targetType?: TargetType;
         vehicleFleet?: number;
+        /** ICAO aircraft type designator the surveillance system reports, e.g. "A320" (ASTERIX CAT062) */
+        aircraftType?: string;
+        /** Wake turbulence category L / M / H / J, as in `FlightPlan.wake` */
+        wake?: string;
     };
+    /** Departure and destination aerodromes the surveillance system reports for the flight (ICAO), named as in `FlightPlan`. */
+    route?: {
+        adep?: string;
+        ades?: string;
+    };
+    /** What the sensor reported about the target besides where it is (ASTERIX feeds). */
+    details?: TargetDetails;
     protocol: Protocol;
+    /** Sensor that reported this track (ASTERIX feeds only). For a merged track: the sensor whose position is shown. */
+    dataSource?: DataSource;
     position?: Position;
     velocity?: Velocity;
     confidence: ConfidenceBudget;
@@ -182,8 +214,20 @@ interface CurrentTrack {
     targetType?: TargetType;
     /** I010/300 Vehicle Fleet Identification code; only present when targetType is "vehicle" */
     vehicleFleet?: number;
+    /** Aircraft type and wake category the surveillance system reports (not the flight plan's: see `flightPlan`) */
+    aircraftType?: string;
+    wake?: string;
+    /** Departure and destination the surveillance system reports for the flight */
+    route?: {
+        adep?: string;
+        ades?: string;
+    };
+    /** On the ground as the sensor reports it; the airport backend may replace it with its own derived state */
+    onGround?: boolean;
     /** ICAO airport code this track is attributed to; undefined = unscoped */
     airportId?: string;
+    /** Sensor (SAC/SIC) that reported the position shown; ASTERIX feeds only */
+    dataSource?: DataSource;
     lat: number | null;
     lon: number | null;
     altitudeFt: number | null;
@@ -257,4 +301,4 @@ interface AeroRecoverableError {
 }
 type SourceStatus = SourceHealthEvent["status"];
 
-export type { AeroConnectionStatus, AeroRecoverableError, AftnMessagePayload, AssignedRoute, Bbox, ConfidenceBudget, CurrentTrack, FlightPhase, FlightPlan, FlightPlanEvent, FlightPlanStatus, FlightPlanSummary, FusedTrackEvent, Position, Protocol, RouteAssignment, SourceHealthEvent, SourceStatus, StreamEnvelope, TargetType, TrackSource, TrackStatus, Velocity };
+export type { AeroConnectionStatus, AeroRecoverableError, AftnMessagePayload, AssignedRoute, Bbox, ConfidenceBudget, CurrentTrack, DataSource, FlightPhase, FlightPlan, FlightPlanEvent, FlightPlanStatus, FlightPlanSummary, FusedTrackEvent, Position, Protocol, RouteAssignment, SourceHealthEvent, SourceStatus, StreamEnvelope, TargetDetails, TargetType, TrackSource, TrackStatus, Velocity };

package/dist/utils/index.js

@@ -15,7 +15,7 @@ import {
   isInsideBbox,
   isRenderableTrack,
   toCurrentTrack
-} from "../chunk-J2UTSYKD.js";
+} from "../chunk-UROKN5FM.js";
 export {
   EMERGENCY_SQUAWKS,
   LOST_AFTER_MS,

package/dist/validation/index.d.ts

@@ -42,6 +42,10 @@ declare const flightPlanSummarySchema: z.ZodObject<{
         UNKNOWN: "UNKNOWN";
     }>;
 }, z.core.$strip>;
+declare const dataSourceSchema: z.ZodObject<{
+    sac: z.ZodNumber;
+    sic: z.ZodNumber;
+}, z.core.$strip>;
 declare const currentTrackSchema: z.ZodObject<{
     trackId: z.ZodString;
     source: z.ZodEnum<{
@@ -63,7 +67,18 @@ declare const currentTrackSchema: z.ZodObject<{
         unknown: "unknown";
     }>>;
     vehicleFleet: z.ZodOptional<z.ZodNumber>;
+    aircraftType: z.ZodOptional<z.ZodString>;
+    wake: z.ZodOptional<z.ZodString>;
+    route: z.ZodOptional<z.ZodObject<{
+        adep: z.ZodOptional<z.ZodString>;
+        ades: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    onGround: z.ZodOptional<z.ZodBoolean>;
     airportId: z.ZodOptional<z.ZodString>;
+    dataSource: z.ZodOptional<z.ZodObject<{
+        sac: z.ZodNumber;
+        sic: z.ZodNumber;
+    }, z.core.$strip>>;
     lat: z.ZodNullable<z.ZodNumber>;
     lon: z.ZodNullable<z.ZodNumber>;
     altitudeFt: z.ZodNullable<z.ZodNumber>;
@@ -130,7 +145,18 @@ declare const streamEnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 unknown: "unknown";
             }>>;
             vehicleFleet: z.ZodOptional<z.ZodNumber>;
+            aircraftType: z.ZodOptional<z.ZodString>;
+            wake: z.ZodOptional<z.ZodString>;
+            route: z.ZodOptional<z.ZodObject<{
+                adep: z.ZodOptional<z.ZodString>;
+                ades: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            onGround: z.ZodOptional<z.ZodBoolean>;
             airportId: z.ZodOptional<z.ZodString>;
+            dataSource: z.ZodOptional<z.ZodObject<{
+                sac: z.ZodNumber;
+                sic: z.ZodNumber;
+            }, z.core.$strip>>;
             lat: z.ZodNullable<z.ZodNumber>;
             lon: z.ZodNullable<z.ZodNumber>;
             altitudeFt: z.ZodNullable<z.ZodNumber>;
@@ -198,7 +224,18 @@ declare const streamEnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 unknown: "unknown";
             }>>;
             vehicleFleet: z.ZodOptional<z.ZodNumber>;
+            aircraftType: z.ZodOptional<z.ZodString>;
+            wake: z.ZodOptional<z.ZodString>;
+            route: z.ZodOptional<z.ZodObject<{
+                adep: z.ZodOptional<z.ZodString>;
+                ades: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            onGround: z.ZodOptional<z.ZodBoolean>;
             airportId: z.ZodOptional<z.ZodString>;
+            dataSource: z.ZodOptional<z.ZodObject<{
+                sac: z.ZodNumber;
+                sic: z.ZodNumber;
+            }, z.core.$strip>>;
             lat: z.ZodNullable<z.ZodNumber>;
             lon: z.ZodNullable<z.ZodNumber>;
             altitudeFt: z.ZodNullable<z.ZodNumber>;
@@ -325,9 +362,22 @@ declare const wsUpdateFilterSchema: z.ZodObject<{
     maxUpdateHz: z.ZodOptional<z.ZodNumber>;
     maxTracks: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
+/** Rides along with a successful REST response. */
+declare const apiMetaSchema: z.ZodObject<{
+    serverTime: z.ZodNumber;
+    count: z.ZodOptional<z.ZodNumber>;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
 declare const apiSuccessSchema: <T extends z.ZodTypeAny>(dataSchema: T) => z.ZodObject<{
     ok: z.ZodLiteral<true>;
     data: T;
+    meta: z.ZodOptional<z.ZodObject<{
+        serverTime: z.ZodNumber;
+        count: z.ZodOptional<z.ZodNumber>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const apiErrorSchema: z.ZodObject<{
     ok: z.ZodLiteral<false>;
@@ -335,21 +385,29 @@ declare const apiErrorSchema: z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
         recoverable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 declare const apiResponseSchema: <T extends z.ZodTypeAny>(dataSchema: T) => z.ZodUnion<readonly [z.ZodObject<{
     ok: z.ZodLiteral<true>;
     data: T;
+    meta: z.ZodOptional<z.ZodObject<{
+        serverTime: z.ZodNumber;
+        count: z.ZodOptional<z.ZodNumber>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     ok: z.ZodLiteral<false>;
     error: z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
         recoverable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$strip>;
 }, z.core.$strip>]>;
 type CurrentTrackInput = z.infer<typeof currentTrackSchema>;
 type WsSubscribeInput = z.infer<typeof wsSubscribeSchema>;
 type StreamEnvelopeInput = z.infer<typeof streamEnvelopeSchema>;
 
-export { type CurrentTrackInput, type StreamEnvelopeInput, type WsSubscribeInput, apiErrorSchema, apiResponseSchema, apiSuccessSchema, currentTrackSchema, flightPlanSummarySchema, positionSchema, sourceHeartbeatSchema, streamEnvelopeSchema, velocitySchema, wsSubscribeSchema, wsUpdateFilterSchema };
+export { type CurrentTrackInput, type StreamEnvelopeInput, type WsSubscribeInput, apiErrorSchema, apiMetaSchema, apiResponseSchema, apiSuccessSchema, currentTrackSchema, dataSourceSchema, flightPlanSummarySchema, positionSchema, sourceHeartbeatSchema, streamEnvelopeSchema, velocitySchema, wsSubscribeSchema, wsUpdateFilterSchema };

package/dist/validation/index.js

@@ -1,8 +1,10 @@
 import {
   apiErrorSchema,
+  apiMetaSchema,
   apiResponseSchema,
   apiSuccessSchema,
   currentTrackSchema,
+  dataSourceSchema,
   flightPlanSummarySchema,
   positionSchema,
   sourceHeartbeatSchema,
@@ -10,12 +12,14 @@ import {
   velocitySchema,
   wsSubscribeSchema,
   wsUpdateFilterSchema
-} from "../chunk-ZYX6U3ZK.js";
+} from "../chunk-7SUMR3X2.js";
 export {
   apiErrorSchema,
+  apiMetaSchema,
   apiResponseSchema,
   apiSuccessSchema,
   currentTrackSchema,
+  dataSourceSchema,
   flightPlanSummarySchema,
   positionSchema,
   sourceHeartbeatSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeroswarm/core",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,6 +21,10 @@
       "import": "./dist/flightplan/index.js",
       "types": "./dist/flightplan/index.d.ts"
     },
+    "./api": {
+      "import": "./dist/api/index.js",
+      "types": "./dist/api/index.d.ts"
+    },
     "./types": {
       "import": "./dist/types/index.js",
       "types": "./dist/types/index.d.ts"
@@ -34,8 +38,8 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/utils/index.ts src/validation/index.ts src/types/index.ts src/flightplan/index.ts --format esm --clean --dts",
-    "dev": "tsup src/index.ts src/utils/index.ts src/validation/index.ts src/types/index.ts src/flightplan/index.ts --format esm --dts --watch",
+    "build": "tsup src/index.ts src/utils/index.ts src/validation/index.ts src/types/index.ts src/flightplan/index.ts src/api/index.ts --format esm --clean --dts",
+    "dev": "tsup src/index.ts src/utils/index.ts src/validation/index.ts src/types/index.ts src/flightplan/index.ts src/api/index.ts --format esm --dts --watch",
     "test": "vitest run --passWithNoTests",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",