@lostgradient/weft 0.2.0

package/dist/server/json-rpc-protocol.js

@@ -0,0 +1,27 @@
+export const JSON_RPC_VERSION = "2.0", JSON_RPC_ERROR_CODES = Object.freeze({
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  UNAUTHORIZED: -32010,
+  FORBIDDEN: -32011,
+  NOT_FOUND: -32020,
+  CONFLICT: -32021,
+  UNPROCESSABLE: -32022,
+  TIMEOUT: -32023,
+  RATE_LIMITED: -32024,
+  NOT_IMPLEMENTED: -32025,
+  UNSUPPORTED_TRANSPORT: -32030,
+  SUBSCRIPTION_OVERFLOW: -32031,
+  ENGINE_FAILURE: -32099
+});
+export function isValidJsonRpcId(value) {
+  if (value === null)
+    return !0;
+  if (typeof value === "string")
+    return !0;
+  if (typeof value === "number" && Number.isFinite(value))
+    return !0;
+  return !1;
+}

package/dist/server/json-rpc-transport-helpers.d.ts

@@ -0,0 +1,17 @@
+import type { Engine } from '../core/engine.ts';
+import type { AuthContext } from './authentication.ts';
+import type { WebSocketData } from './json-rpc-websocket-runtime.ts';
+import type { OperationRegistry } from './operation-catalog.ts';
+type WebSocketUpgradeServer = {
+    upgrade(request: Request, options: {
+        data: WebSocketData;
+    }): boolean;
+};
+export declare function finalizeWebSocketUpgrade(server: WebSocketUpgradeServer, request: Request, data: WebSocketData): Response | undefined;
+export declare function handleJsonRpcHttpRequestSafely(args: {
+    request: Request;
+    registry: OperationRegistry;
+    engine: Engine;
+    authContext: AuthContext | undefined;
+}): Promise<Response>;
+export {};

package/dist/server/json-rpc-transport-helpers.js

@@ -0,0 +1,26 @@
+import { authContextToPrincipal } from "./handler.js";
+import { handleJsonRpcHttpRequest } from "./json-rpc-http.js";
+export function finalizeWebSocketUpgrade(server, request, data) {
+  if (server.upgrade(request, { data }))
+    return;
+  return new Response("WebSocket upgrade failed", { status: 400 });
+}
+export async function handleJsonRpcHttpRequestSafely(args) {
+  try {
+    return await handleJsonRpcHttpRequest(args.request, {
+      registry: args.registry,
+      engine: args.engine,
+      principal: authContextToPrincipal(args.authContext)
+    });
+  } catch (error) {
+    console.error("Unhandled error in /jsonrpc", { error });
+    return new Response(JSON.stringify({
+      jsonrpc: "2.0",
+      error: { code: -32603, message: "Internal error" },
+      id: null
+    }), {
+      status: 500,
+      headers: { "content-type": "application/json", "cache-control": "no-store" }
+    });
+  }
+}

package/dist/server/json-rpc-websocket-runtime.d.ts

@@ -0,0 +1,37 @@
+import type { ServerWebSocket } from 'bun';
+import { type JsonRpcWebSocketSession } from './json-rpc-websocket.ts';
+import type { OperationRegistry } from './operation-catalog.ts';
+import { type Principal } from './principal.ts';
+import type { WorkflowEventFeed } from './workflow-event-feed.ts';
+export type ConnectionType = 'worker' | 'stream' | 'watch' | 'generic' | 'jsonrpc';
+export interface WebSocketData {
+    pathname: string;
+    connectionType: ConnectionType;
+    workflowId?: string;
+    resumeFrom?: number;
+    queue?: string;
+    workerId?: string;
+    workerRegistered?: boolean;
+    workerProtocolVersion?: number;
+    lastDeliveredSequence?: number;
+    replayInProgress?: boolean;
+    pendingStreamMessages?: Array<{
+        sequence: number;
+        message: string;
+    }>;
+    principal?: Principal;
+    jsonRpcSession?: JsonRpcWebSocketSession;
+}
+export declare function handleJsonRpcWebSocketMessage(ws: Pick<ServerWebSocket<WebSocketData>, 'data' | 'close'>, rawMessage: string | Buffer): void;
+export declare function openJsonRpcWebSocketSession(options: {
+    ws: Pick<ServerWebSocket<WebSocketData>, 'data' | 'send' | 'close'>;
+    registry: OperationRegistry;
+    engine: unknown;
+    feed: WorkflowEventFeed;
+    activeSessions: Set<JsonRpcWebSocketSession>;
+}): void;
+export declare function closeJsonRpcWebSocketSession(options: {
+    session: JsonRpcWebSocketSession | undefined;
+    activeSessions: Set<JsonRpcWebSocketSession>;
+}): void;
+export declare function closeJsonRpcSessionsForShutdown(activeSessions: Set<JsonRpcWebSocketSession>): Promise<void>;

