timeback-studio 0.1.0

package/dist/server/controllers/enrollment.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Enrollment Controller
+ *
+ * HTTP endpoints for enrolling and unenrolling students.
+ */
+import type { Context } from 'hono';
+import type { EnvVariables } from '../lib';
+/**
+ * POST /api/enrollments/enroll - Enroll a student in a class.
+ *
+ * Requires env middleware to set `client` context variable.
+ *
+ * @param c - Hono context with env variables
+ * @returns JSON response with enrollment result
+ */
+export declare function handleEnroll(c: Context<{
+    Variables: EnvVariables;
+}>): Promise<(Response & import("hono").TypedResponse<{
+    success: boolean;
+    enrollmentId?: string | undefined;
+    errors: {
+        code: import("../lib").StudioErrorCode;
+        message: string;
+        details?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | undefined;
+    }[];
+}, 200 | 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    errors: {
+        code: import("../lib").StudioErrorCode;
+        message: string;
+        details?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | undefined;
+    }[];
+}, 400, "json">)>;
+/**
+ * POST /api/enrollments/unenroll - Unenroll a student from a class.
+ *
+ * Requires env middleware to set `client` context variable.
+ *
+ * @param c - Hono context with env variables
+ * @returns JSON response with unenrollment result
+ */
+export declare function handleUnenroll(c: Context<{
+    Variables: EnvVariables;
+}>): Promise<(Response & import("hono").TypedResponse<{
+    success: boolean;
+    enrollmentId?: string | undefined;
+    errors: {
+        code: import("../lib").StudioErrorCode;
+        message: string;
+        details?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | undefined;
+    }[];
+}, 200 | 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    errors: {
+        code: import("../lib").StudioErrorCode;
+        message: string;
+        details?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | undefined;
+    }[];
+}, 400, "json">)>;
+/**
+ * POST /api/enrollments/reactivate - Reactivate a student enrollment.
+ *
+ * Requires env middleware to set `client` context variable.
+ *
+ * @param c - Hono context with env variables
+ * @returns JSON response with reactivation result
+ */
+export declare function handleReactivate(c: Context<{
+    Variables: EnvVariables;
+}>): Promise<(Response & import("hono").TypedResponse<{
+    success: boolean;
+    enrollmentId?: string | undefined;
+    errors: {
+        code: import("../lib").StudioErrorCode;
+        message: string;
+        details?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | undefined;
+    }[];
+}, 200 | 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    errors: {
+        code: import("../lib").StudioErrorCode;
+        message: string;
+        details?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | undefined;
+    }[];
+}, 400, "json">)>;
+//# sourceMappingURL=enrollment.d.ts.map

package/dist/server/controllers/enrollment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrollment.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/enrollment.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAa1C;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC;;;;;;;;;;;;;;;;;;;kBAezE;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC;;;;;;;;;;;;;;;;;;;kBAe3E;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC;;;;;;;;;;;;;;;;;;;kBAe7E"}

