@mono-labs/dev 0.1.251

package/dist/aws-event-synthesis/index.d.ts

@@ -0,0 +1,25 @@
+import type { Context as LambdaContext } from 'aws-lambda';
+import type { Response } from 'express';
+/** Flatten Node.js IncomingHttpHeaders to Record<string, string> */
+export declare function flattenHeaders(headers: Record<string, string | string[] | undefined>): Record<string, string>;
+/** Serialize a request body to string (passthrough if already string, JSON.stringify if object) */
+export declare function serializeBody(body: unknown): string | null;
+/** Convert Express parsed query to Record<string, string | undefined> */
+export declare function extractQueryParams(query: Record<string, unknown>): Record<string, string | undefined>;
+/** Split a URL into path and raw query string */
+export declare function splitUrl(originalUrl: string): {
+    path: string;
+    queryString: string;
+};
+/** Generate a local request ID */
+export declare function generateRequestId(): string;
+/** Create a minimal mock Lambda Context */
+export declare function createMockLambdaContext(functionName?: string): LambdaContext;
+/** Send a Lambda-style result (API Gateway V2 or ALB) back through Express */
+export declare function sendLambdaResult(res: Response, result: {
+    statusCode?: number;
+    headers?: Record<string, any>;
+    body?: string;
+    isBase64Encoded?: boolean;
+}): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/aws-event-synthesis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aws-event-synthesis/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,YAAY,CAAA;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAIvC,oEAAoE;AACpE,wBAAgB,cAAc,CAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,GACpD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOxB;AAED,mGAAmG;AACnG,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAI1D;AAED,yEAAyE;AACzE,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAOpC;AAED,iDAAiD;AACjD,wBAAgB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAOnF;AAID,kCAAkC;AAClC,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,2CAA2C;AAC3C,wBAAgB,uBAAuB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,aAAa,CAgB5E;AAID,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAC/B,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE;IACP,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,GACC,IAAI,CAeN"}