package/dist/server/json-rpc-websocket-runtime.js

@@ -0,0 +1,51 @@
+import {
+  createJsonRpcWebSocketSession
+} from "./json-rpc-websocket.js";
+import { anonymousPrincipal } from "./principal.js";
+export function handleJsonRpcWebSocketMessage(ws, rawMessage) {
+  const session = ws.data.jsonRpcSession;
+  if (!session) {
+    console.error("[weft] /jsonrpc WS frame received with no session attached \u2014 closing");
+    ws.close(1011, "no jsonrpc session attached");
+    return;
+  }
+  const text = typeof rawMessage === "string" ? rawMessage : new TextDecoder().decode(rawMessage);
+  session.handleMessage(text).catch((error) => {
+    console.error("[weft] /jsonrpc WS message error", error);
+  });
+}
+export function openJsonRpcWebSocketSession(options) {
+  try {
+    const session = createJsonRpcWebSocketSession({
+      registry: options.registry,
+      engine: options.engine,
+      principal: options.ws.data.principal ?? anonymousPrincipal(),
+      emitter: { send: (message) => options.ws.send(message) },
+      feed: options.feed,
+      transport: "jsonRpcWebSocket"
+    });
+    options.ws.data.jsonRpcSession = session;
+    options.activeSessions.add(session);
+  } catch (error) {
+    console.error("[weft] /jsonrpc WS session construction failed", error);
+    options.ws.close(1011, "session construction failed");
+  }
+}
+export function closeJsonRpcWebSocketSession(options) {
+  const { session, activeSessions } = options;
+  if (!session)
+    return;
+  activeSessions.delete(session);
+  session.close().catch((error) => {
+    console.error("[weft] /jsonrpc WS session close error", error);
+  });
+}
+export async function closeJsonRpcSessionsForShutdown(activeSessions) {
+  const closes = [];
+  for (const session of activeSessions)
+    closes.push(session.close().catch((error) => {
+      console.error("[weft] /jsonrpc WS session close error during shutdown", error);
+    }));
+  activeSessions.clear();
+  await Promise.allSettled(closes);
+}

package/dist/server/json-rpc-websocket-validation.d.ts

@@ -0,0 +1,38 @@
+import { type JsonRpcId } from './json-rpc-protocol.ts';
+import type { Cursor, EventSelector } from './workflow-event-feed.ts';
+type JsonRpcErrorPayload = {
+    readonly code: number;
+    readonly message: string;
+    readonly data?: Record<string, unknown>;
+};
+export type SubscribeParamsValidation = {
+    readonly ok: true;
+    readonly workflowId: string;
+    readonly selector: EventSelector;
+    readonly fromCursor: Cursor | undefined;
+} | {
+    readonly ok: false;
+    readonly error: JsonRpcErrorPayload;
+};
+export type MessageFrameValidation = {
+    readonly ok: false;
+    readonly error: JsonRpcErrorPayload;
+    readonly id: null;
+} | {
+    readonly ok: true;
+    readonly parsed: Record<string, unknown>;
+    readonly method: unknown;
+    readonly id: JsonRpcId | undefined;
+    readonly params: Record<string, unknown> | undefined;
+    readonly hasRequestId: boolean;
+    readonly rawId: unknown;
+};
+export declare function validateSubscribeParams(params: Record<string, unknown> | undefined): SubscribeParamsValidation;
+export declare function validateMessageFrame(frame: string, maxFrameBytes: number): MessageFrameValidation;
+export declare function validateSessionPrimitiveFrame(frame: Extract<MessageFrameValidation, {
+    ok: true;
+}>): {
+    readonly error: JsonRpcErrorPayload;
+    readonly id: JsonRpcId | null;
+} | null;
+export {};