package/dist/server/controllers/events.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Events Controller
+ *
+ * HTTP endpoints for Caliper events (Activity and Time Spent).
+ * Provides both REST endpoint for initial fetch and SSE for real-time updates.
+ */
+import type { Context } from 'hono';
+import type { EnvVariables } from '../lib';
+/**
+ * GET /api/events - Returns recent Caliper events.
+ *
+ * Query parameters:
+ * - `limit`: Maximum events to return (see events.fetch config)
+ * - `since`: Delta sync - fetch events AFTER this ISO timestamp
+ * - `before`: Backward pagination - fetch events BEFORE this ISO timestamp
+ *
+ * @param c - Hono context with env variables
+ * @returns JSON response with events array
+ */
+export declare function handleEvents(c: Context<{
+    Variables: EnvVariables;
+}>): Promise<Response & import("hono").TypedResponse<{
+    events: {
+        id: number;
+        externalId: string;
+        sensor: string;
+        type: string;
+        profile?: string | undefined;
+        action: string;
+        eventTime: string;
+        sendTime: string;
+        updated_at: string | null;
+        created_at: string;
+        deleted_at: string | null;
+        actor: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        };
+        object: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        };
+        generated?: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        target?: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        referrer?: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        edApp?: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        group?: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        membership?: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        session?: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        federatedSession?: string | {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        extensions?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null | undefined;
+        clientAppId?: string | null | undefined;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
+/**
+ * GET /api/events/stream - SSE stream for real-time event updates.
+ *
+ * Polls for new events and pushes them to connected clients.
+ *
+ * @param c - Hono context with env variables
+ * @returns SSE stream
+ */
+export declare function handleEventsStream(c: Context<{
+    Variables: EnvVariables;
+}>): Response;
+//# sourceMappingURL=events.d.ts.map

package/dist/server/controllers/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/events.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAiB1C;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAYzE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC,YAqCzE"}

package/dist/server/controllers/index.d.ts

@@ -0,0 +1,7 @@
+export { handleBootstrap } from './bootstrap';
+export { handleEnroll, handleUnenroll, handleReactivate } from './enrollment';
+export { handleEvents, handleEventsStream } from './events';
+export { handleLive } from './live';
+export { handleStatus, handleStatusStream } from './status';
+export { handleStudentSearch } from './student-search';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/controllers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC7E,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/server/controllers/live.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Live Controller
+ *
+ * GET /api/live - Multiplexed SSE stream combining status and events.
+ *
+ * See LiveService for detailed documentation on how tick intervals work.
+ */
+import type { Context } from 'hono';
+import type { EnvVariables } from '../lib';
+/**
+ * GET /api/live - Multiplexed SSE stream for status and events.
+ *
+ * Combines status updates (on change) and event updates (every 30s) into
+ * a single SSE connection. Emits an array of LiveUpdate objects.
+ *
+ * @param c - Hono context with env variables
+ * @returns SSE stream
+ */
+export declare function handleLive(c: Context<{
+    Variables: EnvVariables;
+}>): Response;
+//# sourceMappingURL=live.d.ts.map

package/dist/server/controllers/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/live.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC,YAqBjE"}

package/dist/server/controllers/status.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Status Controller
+ *
+ * HTTP endpoints for server status and configuration.
+ * These routes don't require environment selection.
+ */
+import type { Context } from 'hono';
+import type { AppContext } from '../../config';
+/**
+ * GET /api/status - Returns server status and configuration.
+ *
+ * @param c - Hono context
+ * @param ctx - App context
+ * @returns JSON response with status and configuration
+ */
+export declare function handleStatus(c: Context, ctx: AppContext): Promise<(Response & import("hono").TypedResponse<{
+    config: {
+        name: string;
+        defaults?: {
+            courseCode?: string | undefined;
+            level?: string | undefined;
+            metadata?: {
+                courseType?: import("@timeback/types").CourseType | undefined;
+                isSupplemental?: boolean | undefined;
+                isCustom?: boolean | undefined;
+                publishStatus?: import("@timeback/types").PublishStatus | undefined;
+                contactEmail?: string | undefined;
+                primaryApp?: string | undefined;
+                goals?: {
+                    dailyXp?: number | undefined;
+                    dailyLessons?: number | undefined;
+                    dailyActiveMinutes?: number | undefined;
+                    dailyAccuracy?: number | undefined;
+                    dailyMasteredUnits?: number | undefined;
+                } | undefined;
+                metrics?: {
+                    totalXp?: number | undefined;
+                    totalLessons?: number | undefined;
+                    totalGrades?: number | undefined;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+        courses: {
+            courseCode?: string | undefined;
+            level?: string | undefined;
+            metadata?: {
+                courseType?: import("@timeback/types").CourseType | undefined;
+                isSupplemental?: boolean | undefined;
+                isCustom?: boolean | undefined;
+                publishStatus?: import("@timeback/types").PublishStatus | undefined;
+                contactEmail?: string | undefined;
+                primaryApp?: string | undefined;
+                goals?: {
+                    dailyXp?: number | undefined;
+                    dailyLessons?: number | undefined;
+                    dailyActiveMinutes?: number | undefined;
+                    dailyAccuracy?: number | undefined;
+                    dailyMasteredUnits?: number | undefined;
+                } | undefined;
+                metrics?: {
+                    totalXp?: number | undefined;
+                    totalLessons?: number | undefined;
+                    totalGrades?: number | undefined;
+                } | undefined;
+            } | undefined;
+            subject: import("@timeback/types").TimebackSubject;
+            grade: import("@timeback/types").TimebackGrade;
+            ids?: {
+                staging?: string | undefined;
+                production?: string | undefined;
+            } | null | undefined;
+        }[];
+        sensors?: string[] | undefined;
+        version: string;
+        path: string;
+        courseIds: {
+            production: string[];
+            staging: string[];
+        };
+    };
+    environment: import("../../config").StudioEnvironment;
+    configuredEnvironments: import("../../config").StudioEnvironment[];
+    hasEmail: boolean;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<null, 304, "body">)>;
+/**
+ * GET /api/status/stream - SSE stream for status updates.
+ *
+ * Sends current status immediately, then pushes updates only when changed.
+ *
+ * @param c - Hono context
+ * @param ctx - App context
+ * @returns SSE stream
+ */
+export declare function handleStatusStream(c: Context, ctx: AppContext): Response;
+//# sourceMappingURL=status.d.ts.map

package/dist/server/controllers/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/status.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mIAY7D;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,YAoB7D"}

package/dist/server/controllers/student-search.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Student Search Controller
+ *
+ * Thin HTTP layer - parses request, delegates to service, returns response.
+ */
+import type { Context } from 'hono';
+import type { EnvVariables } from '../lib';
+/**
+ * GET /api/students/search - Search students by name or email.
+ *
+ * Requires env middleware to set `env` and `client` context variables.
+ *
+ * Query parameters:
+ * - q: Search query (required, min 2 characters)
+ * - max: Maximum total results (optional, default 20, max 50)
+ *
+ * @param c - Hono context with env variables
+ * @returns JSON response with matching students
+ */
+export declare function handleStudentSearch(c: Context<{
+    Variables: EnvVariables;
+}>): Promise<Response & import("hono").TypedResponse<{
+    students: {
+        id: string;
+        name: string;
+        email: string;
+        givenName: string;
+        familyName: string;
+        grades: string[];
+    }[];
+    errors: {
+        code: import("../lib").StudioErrorCode;
+        message: string;
+        details?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | undefined;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
+//# sourceMappingURL=student-search.d.ts.map

package/dist/server/controllers/student-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"student-search.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/student-search.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC;;;;;;;;;;;;;;;;mEAiBhF"}

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+export { createApp } from './app';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA"}

package/dist/server/lib/context.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Service Context
+ *
+ * Aggregates all services into a single context that can be
+ * injected into route handlers via middleware.
+ */
+import type { ServiceContext, ServiceContextOptions } from './types';
+/**
+ * Creates a service context with all services initialized.
+ *
+ * @param options - Context options
+ * @returns Service context with all services
+ */
+export declare function createServiceContext(options: ServiceContextOptions): ServiceContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/server/lib/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/server/lib/context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpE;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAUnF"}

package/dist/server/lib/errors.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Studio API Errors
+ *
+ * Standardized error handling for the Studio API.
+ *
+ * ## Error Codes
+ *
+ * Codes follow the pattern: `RESOURCE_ACTION` (e.g., `COURSE_FETCH_FAILED`)
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * // Create an error
+ * const error = createStudioError('COURSE_FETCH_FAILED', 'Course not found', { courseId })
+ *
+ * // In services, collect errors
+ * const errors: StudioError[] = []
+ * errors.push(createStudioError('USER_FETCH_FAILED', 'User not found'))
+ *
+ * // Return in response
+ * return { data, errors }
+ * ```
+ */
+import type { StudioError, StudioErrorCode } from './types';
+/**
+ * Create a standardized Studio API error.
+ *
+ * @param code - Error code
+ * @param message - Human-readable message
+ * @param details - Optional additional context
+ * @returns Studio error object
+ */
+export declare function createStudioError(code: StudioErrorCode, message: string, details?: Record<string, unknown>): StudioError;
+/**
+ * Extract error message from an unknown error.
+ * @param error - Unknown error value
+ * @returns Error message string
+ */
+export declare function getErrorMessage(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/server/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/server/lib/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE3D;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,WAAW,CAEb;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAItD"}

package/dist/server/lib/index.d.ts

@@ -0,0 +1,8 @@
+export { createServiceContext } from './context';
+export { createStudioError, getErrorMessage } from './errors';
+export { createManager } from './manager';
+export { createEnvMiddleware } from './middleware';
+export { parseEnvironment } from './request';
+export { hashString, runSSE } from './sse';
+export type { EnvErrorResponse, EnvVariables, RunSSEOptions, ServiceContext, ServiceContextOptions, StudioError, StudioErrorCode, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAChD,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAE1C,YAAY,EACX,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,WAAW,EACX,eAAe,GACf,MAAM,SAAS,CAAA"}

package/dist/server/lib/manager.d.ts

@@ -0,0 +1,10 @@
+import { TimebackManager } from '@timeback/core';
+import type { CredentialEnvironment } from '@timeback/internal-cli-infra';
+import type { AppContext } from '../../config';
+/**
+ * Creates a TimebackManager with clients for all configured environments.
+ * @param ctx - App context with credentials
+ * @returns Manager with registered clients
+ */
+export declare function createManager(ctx: AppContext): TimebackManager<CredentialEnvironment>;
+//# sourceMappingURL=manager.d.ts.map

package/dist/server/lib/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../src/server/lib/manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAIhD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAA;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAI9C;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,eAAe,CAAC,qBAAqB,CAAC,CAmBrF"}

package/dist/server/lib/middleware.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Hono Middleware
+ *
+ * Shared middleware for route handlers.
+ */
+import type { TimebackManager } from '@timeback/core';
+import type { AppContext, Environment } from '../../config';
+import type { EnvVariables } from './types';
+/**
+ * Creates middleware that validates the X-Environment header and provides
+ * the Timeback client to route handlers.
+ *
+ * On success, sets `c.get('env')` and `c.get('client')` for use in handlers.
+ * On failure, returns a 400 response with standardized error format.
+ *
+ * @param ctx - Application context
+ * @param manager - Timeback manager instance
+ * @returns Hono middleware
+ */
+export declare function createEnvMiddleware(ctx: AppContext, manager: TimebackManager<Environment>): import("hono").MiddlewareHandler<{
+    Variables: EnvVariables;
+}, string, {}, Response>;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/server/lib/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/server/lib/middleware.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,KAAK,EAAoB,YAAY,EAAE,MAAM,SAAS,CAAA;AAI7D;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,eAAe,CAAC,WAAW,CAAC;;yBAgDzF"}

package/dist/server/lib/request.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Request Utilities
+ *
+ * Helpers for parsing and validating HTTP request data.
+ */
+import type { Context } from 'hono';
+import type { Environment } from '../../config';
+/**
+ * Parse and validate the environment from query parameter.
+ *
+ * While passing environment via an HTTP header (e.g. `X-Environment`) would typically be more idiomatic,
+ * we standardize on the query param `?environment=staging|production` to support SSE endpoints,
+ * since SSE (EventSource) does not allow custom headers.
+ *
+ * @param c - Hono context
+ * @returns Valid environment or null
+ */
+export declare function parseEnvironment(c: Context): Environment | null;
+//# sourceMappingURL=request.d.ts.map

package/dist/server/lib/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/server/lib/request.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAM/D"}

package/dist/server/lib/sse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * SSE (Server-Sent Events) Utilities
+ *
+ * Tick-based SSE streaming. Routes provide a `tick` function that returns
+ * data to send (or undefined to skip). The core handles connection lifecycle,
+ * heartbeats, and deduplication.
+ */
+import type { Context } from 'hono';
+import type { RunSSEOptions } from './types';
+/**
+ * Simple hash function for change detection.
+ * Used by routes for ETag generation and payload comparison.
+ *
+ * @param str - String to hash
+ * @returns Hash as a base-36 string
+ */
+export declare function hashString(str: string): string;
+/**
+ * Run an SSE stream with a tick-based emission model.
+ *
+ * @param c - Hono context
+ * @param options - Stream options
+ * @returns SSE response
+ */
+export declare function runSSE(c: Context, options: RunSSEOptions): Response;
+//# sourceMappingURL=sse.d.ts.map

package/dist/server/lib/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/server/lib/sse.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AA6C5C;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAMD;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,YA4ExD"}

package/dist/server/lib/types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Server Lib Types
+ */
+import type { TimebackClient } from '@timeback/core';
+import type { AppContext, Environment } from '../../config';
+import type { StudioError } from '../../types';
+import type { BootstrapService, EnrollmentService, EventsService, StatusService, StudentSearchService } from '../services';
+export type { StudioError, StudioErrorCode } from '../../types';
+/**
+ * Aggregated service context available to route handlers.
+ *
+ * Created once per request by the environment middleware.
+ */
+export interface ServiceContext {
+    bootstrap: BootstrapService;
+    enrollment: EnrollmentService;
+    events: EventsService;
+    status: StatusService;
+    studentSearch: StudentSearchService;
+}
+/**
+ * Options for creating a service context.
+ */
+export interface ServiceContextOptions {
+    /** Application context (for status service) */
+    appContext: AppContext;
+    /** Authenticated Timeback client */
+    client: TimebackClient;
+    /** Optional sensor URLs to scope event queries */
+    sensors?: string[];
+}
+/**
+ * Context variables set by the environment middleware.
+ */
+export interface EnvVariables {
+    env: Environment;
+    client: TimebackClient;
+    sensors: string[] | undefined;
+    services: ServiceContext;
+}
+/**
+ * Standardized error response for environment validation failures.
+ */
+export interface EnvErrorResponse {
+    success: false;
+    error: string;
+    errors: StudioError[];
+}
+/**
+ * Options for the tick-based SSE stream.
+ */
+export interface RunSSEOptions {
+    /** Event name to emit */
+    event: string;
+    /** Interval in ms between ticks (default: SSE_CHECK_INTERVAL_MS) */
+    intervalMs?: number;
+    /** Interval in ms between heartbeats (default: SSE_HEARTBEAT_INTERVAL_MS) */
+    heartbeatMs?: number;
+    /** Whether to call tick and emit immediately on connection (default: false) */
+    sendInitial?: boolean;
+    /** Return a string to emit, or undefined to skip this tick */
+    tick: () => Promise<string | undefined>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/server/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/server/lib/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EACX,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,MAAM,aAAa,CAAA;AAEpB,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAM/D;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B,SAAS,EAAE,gBAAgB,CAAA;IAC3B,UAAU,EAAE,iBAAiB,CAAA;IAC7B,MAAM,EAAE,aAAa,CAAA;IACrB,MAAM,EAAE,aAAa,CAAA;IACrB,aAAa,EAAE,oBAAoB,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC,+CAA+C;IAC/C,UAAU,EAAE,UAAU,CAAA;IACtB,oCAAoC;IACpC,MAAM,EAAE,cAAc,CAAA;IACtB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAClB;AAMD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,GAAG,EAAE,WAAW,CAAA;IAChB,MAAM,EAAE,cAAc,CAAA;IACtB,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;IAC7B,QAAQ,EAAE,cAAc,CAAA;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,KAAK,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,WAAW,EAAE,CAAA;CACrB;AAMD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,8DAA8D;IAC9D,IAAI,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CACvC"}