@cosmicdrift/kumiko-types 0.327.0 → 0.328.0

package/dist/tz-context.js

@@ -0,0 +1,6 @@
+// TzContext — the type contract for ctx.tz (pure types; the factory lives in
+// @cosmicdrift/kumiko-framework, time/tz-context.ts).
+//
+// `Temporal` here is the ambient global from TypeScript's lib
+// (lib.esnext.temporal) — at runtime the framework installs the polyfill.
+export {};

package/dist/websocket-route.d.ts

@@ -0,0 +1,46 @@
+import type { Context } from "hono";
+import type { SessionUser, WriteResult } from "./handlers.js";
+export declare const WEBSOCKET_MAX_PAYLOAD_BYTES: number;
+export declare const WEBSOCKET_DEFAULT_MAX_MESSAGE_BYTES: number;
+export declare const WEBSOCKET_ROUTE_PATH_PREFIX = "/api/ws/";
+export declare const WEBSOCKET_BACKPRESSURE_LIMIT_BYTES: number;
+export declare const WEBSOCKET_DEFAULT_MAX_CONNECTIONS_PER_USER = 5;
+export declare const WEBSOCKET_MAX_CONNECTIONS_PER_USER_LIMIT = 100;
+export type WebSocketMessageData = string | Uint8Array;
+export type WebSocketConnection = {
+    readonly send: (data: WebSocketMessageData) => void;
+    readonly close: (code?: number, reason?: string) => void;
+    /**
+     * Aborts when the socket closes. onClose can run while onOpen/onMessage is
+     * still awaiting, so after any await that allocates (e.g. an upstream
+     * session), check `signal.aborted` and release it yourself.
+     */
+    readonly signal: AbortSignal;
+};
+export type WebSocketSessionHandlers = {
+    /** May still be awaiting when onClose runs; see `WebSocketConnection.signal`. */
+    readonly onOpen?: (connection: WebSocketConnection) => void | Promise<void>;
+    readonly onMessage?: (data: WebSocketMessageData, connection: WebSocketConnection) => void | Promise<void>;
+    /** Runs immediately on close, not queued behind a slow onMessage; pending messages never start after it. */
+    readonly onClose?: (code: number, reason: string, connection: WebSocketConnection) => void | Promise<void>;
+};
+export type WebSocketRouteConnectDeps = {
+    readonly user: SessionUser;
+    readonly query: (type: string, payload: unknown) => Promise<unknown>;
+    readonly write: (type: string, payload: unknown) => Promise<WriteResult>;
+    /** Resolved via the server's trustedProxyHops-aware resolver, like HttpRouteHandlerDeps.clientIp. */
+    readonly clientIp: string;
+};
+export type WebSocketRouteDefinition = {
+    /** Must start with "/api/ws/"; `:param` segments allowed, no "*". */
+    readonly path: string;
+    /** Per-message cap; oversized messages close the socket with 1009. Default 64 KiB, max 1 MiB. */
+    readonly maxMessageBytes?: number;
+    /** Concurrent sockets per user and tenant on this route (per server process). Default 5, max 100; above it the upgrade gets 429. */
+    readonly maxConnectionsPerUser?: number;
+    /**
+     * Runs after auth + origin checks, before the upgrade. Returning a Response rejects the upgrade with it.
+     * Allocate per-connection resources in `onOpen`, not here: if the upgrade then fails, no `onClose` runs.
+     */
+    readonly connect: (c: Context<any, any>, deps: WebSocketRouteConnectDeps) => WebSocketSessionHandlers | Response | Promise<WebSocketSessionHandlers | Response>;
+};

package/dist/websocket-route.js

@@ -0,0 +1,10 @@
+// WebSocket route definition — feature-declared WebSocket endpoints under
+// /api/ws/*. Auth (session + origin) runs before the upgrade; `connect`
+// then returns the per-connection handlers or a Response that rejects it.
+export const WEBSOCKET_MAX_PAYLOAD_BYTES = 1024 * 1024;
+export const WEBSOCKET_DEFAULT_MAX_MESSAGE_BYTES = 64 * 1024;
+export const WEBSOCKET_ROUTE_PATH_PREFIX = "/api/ws/";
+// Bun closes a socket whose unsent outbound queue exceeds this (slow or stalled reader).
+export const WEBSOCKET_BACKPRESSURE_LIMIT_BYTES = 4 * 1024 * 1024;
+export const WEBSOCKET_DEFAULT_MAX_CONNECTIONS_PER_USER = 5;
+export const WEBSOCKET_MAX_CONNECTIONS_PER_USER_LIMIT = 100;

package/dist/where-clause-types.d.ts

@@ -0,0 +1,20 @@
+export type WhereOperator = {
+    readonly gt?: unknown;
+    readonly gte?: unknown;
+    readonly lt?: unknown;
+    readonly lte?: unknown;
+    readonly ne?: unknown;
+    readonly in?: readonly unknown[];
+    readonly like?: string;
+};
+export type WherePrimitive = string | number | boolean | bigint | Date | null | undefined;
+export type WhereValue = WherePrimitive | readonly WherePrimitive[] | WhereOperator;
+export type WhereObject = Record<string, WhereValue | unknown>;
+export type OrderByClause = {
+    readonly col: string;
+    readonly direction?: "asc" | "desc";
+};
+export type SelectOptions = {
+    readonly limit?: number;
+    readonly orderBy?: OrderByClause | readonly OrderByClause[];
+};

package/dist/where-clause-types.js

@@ -0,0 +1 @@
+export {};

package/dist/workspace.d.ts

@@ -0,0 +1,10 @@
+import type { AccessRule } from "./handlers.js";
+export type WorkspaceDefinition = {
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: string;
+    readonly order?: number;
+    readonly access?: AccessRule;
+    readonly nav?: readonly string[];
+    readonly default?: boolean;
+};

package/dist/workspace.js

@@ -0,0 +1 @@
+export {};

package/dist/write-error-info-types.d.ts

@@ -0,0 +1,12 @@
+export type WriteErrorInfo = {
+    readonly code: string;
+    readonly httpStatus: number;
+    readonly i18nKey: string;
+    readonly i18nParams?: Readonly<Record<string, unknown>>;
+    readonly message: string;
+    readonly details?: unknown;
+};
+export type WriteFailure = {
+    readonly isSuccess: false;
+    readonly error: WriteErrorInfo;
+};

package/dist/write-error-info-types.js

@@ -0,0 +1 @@
+export {};