package/dist/server/json-rpc-websocket-validation.js

@@ -0,0 +1,96 @@
+import {
+  JSON_RPC_ERROR_CODES,
+  JSON_RPC_VERSION,
+  isValidJsonRpcId
+} from "./json-rpc-protocol.js";
+import { isPlainObject } from "./json-schema-utilities.js";
+export function validateSubscribeParams(params) {
+  const workflowId = params?.workflowId;
+  if (typeof workflowId !== "string" || workflowId.length === 0)
+    return invalidParams("params.workflowId must be a non-empty string");
+  const selector = params?.selector;
+  if (selector !== "events" && selector !== "tokens")
+    return invalidParams("params.selector must be 'events' or 'tokens'");
+  const fromCursor = params?.fromCursor;
+  if (fromCursor !== void 0 && typeof fromCursor !== "string")
+    return invalidParams("params.fromCursor must be a string when present");
+  return { ok: !0, workflowId, selector, fromCursor };
+}
+export function validateMessageFrame(frame, maxFrameBytes) {
+  if (Buffer.byteLength(frame, "utf8") > maxFrameBytes)
+    return {
+      ok: !1,
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: `frame size exceeds limit of ${maxFrameBytes} bytes`
+      },
+      id: null
+    };
+  let parsed;
+  try {
+    parsed = JSON.parse(frame);
+  } catch {
+    return {
+      ok: !1,
+      error: { code: JSON_RPC_ERROR_CODES.PARSE_ERROR, message: "Parse error" },
+      id: null
+    };
+  }
+  if (Array.isArray(parsed))
+    return {
+      ok: !1,
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: "batch frames are not supported over WebSocket"
+      },
+      id: null
+    };
+  if (!isPlainObject(parsed))
+    return {
+      ok: !1,
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: "request must be a JSON object"
+      },
+      id: null
+    };
+  const rawId = parsed.id, hasRequestId = Object.hasOwn(parsed, "id");
+  return {
+    ok: !0,
+    parsed,
+    method: parsed.method,
+    id: isValidJsonRpcId(rawId) ? rawId : void 0,
+    params: isPlainObject(parsed.params) ? parsed.params : void 0,
+    hasRequestId,
+    rawId
+  };
+}
+export function validateSessionPrimitiveFrame(frame) {
+  if (frame.parsed.jsonrpc !== JSON_RPC_VERSION)
+    return {
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: `jsonrpc field must be exactly "${JSON_RPC_VERSION}"`
+      },
+      id: frame.id ?? null
+    };
+  if (frame.hasRequestId && !isValidJsonRpcId(frame.rawId))
+    return {
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: "id must be a string, number, null, or absent"
+      },
+      id: null
+    };
+  return null;
+}
+function invalidParams(message) {
+  return {
+    ok: !1,
+    error: {
+      code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+      message,
+      data: { weftCode: "InvalidParams", httpStatus: 400 }
+    }
+  };
+}

package/dist/server/json-rpc-websocket.d.ts