package/dist/aws-event-synthesis/index.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenHeaders = flattenHeaders;
+exports.serializeBody = serializeBody;
+exports.extractQueryParams = extractQueryParams;
+exports.splitUrl = splitUrl;
+exports.generateRequestId = generateRequestId;
+exports.createMockLambdaContext = createMockLambdaContext;
+exports.sendLambdaResult = sendLambdaResult;
+// --- Header utilities ---
+/** Flatten Node.js IncomingHttpHeaders to Record<string, string> */
+function flattenHeaders(headers) {
+    const flat = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value === 'string')
+            flat[key] = value;
+        else if (Array.isArray(value))
+            flat[key] = value.join(', ');
+    }
+    return flat;
+}
+/** Serialize a request body to string (passthrough if already string, JSON.stringify if object) */
+function serializeBody(body) {
+    if (body === undefined || body === null)
+        return null;
+    if (typeof body === 'string')
+        return body;
+    return JSON.stringify(body);
+}
+/** Convert Express parsed query to Record<string, string | undefined> */
+function extractQueryParams(query) {
+    const params = {};
+    for (const [key, value] of Object.entries(query)) {
+        if (typeof value === 'string')
+            params[key] = value;
+        else if (value !== undefined)
+            params[key] = String(value);
+    }
+    return params;
+}
+/** Split a URL into path and raw query string */
+function splitUrl(originalUrl) {
+    const qIndex = originalUrl.indexOf('?');
+    if (qIndex === -1)
+        return { path: originalUrl, queryString: '' };
+    return {
+        path: originalUrl.slice(0, qIndex),
+        queryString: originalUrl.slice(qIndex + 1),
+    };
+}
+// --- Mock Lambda context ---
+/** Generate a local request ID */
+function generateRequestId() {
+    return `local-${Date.now()}`;
+}
+/** Create a minimal mock Lambda Context */
+function createMockLambdaContext(functionName) {
+    const name = functionName ?? 'local-handler';
+    return {
+        callbackWaitsForEmptyEventLoop: true,
+        functionName: name,
+        functionVersion: '$LATEST',
+        invokedFunctionArn: `arn:aws:lambda:us-east-1:000000000000:function:${name}`,
+        memoryLimitInMB: '128',
+        awsRequestId: generateRequestId(),
+        logGroupName: `/aws/lambda/${name}`,
+        logStreamName: 'local',
+        getRemainingTimeInMillis: () => 30_000,
+        done: () => { },
+        fail: () => { },
+        succeed: () => { },
+    };
+}
+// --- Result -> Express response ---
+/** Send a Lambda-style result (API Gateway V2 or ALB) back through Express */
+function sendLambdaResult(res, result) {
+    const statusCode = result.statusCode ?? 200;
+    if (result.headers) {
+        for (const [key, value] of Object.entries(result.headers)) {
+            res.setHeader(key, value);
+        }
+    }
+    if (result.isBase64Encoded && result.body) {
+        const buffer = Buffer.from(result.body, 'base64');
+        res.status(statusCode).send(buffer);
+    }
+    else {
+        res.status(statusCode).send(result.body ?? '');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { LocalServer } from './local-server';
+export type { ApiGatewayHandler, ALBHandler, LocalServerConfig } from './local-server/types';
+export { attachSocketAdapter } from './websocket';
+export { ConnectionRegistry } from './websocket/connection-registry';
+export { ActionRouter } from './websocket/action-router';
+export { LocalGatewayClient } from './websocket/local-gateway-client';
+export type { ConnectionId, PostToConnectionFn, SocketAdapterConfig, ConnectHandlerFn, DisconnectHandlerFn, ActionHandler, ActionHandlerContext, ActionHandlerResult, LocalRequestContext, WebSocketUserContext, } from './websocket/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAG5F,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AACrE,YAAY,EACX,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,GACpB,MAAM,mBAAmB,CAAA"}

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalGatewayClient = exports.ActionRouter = exports.ConnectionRegistry = exports.attachSocketAdapter = exports.LocalServer = void 0;
+// Core
+var local_server_1 = require("./local-server");
+Object.defineProperty(exports, "LocalServer", { enumerable: true, get: function () { return local_server_1.LocalServer; } });
+// WebSocket
+var websocket_1 = require("./websocket");
+Object.defineProperty(exports, "attachSocketAdapter", { enumerable: true, get: function () { return websocket_1.attachSocketAdapter; } });
+var connection_registry_1 = require("./websocket/connection-registry");
+Object.defineProperty(exports, "ConnectionRegistry", { enumerable: true, get: function () { return connection_registry_1.ConnectionRegistry; } });
+var action_router_1 = require("./websocket/action-router");
+Object.defineProperty(exports, "ActionRouter", { enumerable: true, get: function () { return action_router_1.ActionRouter; } });
+var local_gateway_client_1 = require("./websocket/local-gateway-client");
+Object.defineProperty(exports, "LocalGatewayClient", { enumerable: true, get: function () { return local_gateway_client_1.LocalGatewayClient; } });

package/dist/local-server/event-synthesizer.d.ts

@@ -0,0 +1,7 @@
+import type { Request } from 'express';
+import type { APIGatewayProxyEventV2, ALBEvent } from 'aws-lambda';
+/** Synthesize an API Gateway V2 event from an Express request */
+export declare function synthesizeApiGatewayEvent(req: Request): APIGatewayProxyEventV2;
+/** Synthesize an ALB event from an Express request */
+export declare function synthesizeALBEvent(req: Request): ALBEvent;
+//# sourceMappingURL=event-synthesizer.d.ts.map

package/dist/local-server/event-synthesizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-synthesizer.d.ts","sourceRoot":"","sources":["../../src/local-server/event-synthesizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAUlE,iEAAiE;AACjE,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,sBAAsB,CAoC9E;AAED,sDAAsD;AACtD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,QAAQ,CAmBzD"}

package/dist/local-server/event-synthesizer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeApiGatewayEvent = synthesizeApiGatewayEvent;
+exports.synthesizeALBEvent = synthesizeALBEvent;
+const aws_event_synthesis_1 = require("../aws-event-synthesis");
+/** Synthesize an API Gateway V2 event from an Express request */
+function synthesizeApiGatewayEvent(req) {
+    const headers = (0, aws_event_synthesis_1.flattenHeaders)(req.headers);
+    const body = (0, aws_event_synthesis_1.serializeBody)(req.body);
+    const queryParams = (0, aws_event_synthesis_1.extractQueryParams)(req.query);
+    const { path, queryString } = (0, aws_event_synthesis_1.splitUrl)(req.originalUrl);
+    const requestId = (0, aws_event_synthesis_1.generateRequestId)();
+    const now = Date.now();
+    return {
+        version: '2.0',
+        routeKey: `$default`,
+        rawPath: path,
+        rawQueryString: queryString,
+        headers,
+        queryStringParameters: Object.keys(queryParams).length > 0 ? queryParams : undefined,
+        requestContext: {
+            accountId: 'local',
+            apiId: 'local',
+            domainName: req.hostname ?? 'localhost',
+            domainPrefix: 'local',
+            http: {
+                method: req.method,
+                path,
+                protocol: req.protocol ?? 'HTTP/1.1',
+                sourceIp: req.ip ?? '127.0.0.1',
+                userAgent: req.headers['user-agent'] ?? '',
+            },
+            requestId,
+            routeKey: '$default',
+            stage: 'local',
+            time: new Date(now).toISOString(),
+            timeEpoch: now,
+        },
+        body: body ?? undefined,
+        isBase64Encoded: false,
+    };
+}
+/** Synthesize an ALB event from an Express request */
+function synthesizeALBEvent(req) {
+    const headers = (0, aws_event_synthesis_1.flattenHeaders)(req.headers);
+    const body = (0, aws_event_synthesis_1.serializeBody)(req.body);
+    const queryParams = (0, aws_event_synthesis_1.extractQueryParams)(req.query);
+    const { path } = (0, aws_event_synthesis_1.splitUrl)(req.originalUrl);
+    return {
+        requestContext: {
+            elb: {
+                targetGroupArn: 'arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/local/local',
+            },
+        },
+        httpMethod: req.method,
+        path,
+        headers,
+        queryStringParameters: queryParams,
+        body: body ?? '',
+        isBase64Encoded: false,
+    };
+}

package/dist/local-server/index.d.ts

@@ -0,0 +1,17 @@
+import express from 'express';
+import type { attachSocketAdapter } from '../websocket';
+import type { SocketAdapterConfig } from '../websocket/types';
+import type { ApiGatewayHandler, ALBHandler, LambdaOptionsApiGateway, LambdaOptionsALB, LocalServerConfig } from './types';
+export type { ApiGatewayHandler, ALBHandler, LocalServerConfig } from './types';
+export declare class LocalServer {
+    readonly app: express.Express;
+    private httpServer;
+    private config;
+    constructor(config?: LocalServerConfig);
+    lambda(path: string, handler: ApiGatewayHandler): this;
+    lambda(path: string, handler: ApiGatewayHandler, options: LambdaOptionsApiGateway): this;
+    lambda(path: string, handler: ALBHandler, options: LambdaOptionsALB): this;
+    attachSocket(adapterFn: typeof attachSocketAdapter, config?: SocketAdapterConfig): ReturnType<typeof attachSocketAdapter>;
+    listen(port: number, hostname?: string): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/local-server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/local-server/index.ts"],"names":[],"mappings":"AAEA,OAAO,OAAO,MAAM,SAAS,CAAA;AAO7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,KAAK,EACX,iBAAiB,EACjB,UAAU,EACV,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,MAAM,SAAS,CAAA;AAEhB,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE/E,qBAAa,WAAW;IACvB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAA;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,MAAM,CAAmB;gBAErB,MAAM,CAAC,EAAE,iBAAiB;IAgBtC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI;IACtD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,uBAAuB,GAAG,IAAI;IACxF,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAgC1E,YAAY,CACX,SAAS,EAAE,OAAO,mBAAmB,EACrC,MAAM,CAAC,EAAE,mBAAmB,GAC1B,UAAU,CAAC,OAAO,mBAAmB,CAAC;IAKzC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;CAS7C"}

package/dist/local-server/index.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalServer = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const ws_1 = require("ws");
+const aws_event_synthesis_1 = require("../aws-event-synthesis");
+const event_synthesizer_1 = require("./event-synthesizer");
+class LocalServer {
+    app;
+    httpServer;
+    config;
+    constructor(config) {
+        this.config = config ?? {};
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.json());
+        this.app.use((0, cors_1.default)());
+        this.app.get('/', (_req, res) => {
+            res.send('Hello from Express HTTP Server');
+        });
+        this.httpServer = node_http_1.default.createServer(this.app);
+    }
+    lambda(path, handler, options) {
+        const eventType = options?.eventType ?? 'api-gateway';
+        this.app.use(path, async (req, res) => {
+            try {
+                const context = (0, aws_event_synthesis_1.createMockLambdaContext)();
+                if (eventType === 'alb') {
+                    const event = (0, event_synthesizer_1.synthesizeALBEvent)(req);
+                    const result = await handler(event, context);
+                    (0, aws_event_synthesis_1.sendLambdaResult)(res, result);
+                }
+                else {
+                    const event = (0, event_synthesizer_1.synthesizeApiGatewayEvent)(req);
+                    const result = await handler(event, context);
+                    (0, aws_event_synthesis_1.sendLambdaResult)(res, result ?? {});
+                }
+            }
+            catch (err) {
+                console.error(`[LocalServer] Error handling ${req.method} ${req.originalUrl}:`, err);
+                if (!res.headersSent) {
+                    res.status(500).json({ error: 'Internal Server Error' });
+                }
+            }
+        });
+        return this;
+    }
+    attachSocket(adapterFn, config) {
+        const wss = new ws_1.WebSocketServer({ server: this.httpServer });
+        return adapterFn(wss, config);
+    }
+    listen(port, hostname) {
+        const host = hostname ?? '0.0.0.0';
+        this.httpServer.listen(port, host, () => {
+            if (this.config.debug) {
+                console.info(`HTTP Server running at http://localhost:${port}`);
+                console.info(`WebSocket server running on ws://localhost:${port}`);
+            }
+        });
+    }
+}
+exports.LocalServer = LocalServer;

package/dist/local-server/types.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from 'aws-lambda';
+import type { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2, ALBEvent, ALBResult } from 'aws-lambda';
+export type ApiGatewayHandler = (event: APIGatewayProxyEventV2, context: Context) => Promise<APIGatewayProxyStructuredResultV2>;
+export type ALBHandler = (event: ALBEvent, context: Context) => Promise<ALBResult>;
+export interface LambdaOptionsApiGateway {
+    eventType?: 'api-gateway';
+}
+export interface LambdaOptionsALB {
+    eventType: 'alb';
+}
+export interface LocalServerConfig {
+    debug?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/local-server/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/local-server/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EACX,sBAAsB,EACtB,iCAAiC,EACjC,QAAQ,EACR,SAAS,EACT,MAAM,YAAY,CAAA;AAInB,MAAM,MAAM,iBAAiB,GAAG,CAC/B,KAAK,EAAE,sBAAsB,EAC7B,OAAO,EAAE,OAAO,KACZ,OAAO,CAAC,iCAAiC,CAAC,CAAA;AAE/C,MAAM,MAAM,UAAU,GAAG,CACxB,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,OAAO,KACZ,OAAO,CAAC,SAAS,CAAC,CAAA;AAIvB,MAAM,WAAW,uBAAuB;IACvC,SAAS,CAAC,EAAE,aAAa,CAAA;CACzB;AAED,MAAM,WAAW,gBAAgB;IAChC,SAAS,EAAE,KAAK,CAAA;CAChB;AAID,MAAM,WAAW,iBAAiB;IACjC,KAAK,CAAC,EAAE,OAAO,CAAA;CACf"}

package/dist/local-server/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/websocket/action-router.d.ts

@@ -0,0 +1,17 @@
+import type { ActionHandler, ActionHandlerResult, ConnectionId, LocalRequestContext, PostToConnectionFn } from './types';
+import type { WebSocketUserContext } from './types';
+/**
+ * Routes incoming WebSocket messages by `action` field — mirrors
+ * API Gateway's `$request.body.action` route selection.
+ */
+export declare class ActionRouter {
+    private routes;
+    private defaultHandler;
+    /** Register a handler for a specific action (equivalent to webSocketApi.addRoute()) */
+    addRoute(action: string, handler: ActionHandler): void;
+    /** Set the $default handler for unknown actions */
+    setDefaultHandler(handler: ActionHandler): void;
+    /** Parse incoming message JSON, extract `action`, and dispatch to the matching handler */
+    route(connectionId: ConnectionId, rawBody: string, postToConnection: PostToConnectionFn, requestContext: LocalRequestContext, userContext: WebSocketUserContext): Promise<ActionHandlerResult>;
+}
+//# sourceMappingURL=action-router.d.ts.map

package/dist/websocket/action-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-router.d.ts","sourceRoot":"","sources":["../../src/websocket/action-router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,aAAa,EAEb,mBAAmB,EACnB,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEnD;;;GAGG;AACH,qBAAa,YAAY;IACxB,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,cAAc,CAA6B;IAEnD,uFAAuF;IACvF,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAItD,mDAAmD;IACnD,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAI/C,0FAA0F;IACpF,KAAK,CACV,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,kBAAkB,EACpC,cAAc,EAAE,mBAAmB,EACnC,WAAW,EAAE,oBAAoB,GAC/B,OAAO,CAAC,mBAAmB,CAAC;CA8B/B"}

package/dist/websocket/action-router.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionRouter = void 0;
+/**
+ * Routes incoming WebSocket messages by `action` field — mirrors
+ * API Gateway's `$request.body.action` route selection.
+ */
+class ActionRouter {
+    routes = new Map();
+    defaultHandler = null;
+    /** Register a handler for a specific action (equivalent to webSocketApi.addRoute()) */
+    addRoute(action, handler) {
+        this.routes.set(action, handler);
+    }
+    /** Set the $default handler for unknown actions */
+    setDefaultHandler(handler) {
+        this.defaultHandler = handler;
+    }
+    /** Parse incoming message JSON, extract `action`, and dispatch to the matching handler */
+    async route(connectionId, rawBody, postToConnection, requestContext, userContext) {
+        let parsed;
+        try {
+            parsed = JSON.parse(rawBody);
+        }
+        catch {
+            return { statusCode: 400, body: JSON.stringify({ error: 'Invalid JSON' }) };
+        }
+        const action = parsed.action;
+        if (!action || typeof action !== 'string') {
+            return { statusCode: 400, body: JSON.stringify({ error: 'Missing "action" field' }) };
+        }
+        const handler = this.routes.get(action) ?? this.defaultHandler;
+        if (!handler) {
+            return {
+                statusCode: 400,
+                body: JSON.stringify({ error: `Unknown action: ${action}` }),
+            };
+        }
+        const ctx = {
+            connectionId,
+            requestContext: { ...requestContext, routeKey: action },
+            postToConnection,
+            userContext,
+        };
+        return handler(rawBody, ctx);
+    }
+}
+exports.ActionRouter = ActionRouter;

package/dist/websocket/connection-registry.d.ts

@@ -0,0 +1,28 @@
+import type { WebSocket } from 'ws';
+import type { ConnectionId } from './types';
+import type { WebSocketUserContext } from './types';
+/**
+ * In-memory connection registry — replaces API Gateway's built-in connection management.
+ * Maps connectionId → WebSocket instance and connectionId → user context.
+ */
+export declare class ConnectionRegistry {
+    private connections;
+    private userContexts;
+    /** Register a WebSocket and return its assigned connectionId */
+    register(ws: WebSocket): ConnectionId;
+    /** Remove a connection by ID */
+    unregister(connectionId: ConnectionId): void;
+    /** Look up a WebSocket by connectionId */
+    get(connectionId: ConnectionId): WebSocket | undefined;
+    /** Return all active connectionIds */
+    getAll(): ConnectionId[];
+    /** Store user context for a connection */
+    setUserContext(connectionId: ConnectionId, ctx: WebSocketUserContext): void;
+    /** Retrieve user context for a connection */
+    getUserContext(connectionId: ConnectionId): WebSocketUserContext | undefined;
+    /** Find all connectionIds belonging to a specific user */
+    getConnectionsByUserId(userId: string): ConnectionId[];
+    /** Find all connectionIds belonging to a specific organization */
+    getConnectionsByOrgId(orgId: string): ConnectionId[];
+}
+//# sourceMappingURL=connection-registry.d.ts.map

package/dist/websocket/connection-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-registry.d.ts","sourceRoot":"","sources":["../../src/websocket/connection-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAMnD;;;GAGG;AACH,qBAAa,kBAAkB;IAC9B,OAAO,CAAC,WAAW,CAAqC;IACxD,OAAO,CAAC,YAAY,CAAgD;IAEpE,gEAAgE;IAChE,QAAQ,CAAC,EAAE,EAAE,SAAS,GAAG,YAAY;IAMrC,gCAAgC;IAChC,UAAU,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;IAK5C,0CAA0C;IAC1C,GAAG,CAAC,YAAY,EAAE,YAAY,GAAG,SAAS,GAAG,SAAS;IAItD,sCAAsC;IACtC,MAAM,IAAI,YAAY,EAAE;IAIxB,0CAA0C;IAC1C,cAAc,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,EAAE,oBAAoB,GAAG,IAAI;IAI3E,6CAA6C;IAC7C,cAAc,CAAC,YAAY,EAAE,YAAY,GAAG,oBAAoB,GAAG,SAAS;IAI5E,0DAA0D;IAC1D,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE;IAQtD,kEAAkE;IAClE,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,EAAE;CAOpD"}

package/dist/websocket/connection-registry.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionRegistry = void 0;
+/** Generates a unique connection ID (same pattern as socket-real.ts) */
+const makeConnectionId = () => `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+/**
+ * In-memory connection registry — replaces API Gateway's built-in connection management.
+ * Maps connectionId → WebSocket instance and connectionId → user context.
+ */
+class ConnectionRegistry {
+    connections = new Map();
+    userContexts = new Map();
+    /** Register a WebSocket and return its assigned connectionId */
+    register(ws) {
+        const connectionId = makeConnectionId();
+        this.connections.set(connectionId, ws);
+        return connectionId;
+    }
+    /** Remove a connection by ID */
+    unregister(connectionId) {
+        this.connections.delete(connectionId);
+        this.userContexts.delete(connectionId);
+    }
+    /** Look up a WebSocket by connectionId */
+    get(connectionId) {
+        return this.connections.get(connectionId);
+    }
+    /** Return all active connectionIds */
+    getAll() {
+        return Array.from(this.connections.keys());
+    }
+    /** Store user context for a connection */
+    setUserContext(connectionId, ctx) {
+        this.userContexts.set(connectionId, ctx);
+    }
+    /** Retrieve user context for a connection */
+    getUserContext(connectionId) {
+        return this.userContexts.get(connectionId);
+    }
+    /** Find all connectionIds belonging to a specific user */
+    getConnectionsByUserId(userId) {
+        const result = [];
+        for (const [connId, ctx] of this.userContexts) {
+            if (ctx.userId === userId)
+                result.push(connId);
+        }
+        return result;
+    }
+    /** Find all connectionIds belonging to a specific organization */
+    getConnectionsByOrgId(orgId) {
+        const result = [];
+        for (const [connId, ctx] of this.userContexts) {
+            if (ctx.organizationId === orgId)
+                result.push(connId);
+        }
+        return result;
+    }
+}
+exports.ConnectionRegistry = ConnectionRegistry;

package/dist/websocket/event-synthesizer.d.ts

@@ -0,0 +1,24 @@
+import type { APIGatewayProxyEvent } from 'aws-lambda';
+import type http from 'node:http';
+import type { ConnectionId, LocalRequestContext } from './types';
+/** Synthesize a $connect event */
+export declare function synthesizeConnectEvent(connectionId: ConnectionId, req: http.IncomingMessage, config?: {
+    domainName?: string;
+    stage?: string;
+}): APIGatewayProxyEvent;
+/** Synthesize a $disconnect event */
+export declare function synthesizeDisconnectEvent(connectionId: ConnectionId, config?: {
+    domainName?: string;
+    stage?: string;
+}): APIGatewayProxyEvent;
+/** Synthesize a message event with body and routeKey */
+export declare function synthesizeMessageEvent(connectionId: ConnectionId, body: string, routeKey: string, config?: {
+    domainName?: string;
+    stage?: string;
+}): APIGatewayProxyEvent;
+/** Build a LocalRequestContext from parameters */
+export declare function buildRequestContext(connectionId: ConnectionId, routeKey: string, eventType: LocalRequestContext['eventType'], config?: {
+    domainName?: string;
+    stage?: string;
+}): LocalRequestContext;
+//# sourceMappingURL=event-synthesizer.d.ts.map

package/dist/websocket/event-synthesizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-synthesizer.d.ts","sourceRoot":"","sources":["../../src/websocket/event-synthesizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAyDhE,kCAAkC;AAClC,wBAAgB,sBAAsB,CACrC,YAAY,EAAE,YAAY,EAC1B,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,MAAM,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9C,oBAAoB,CAiBtB;AAED,qCAAqC;AACrC,wBAAgB,yBAAyB,CACxC,YAAY,EAAE,YAAY,EAC1B,MAAM,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9C,oBAAoB,CAQtB;AAED,wDAAwD;AACxD,wBAAgB,sBAAsB,CACrC,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9C,oBAAoB,CAWtB;AAED,kDAAkD;AAClD,wBAAgB,mBAAmB,CAClC,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,mBAAmB,CAAC,WAAW,CAAC,EAC3C,MAAM,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9C,mBAAmB,CAQrB"}

package/dist/websocket/event-synthesizer.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeConnectEvent = synthesizeConnectEvent;
+exports.synthesizeDisconnectEvent = synthesizeDisconnectEvent;
+exports.synthesizeMessageEvent = synthesizeMessageEvent;
+exports.buildRequestContext = buildRequestContext;
+const EMPTY_MULTI_VALUE = {};
+const EMPTY_HEADERS = {};
+/** Creates a minimal APIGatewayProxyEvent shell with the given requestContext fields */
+function baseEvent(requestContext, overrides) {
+    return {
+        body: null,
+        headers: EMPTY_HEADERS,
+        multiValueHeaders: EMPTY_MULTI_VALUE,
+        httpMethod: 'GET',
+        isBase64Encoded: false,
+        path: '',
+        pathParameters: null,
+        queryStringParameters: null,
+        multiValueQueryStringParameters: null,
+        stageVariables: null,
+        resource: '',
+        requestContext: {
+            accountId: 'local',
+            apiId: 'local',
+            authorizer: null,
+            protocol: 'websocket',
+            httpMethod: 'GET',
+            identity: {
+                accessKey: null,
+                accountId: null,
+                apiKey: null,
+                apiKeyId: null,
+                caller: null,
+                clientCert: null,
+                cognitoAuthenticationProvider: null,
+                cognitoAuthenticationType: null,
+                cognitoIdentityId: null,
+                cognitoIdentityPoolId: null,
+                principalOrgId: null,
+                sourceIp: '127.0.0.1',
+                user: null,
+                userAgent: null,
+                userArn: null,
+            },
+            path: '',
+            stage: 'local',
+            requestId: `local-${Date.now()}`,
+            requestTimeEpoch: Date.now(),
+            resourceId: '',
+            resourcePath: '',
+            ...requestContext,
+        },
+        ...overrides,
+    };
+}
+/** Synthesize a $connect event */
+function synthesizeConnectEvent(connectionId, req, config) {
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === 'string')
+            headers[key] = value;
+        else if (Array.isArray(value))
+            headers[key] = value.join(', ');
+    }
+    return baseEvent({
+        connectionId,
+        domainName: config?.domainName ?? 'localhost',
+        stage: config?.stage ?? 'local',
+        routeKey: '$connect',
+        eventType: 'CONNECT',
+    }, { headers });
+}
+/** Synthesize a $disconnect event */
+function synthesizeDisconnectEvent(connectionId, config) {
+    return baseEvent({
+        connectionId,
+        domainName: config?.domainName ?? 'localhost',
+        stage: config?.stage ?? 'local',
+        routeKey: '$disconnect',
+        eventType: 'DISCONNECT',
+    });
+}
+/** Synthesize a message event with body and routeKey */
+function synthesizeMessageEvent(connectionId, body, routeKey, config) {
+    return baseEvent({
+        connectionId,
+        domainName: config?.domainName ?? 'localhost',
+        stage: config?.stage ?? 'local',
+        routeKey,
+        eventType: 'MESSAGE',
+    }, { body });
+}
+/** Build a LocalRequestContext from parameters */
+function buildRequestContext(connectionId, routeKey, eventType, config) {
+    return {
+        connectionId,
+        domainName: config?.domainName ?? 'localhost',
+        stage: config?.stage ?? 'local',
+        routeKey,
+        eventType,
+    };
+}