@@ -0,0 +1,60 @@
+/**
+ * WebSocket JSON-RPC session adapter.
+ *
+ * Each `/jsonrpc` WebSocket connection gets one `JsonRpcWebSocketSession`
+ * that binds the authenticated principal at upgrade time and reuses it
+ * for every frame. The session:
+ *   - Parses incoming frames as single JSON-RPC requests (batches over
+ *     WS are rejected per Track 8 design decision 13).
+ *   - Dispatches `weft.workflows.subscribe` / `weft.workflows.unsubscribe`
+ *     as first-class session primitives against the `WorkflowEventFeed`.
+ *   - Delegates all other methods to the standard `dispatchJsonRpc`.
+ *   - Emits live envelopes as `weft.events.deliver` notifications keyed
+ *     by the assigned `subscriptionId`.
+ *   - Guarantees every active subscription is torn down on `close()`
+ *     (or socket disconnect at the transport layer).
+ */
+import { type OperationRegistry } from './operation-catalog.ts';
+import type { Principal } from './principal.ts';
+import type { WorkflowEventFeed } from './workflow-event-feed.ts';
+/** Emitter interface: any `send(string)`-shaped object. */
+export type JsonRpcWebSocketEmitter = {
+    send(message: string): void;
+};
+export type JsonRpcWebSocketSessionOptions = {
+    readonly registry: OperationRegistry;
+    readonly engine: unknown;
+    readonly principal: Principal;
+    readonly emitter: JsonRpcWebSocketEmitter;
+    readonly feed: WorkflowEventFeed;
+    /**
+     * Maximum concurrent subscriptions per session. Default 100 — a
+     * well-behaved client should never need more. Rejected `subscribe`
+     * requests above the cap return `InvalidRequest (-32600)` so clients
+     * can distinguish resource exhaustion from other failures.
+     */
+    readonly maxSubscriptions?: number;
+    /**
+     * Maximum size of a single incoming frame in bytes. Default 1 MB.
+     * Frames exceeding the limit are rejected with a parse error before
+     * `JSON.parse` touches the payload — a runaway producer cannot force
+     * an unbounded allocation inside the adapter.
+     */
+    readonly maxFrameBytes?: number;
+    /**
+     * Transport identity for the dispatcher's transport-availability
+     * check. Defaults to `'jsonRpcWebSocket'`. The stdio session reuses
+     * this factory but must pass `'jsonRpcStdio'` so operations with
+     * `transports.jsonRpcStdio: false` are rejected on stdio and,
+     * conversely, operations that are stdio-only aren't rejected just
+     * because they haven't been enabled for WS.
+     */
+    readonly transport?: 'jsonRpcHttp' | 'jsonRpcWebSocket' | 'jsonRpcStdio';
+};
+export type JsonRpcWebSocketSession = {
+    /** Process one incoming WS frame (UTF-8 text). */
+    handleMessage(frame: string): Promise<void>;
+    /** Tear down every active subscription and release resources. */
+    close(): Promise<void>;
+};
+export declare function createJsonRpcWebSocketSession(options: JsonRpcWebSocketSessionOptions): JsonRpcWebSocketSession;

package/dist/server/json-rpc-websocket.js

@@ -0,0 +1,268 @@
+import { faultToJsonRpcError } from "./fault-to-json-rpc.js";
+import { dispatchJsonRpc } from "./json-rpc-dispatch.js";
+import { JSON_RPC_ERROR_CODES, JSON_RPC_VERSION } from "./json-rpc-protocol.js";
+import {
+  validateMessageFrame,
+  validateSessionPrimitiveFrame,
+  validateSubscribeParams
+} from "./json-rpc-websocket-validation.js";
+import {
+  executeSubscription,
+  SubscriptionElementValidationError
+} from "./operation-catalog.js";
+import { workflowEventsSubscriptionOperation } from "./operations/workflow-events-subscription.js";
+const DEFAULT_MAX_SUBSCRIPTIONS = 100, DEFAULT_MAX_FRAME_BYTES = 1048576, SESSION_METHODS = {
+  SUBSCRIBE: "weft.workflows.subscribe",
+  UNSUBSCRIBE: "weft.workflows.unsubscribe",
+  DELIVER: "weft.events.deliver",
+  TERMINATED: "weft.events.terminated"
+}, WORKFLOW_EVENTS_OPERATION_NAME = "weft.workflows.events", WORKFLOW_EVENTS_SUBSCRIPTION_OPERATION = workflowEventsSubscriptionOperation;
+function withWorkflowEventsSubscriptionOperation(registry) {
+  if (registry.get(WORKFLOW_EVENTS_OPERATION_NAME) !== void 0)
+    return registry;
+  return {
+    get(name) {
+      if (name === WORKFLOW_EVENTS_OPERATION_NAME)
+        return WORKFLOW_EVENTS_SUBSCRIPTION_OPERATION;
+      return registry.get(name);
+    },
+    list() {
+      return [...registry.list(), WORKFLOW_EVENTS_SUBSCRIPTION_OPERATION];
+    }
+  };
+}
+export function createJsonRpcWebSocketSession(options) {
+  const { registry, engine, principal, emitter, feed } = options, subscriptionRegistry = withWorkflowEventsSubscriptionOperation(registry), maxSubscriptions = options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS, maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES, transport = options.transport ?? "jsonRpcWebSocket", subscriptions = new Map;
+  let emitterBroken = !1, disposed = !1;
+  function emit(message) {
+    if (disposed || emitterBroken)
+      return;
+    try {
+      emitter.send(JSON.stringify(message));
+    } catch {
+      emitterBroken = !0;
+    }
+  }
+  function shouldSuppressOutput() {
+    return disposed || emitterBroken;
+  }
+  function emitResponse(request, message) {
+    if (request.expectsResponse)
+      emit(message);
+  }
+  async function handleSubscribe(request, params) {
+    const validation = validateSubscribeParams(params);
+    if (!validation.ok) {
+      emitResponse(request, {
+        jsonrpc: JSON_RPC_VERSION,
+        error: validation.error,
+        id: request.id ?? null
+      });
+      return;
+    }
+    if (subscriptions.size >= maxSubscriptions) {
+      emitResponse(request, {
+        jsonrpc: JSON_RPC_VERSION,
+        error: {
+          code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+          message: `maximum concurrent subscriptions per session (${maxSubscriptions}) exceeded`,
+          data: {
+            weftCode: "Unprocessable",
+            httpStatus: 422,
+            reason: "per-session subscription cap exceeded"
+          }
+        },
+        id: request.id ?? null
+      });
+      return;
+    }
+    const controller = new AbortController, result = await executeSubscription("weft.workflows.events", {
+      workflowId: validation.workflowId,
+      selector: validation.selector,
+      ...validation.fromCursor === void 0 ? {} : { fromCursor: validation.fromCursor }
+    }, {
+      principal,
+      engine: { feed },
+      transport,
+      registry: subscriptionRegistry
+    });
+    if (!result.ok) {
+      const error = faultToJsonRpcError(result.fault);
+      emitResponse(request, {
+        jsonrpc: JSON_RPC_VERSION,
+        error: { code: error.code, message: error.message, data: error.data },
+        id: request.id ?? null
+      });
+      return;
+    }
+    const { envelope, iterable, close: closeSubscription } = result.value, { subscriptionId, cursor } = envelope;
+    emitResponse(request, {
+      jsonrpc: JSON_RPC_VERSION,
+      result: { subscriptionId, cursor },
+      id: request.id ?? null
+    });
+    const pump = pumpSubscriptionIterable(subscriptionId, iterable, controller.signal, closeSubscription);
+    subscriptions.set(subscriptionId, {
+      id: subscriptionId,
+      controller,
+      pump,
+      isTerminating: !1
+    });
+  }
+  async function pumpSubscriptionIterable(subscriptionId, iterable, signal, closeSubscription) {
+    let closeStarted = !1;
+    async function closeOnce() {
+      if (closeStarted)
+        return;
+      closeStarted = !0;
+      await closeSubscription();
+    }
+    const abortSubscription = () => {
+      closeOnce().catch(() => {});
+    };
+    signal.addEventListener("abort", abortSubscription, { once: !0 });
+    try {
+      for await (const envelope of iterable) {
+        if (signal.aborted) {
+          await closeOnce().catch(() => {});
+          break;
+        }
+        deliver(subscriptionId, envelope);
+      }
+      if (!signal.aborted && !shouldSuppressOutput())
+        emit({
+          jsonrpc: JSON_RPC_VERSION,
+          method: SESSION_METHODS.TERMINATED,
+          params: { subscriptionId, reason: "server-closed" }
+        });
+    } catch (error) {
+      if (!signal.aborted && !shouldSuppressOutput())
+        if (error instanceof SubscriptionElementValidationError)
+          emit({
+            jsonrpc: JSON_RPC_VERSION,
+            method: SESSION_METHODS.TERMINATED,
+            params: {
+              subscriptionId,
+              reason: "validation-failed",
+              fault: error.fault
+            }
+          });
+        else
+          emit({
+            jsonrpc: JSON_RPC_VERSION,
+            method: SESSION_METHODS.TERMINATED,
+            params: {
+              subscriptionId,
+              reason: "server-closed",
+              fault: { code: "EngineFailure", message: "internal error", data: {} }
+            }
+          });
+    } finally {
+      signal.removeEventListener("abort", abortSubscription);
+      await closeOnce().catch(() => {});
+      subscriptions.delete(subscriptionId);
+    }
+  }
+  function deliver(subscriptionId, envelope) {
+    emit({
+      jsonrpc: JSON_RPC_VERSION,
+      method: SESSION_METHODS.DELIVER,
+      params: { subscriptionId, envelope }
+    });
+  }
+  function handleUnsubscribe(request, params) {
+    const subscriptionId = params?.subscriptionId;
+    if (typeof subscriptionId !== "string") {
+      emitResponse(request, {
+        jsonrpc: JSON_RPC_VERSION,
+        error: {
+          code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+          message: "params.subscriptionId must be a string",
+          data: { weftCode: "InvalidParams", httpStatus: 400 }
+        },
+        id: request.id ?? null
+      });
+      return;
+    }
+    const active = subscriptions.get(subscriptionId);
+    if (!active || active.isTerminating) {
+      emitResponse(request, {
+        jsonrpc: JSON_RPC_VERSION,
+        error: {
+          code: JSON_RPC_ERROR_CODES.NOT_FOUND,
+          message: "subscription not found",
+          data: {
+            weftCode: "NotFound",
+            httpStatus: 404,
+            resource: "subscription",
+            identifier: subscriptionId
+          }
+        },
+        id: request.id ?? null
+      });
+      return;
+    }
+    active.isTerminating = !0;
+    active.controller.abort();
+    emitResponse(request, { jsonrpc: JSON_RPC_VERSION, result: {}, id: request.id ?? null });
+    emit({
+      jsonrpc: JSON_RPC_VERSION,
+      method: SESSION_METHODS.TERMINATED,
+      params: { subscriptionId, reason: "client-unsubscribed" }
+    });
+  }
+  async function handleMessage(frame) {
+    if (disposed || emitterBroken)
+      return;
+    const validation = validateMessageFrame(frame, maxFrameBytes);
+    if (!validation.ok) {
+      emit({
+        jsonrpc: JSON_RPC_VERSION,
+        error: validation.error,
+        id: validation.id
+      });
+      return;
+    }
+    if (validation.method === SESSION_METHODS.SUBSCRIBE || validation.method === SESSION_METHODS.UNSUBSCRIBE) {
+      const sessionPrimitiveError = validateSessionPrimitiveFrame(validation);
+      if (sessionPrimitiveError !== null) {
+        emit({
+          jsonrpc: JSON_RPC_VERSION,
+          error: sessionPrimitiveError.error,
+          id: sessionPrimitiveError.id
+        });
+        return;
+      }
+      const request = {
+        id: validation.id,
+        expectsResponse: validation.hasRequestId
+      };
+      if (validation.method === SESSION_METHODS.SUBSCRIBE)
+        await handleSubscribe(request, validation.params);
+      else
+        handleUnsubscribe(request, validation.params);
+      return;
+    }
+    const result = await dispatchJsonRpc(validation.parsed, {
+      registry,
+      engine,
+      principal,
+      transport
+    });
+    if (result.kind === "single")
+      emit(result.response);
+  }
+  async function close() {
+    if (disposed)
+      return;
+    disposed = !0;
+    const pending = [];
+    for (const sub of subscriptions.values()) {
+      sub.controller.abort();
+      pending.push(sub.pump.catch(() => {}));
+    }
+    subscriptions.clear();
+    await Promise.all(pending);
+  }
+  return { handleMessage, close };
+}

package/dist/server/json-schema-utilities.d.ts

@@ -0,0 +1,4 @@
+export declare function compareStrings(left: string, right: string): number;
+export declare function asPlainObject(value: unknown): Record<string, unknown>;
+export declare function normalizeJsonObject(value: unknown): Record<string, unknown>;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/server/json-schema-utilities.js

@@ -0,0 +1,16 @@
+import { canonicalJson } from "./openapi-canonical-json.js";
+export function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+export function asPlainObject(value) {
+  if (isPlainObject(value))
+    return value;
+  return {};
+}
+export function normalizeJsonObject(value) {
+  const parsed = JSON.parse(canonicalJson(value));
+  return asPlainObject(parsed);
+}
+export function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}