timeback-studio 0.1.6 → 0.1.8

package/dist/index.js

@@ -14744,13 +14744,14 @@ async function validateEmailWithTimeback(environment, clientId, clientSecret, em
     if (page.data.length === 0) {
       return {
         valid: false,
+        reason: "not_found",
         error: `No user found with email "${email3}" in ${environment}`
       };
     }
     return { valid: true };
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : "Unknown error";
-    return { valid: false, error: `Failed to validate email: ${message}` };
+    return { valid: false, reason: "api_error", error: `Failed to validate email: ${message}` };
   }
 }
 
@@ -15052,6 +15053,8 @@ var ActivityCompletedInput = exports_external.object({
   metricsId: exports_external.string().optional(),
   id: exports_external.string().optional(),
   extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  edApp: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
+  session: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
   attempt: exports_external.number().int().min(1).optional(),
   generatedExtensions: exports_external.object({
     pctCompleteApp: exports_external.number().optional()
@@ -15064,7 +15067,9 @@ var TimeSpentInput = exports_external.object({
   eventTime: IsoDateTimeString.optional(),
   metricsId: exports_external.string().optional(),
   id: exports_external.string().optional(),
-  extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  edApp: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
+  session: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional()
 }).strict();
 var TimebackEvent = exports_external.union([TimebackActivityEvent, TimebackTimeSpentEvent]);
 var CaliperEnvelope = exports_external.object({
@@ -15254,7 +15259,7 @@ var TimebackConfig = exports_external.object({
   path: ["courses"]
 });
 // ../types/src/zod/edubridge.ts
-var EdubridgeDateString = IsoDateTimeString;
+var EdubridgeDateString = exports_external.union([IsoDateTimeString, IsoDateString]);
 var EduBridgeEnrollment = exports_external.object({
   id: exports_external.string(),
   role: exports_external.string(),
@@ -17540,6 +17545,184 @@ async function addCredentials(options = {}) {
   if (exitOnComplete)
     process.exit(0);
 }
+// src/cli/commands/credentials/create-account.ts
+import { randomUUID } from "node:crypto";
+import { TimebackClient as TimebackClient3 } from "@timeback/core";
+async function promptName(label) {
+  const value = await he({
+    message: label,
+    placeholder: "Enter name",
+    validate: (v2) => {
+      if (!v2?.trim())
+        return `${label} is required`;
+    }
+  });
+  if (isCancelled(value))
+    return null;
+  return value.trim();
+}
+async function searchOrganizations(client, query) {
+  const allOrgs = await client.oneroster.orgs.listAll({
+    where: { status: "active" },
+    max: 100
+  });
+  if (!query.trim())
+    return allOrgs;
+  const lowerQuery = query.toLowerCase().trim();
+  return allOrgs.filter((org) => org.name?.toLowerCase().includes(lowerQuery));
+}
+async function searchForOrganization(client) {
+  const query = await he({
+    message: "Search for organization",
+    placeholder: "Enter organization name to search"
+  });
+  if (isCancelled(query))
+    return null;
+  const s = Y2();
+  s.start("Searching organizations...");
+  let results;
+  try {
+    results = await searchOrganizations(client, query);
+    s.stop(green(`Found ${results.length} result${results.length === 1 ? "" : "s"}`));
+  } catch (error48) {
+    s.stop(red("Failed to search organizations"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+  if (results.length === 0) {
+    M2.warn("No organizations found matching your search");
+    return promptOrganization(client);
+  }
+  const validResults = results.filter((org) => org.sourcedId);
+  if (validResults.length === 0) {
+    M2.warn("No valid organizations found (missing IDs)");
+    return promptOrganization(client);
+  }
+  const options = validResults.map((org) => ({
+    value: org.sourcedId,
+    label: org.name ?? "Unnamed Organization"
+  }));
+  options.push({ value: "__back__", label: `${dim("←")} Back to options` });
+  const selection = await ve({
+    message: "Select an organization",
+    options
+  });
+  if (isCancelled(selection))
+    return null;
+  if (selection === "__back__") {
+    return promptOrganization(client);
+  }
+  return validResults.find((org) => org.sourcedId === selection) ?? null;
+}
+async function promptOrganization(client) {
+  const action = await ve({
+    message: "Organization",
+    options: [
+      { value: "search", label: "Search for existing organization" },
+      { value: "create", label: "Create new organization" }
+    ]
+  });
+  if (isCancelled(action))
+    return null;
+  if (action === "create") {
+    return createNewOrganization(client);
+  }
+  return searchForOrganization(client);
+}
+async function createNewOrganization(client) {
+  const name = await he({
+    message: "Organization name",
+    placeholder: "Enter organization name",
+    validate: (v2) => {
+      if (!v2?.trim())
+        return "Organization name is required";
+    }
+  });
+  if (isCancelled(name))
+    return null;
+  const s = Y2();
+  s.start("Creating organization...");
+  const sourcedId = randomUUID();
+  try {
+    await client.oneroster.orgs.create({
+      sourcedId,
+      name: name.trim(),
+      type: "school",
+      status: "active"
+    });
+    const organization = await client.oneroster.orgs.get(sourcedId);
+    s.stop(green(`Organization "${name}" created`));
+    return organization;
+  } catch (error48) {
+    s.stop(red("Failed to create organization"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+}
+async function createUser(client, email3, givenName, familyName, organizationId) {
+  const s = Y2();
+  s.start("Creating account...");
+  const sourcedId = randomUUID();
+  try {
+    await client.oneroster.users.create({
+      sourcedId,
+      givenName,
+      familyName,
+      email: email3.toLowerCase(),
+      enabledUser: true,
+      status: "active",
+      roles: [
+        {
+          roleType: "primary",
+          role: "administrator",
+          org: { sourcedId: organizationId }
+        }
+      ]
+    });
+    const user = await client.oneroster.users.get(sourcedId);
+    s.stop(green("Account created successfully"));
+    return user;
+  } catch (error48) {
+    s.stop(red("Failed to create account"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+}
+async function createAccountFlow(options) {
+  const { environment, clientId, clientSecret, email: email3 } = options;
+  M2.info("");
+  M2.info(`No account found for ${dim(email3)} in ${environment}`);
+  const shouldCreate = await ye({
+    message: "Would you like to create a new account?",
+    initialValue: true
+  });
+  if (isCancelled(shouldCreate)) {
+    return { success: false };
+  }
+  if (!shouldCreate) {
+    return { success: false, declined: true };
+  }
+  const client = new TimebackClient3({
+    env: environment,
+    auth: { clientId, clientSecret }
+  });
+  const givenName = await promptName("First name");
+  if (!givenName)
+    return { success: false };
+  const familyName = await promptName("Last name");
+  if (!familyName)
+    return { success: false };
+  const organization = await promptOrganization(client);
+  if (!organization?.sourcedId)
+    return { success: false };
+  const user = await createUser(client, email3, givenName, familyName, organization.sourcedId);
+  if (!user) {
+    return { success: false };
+  }
+  M2.success(`Account created for ${user.givenName} ${user.familyName}`);
+  return { success: true };
+}
+
 // src/cli/commands/credentials/email.ts
 async function updateEmail(options = {}) {
   const { exitOnComplete = true, inline = false } = options;
@@ -17608,32 +17791,58 @@ async function updateEmail(options = {}) {
     return;
   }
   const emailUnchanged = email3 === (currentEmail ?? "");
-  if (emailUnchanged) {
-    if (!inline)
-      outro.info("Email unchanged");
-    if (exitOnComplete)
-      process.exit(0);
-    return;
-  }
   if (email3) {
     const s = Y2();
-    s.start("Validating email...");
+    s.start("Checking account...");
     const result = await validateEmailWithTimeback(targetEnv, currentCreds.clientId, currentCreds.clientSecret, email3);
     if (!result.valid) {
-      s.stop(red("Email validation failed"));
-      M2.error(result.error ?? "Unknown error");
-      M2.info("Please contact a Timeback admin to set up your account.");
+      if (result.reason !== "not_found") {
+        s.stop(red("Account check failed"));
+        M2.error(result.error ?? "Unknown error");
+        if (!inline)
+          outro.error("Account check failed");
+        if (exitOnComplete)
+          process.exit(1);
+        return;
+      }
+      s.stop(red("No account found"));
+      const { success: accountCreated, declined } = await createAccountFlow({
+        environment: targetEnv,
+        clientId: currentCreds.clientId,
+        clientSecret: currentCreds.clientSecret,
+        email: email3
+      });
+      if (!emailUnchanged) {
+        await saveCredentials(targetEnv, {
+          ...currentCreds,
+          email: email3
+        });
+        M2.success(`Email saved for ${targetEnv}`);
+      }
+      if (!inline) {
+        if (accountCreated || declined) {
+          outro.success();
+        } else {
+          outro.info("Setup incomplete - run this command again to finish");
+        }
+      }
+      if (exitOnComplete)
+        process.exit(0);
+      return;
+    }
+    s.stop(green("Account verified"));
+    if (emailUnchanged) {
       if (!inline)
-        outro.error("Email validation failed");
+        outro.info("Email unchanged");
       if (exitOnComplete)
-        process.exit(1);
+        process.exit(0);
       return;
     }
     await saveCredentials(targetEnv, {
       ...currentCreds,
       email: email3
     });
-    s.stop(green(`Email updated for ${targetEnv}`));
+    M2.success(`Email updated for ${targetEnv}`);
     if (!inline)
       outro.success();
     if (exitOnComplete)
@@ -17846,7 +18055,7 @@ async function handleCredentialSetup(options = {}) {
   };
 }
 // src/cli/lib/onboarding/import.ts
-import { TimebackClient as TimebackClient3 } from "@timeback/core";
+import { TimebackClient as TimebackClient4 } from "@timeback/core";
 async function promptImportApp(credentials, configuredEnvs) {
   let env2;
   if (configuredEnvs.length === 1 && configuredEnvs[0]) {
@@ -17859,7 +18068,7 @@ async function promptImportApp(credentials, configuredEnvs) {
     env2 = selectedEnv;
   }
   const creds = credentials[env2];
-  const client = new TimebackClient3({
+  const client = new TimebackClient4({
     env: env2,
     auth: { clientId: creds.clientId, clientSecret: creds.clientSecret }
   });
@@ -20289,7 +20498,8 @@ var cors = (options) => {
 async function handleBootstrap(c, ctx) {
   const { bootstrap } = c.get("services");
   const env2 = c.get("env");
-  const email3 = ctx.credentials[env2]?.email;
+  const freshCredentials = await getSavedCredentials(env2);
+  const email3 = freshCredentials?.email;
   const courseIds = ctx.userConfig.courseIds[env2];
   const result = await bootstrap.getBootstrap({ email: email3, courseIds });
   return c.json(result);
@@ -20617,6 +20827,7 @@ function createLogger(options = {}) {
 }
 // src/server/services/bootstrap.ts
 var log = createLogger({ scope: "studio:service:bootstrap" });
+var hasLoggedInitialLoad = false;
 
 class BootstrapService {
   client;
@@ -20647,8 +20858,11 @@ class BootstrapService {
       stats,
       errors: errors3.length
     });
-    const message = `Loaded ${underline(stats.totalCourses)} ${pluralize(stats.totalCourses, "course")}, ${underline(stats.totalStudents)} ${pluralize(stats.totalStudents, "student")}`;
-    M2.success(message);
+    if (!hasLoggedInitialLoad) {
+      const message = `Loaded ${underline(stats.totalCourses)} ${pluralize(stats.totalCourses, "course")}, ${underline(stats.totalStudents)} ${pluralize(stats.totalStudents, "student")}`;
+      M2.success(message);
+      hasLoggedInitialLoad = true;
+    }
     return {
       user,
       courses,
@@ -21128,48 +21342,107 @@ class EventsService {
     return result;
   }
 }
-// src/server/services/live.ts
-var log4 = createLogger({ scope: "studio:service:live" });
+// src/server/services/live-poller.ts
+var log4 = createLogger({ scope: "studio:service:live-poller" });
+var pollers = new Map;
+function getOrCreatePoller(environment, statusService, eventsService) {
+  let poller = pollers.get(environment);
+  if (!poller) {
+    poller = new LivePoller({ environment, statusService, eventsService });
+    pollers.set(environment, poller);
+  }
+  return poller;
+}
 
-class LiveService {
+class LivePoller {
+  environment;
   statusService;
   eventsService;
+  subscribers = new Set;
+  interval = null;
+  state;
+  lastBroadcast;
+  initialTickPromise = null;
+  ticking = false;
   constructor(options) {
+    this.environment = options.environment;
     this.statusService = options.statusService;
     this.eventsService = options.eventsService;
-  }
-  static createInitialState() {
     const now = Date.now();
-    return {
+    this.state = {
       lastStatusHash: "",
       lastEventTime: new Date().toISOString(),
       lastStatusTick: now,
       lastEventsTick: now
     };
   }
-  async tick(state) {
-    const updates = [];
-    const now = Date.now();
-    const newState = { ...state };
-    const statusUpdate = await this.fetchStatusIfChanged(state.lastStatusHash);
-    if (statusUpdate) {
-      updates.push(statusUpdate.update);
-      newState.lastStatusHash = statusUpdate.hash;
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    if (this.subscribers.size === 1) {
+      this.start();
     }
-    newState.lastStatusTick = now;
-    const shouldCheckEvents = this.hasIntervalElapsed(state.lastEventsTick, now, constants.events.polling.tickIntervalMs);
-    if (shouldCheckEvents) {
-      const eventsUpdate = await this.fetchEventsIfNew(state.lastEventTime);
-      if (eventsUpdate) {
-        updates.push(eventsUpdate.update);
-        newState.lastEventTime = eventsUpdate.newEventTime;
+    return () => {
+      this.subscribers.delete(callback);
+      if (this.subscribers.size === 0) {
+        this.stop();
+        pollers.delete(this.environment);
       }
-      newState.lastEventsTick = now;
+    };
+  }
+  async getLastBroadcastAfterInitialTick() {
+    if (this.initialTickPromise) {
+      await this.initialTickPromise;
     }
-    return { updates, newState };
+    return this.lastBroadcast;
   }
-  hasIntervalElapsed(lastTick, now, intervalMs) {
-    return now - lastTick >= intervalMs;
+  start() {
+    log4.debug("Poller started", { environment: this.environment });
+    this.initialTickPromise = this.tick();
+    this.interval = setInterval(() => this.tick(), constants.sse.defaultTickIntervalMs);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    this.lastBroadcast = undefined;
+    this.initialTickPromise = null;
+    log4.debug("Poller stopped", { environment: this.environment });
+  }
+  async tick() {
+    if (this.ticking)
+      return;
+    this.ticking = true;
+    try {
+      const updates = [];
+      const now = Date.now();
+      const statusUpdate = await this.fetchStatusIfChanged(this.state.lastStatusHash);
+      if (statusUpdate) {
+        updates.push(statusUpdate.update);
+        this.state.lastStatusHash = statusUpdate.hash;
+      }
+      this.state.lastStatusTick = now;
+      const shouldCheckEvents = now - this.state.lastEventsTick >= constants.events.polling.tickIntervalMs;
+      if (shouldCheckEvents) {
+        const eventsUpdate = await this.fetchEventsIfNew(this.state.lastEventTime);
+        if (eventsUpdate) {
+          updates.push(eventsUpdate.update);
+          this.state.lastEventTime = eventsUpdate.newEventTime;
+        }
+        this.state.lastEventsTick = now;
+      }
+      if (updates.length > 0) {
+        const data = JSON.stringify(updates);
+        this.lastBroadcast = data;
+        for (const callback of this.subscribers) {
+          callback(data);
+        }
+      }
+    } catch (error48) {
+      log4.error("Tick failed", { environment: this.environment, error: error48 });
+    } finally {
+      this.ticking = false;
+    }
   }
   async fetchStatusIfChanged(lastHash) {
     try {
@@ -21196,7 +21469,8 @@ class LiveService {
       }
       const message = `${underline(newEvents.length)} new ${pluralize(newEvents.length, "event")}`;
       M2.message(message, { symbol: magenta("◆") });
-      const mostRecentTime = newEvents.map((e2) => e2.eventTime).sort().pop();
+      const mostRecentTime = newEvents.map((e2) => new Date(e2.eventTime).getTime()).sort((a, b3) => a - b3).pop();
+      const newEventTime = mostRecentTime === undefined ? lastEventTime : new Date(mostRecentTime + 1).toISOString();
       return {
         update: {
           type: "events",
@@ -21205,7 +21479,7 @@ class LiveService {
             timestamp: new Date().toISOString()
           }
         },
-        newEventTime: mostRecentTime ?? lastEventTime
+        newEventTime
       };
     } catch (error48) {
       log4.error("Failed to fetch events", { error: error48 });
@@ -21221,11 +21495,15 @@ class StatusService {
   }
   async getStatus() {
     const configuredEnvironments = await getConfiguredEnvironments();
+    const [stagingCreds, productionCreds] = await Promise.all([
+      getSavedCredentials("staging"),
+      getSavedCredentials("production")
+    ]);
     return {
       config: this.ctx.userConfig,
       environment: this.ctx.defaultEnvironment,
       configuredEnvironments,
-      hasEmail: !!this.ctx.credentials.staging?.email || !!this.ctx.credentials.production?.email
+      hasEmail: !!stagingCreds?.email || !!productionCreds?.email
     };
   }
 }
@@ -21606,6 +21884,7 @@ function runSSE(c, options) {
     } catch {
       abort("write error");
     }
+    options.onClose?.();
     unregisterConnection(key, () => abort("superseded"));
     log8.debug("SSE connection closed", { ...meta3, reason: closeReason });
   });
@@ -21708,20 +21987,41 @@ function handleEventsStream(c) {
 }
 // src/server/controllers/live.ts
 function handleLive(c) {
+  const env2 = c.get("env");
   const { status: statusService, events: eventsService } = c.get("services");
-  const liveService = new LiveService({ statusService, eventsService });
-  let state = LiveService.createInitialState();
+  const poller = getOrCreatePoller(env2, statusService, eventsService);
+  let pending;
+  let isFirstTick = true;
+  const takePending = () => {
+    const data = pending;
+    pending = undefined;
+    return data;
+  };
+  const unsubscribe = poller.subscribe((data) => {
+    pending = data;
+  });
   return runSSE(c, {
     event: "live",
     intervalMs: constants.sse.defaultTickIntervalMs,
     sendInitial: true,
+    onClose: unsubscribe,
     tick: async () => {
-      const result = await liveService.tick(state);
-      state = result.newState;
-      if (result.updates.length === 0) {
-        return;
+      if (isFirstTick) {
+        isFirstTick = false;
+        const immediate = takePending();
+        if (immediate !== undefined) {
+          return immediate;
+        }
+        const initial = await poller.getLastBroadcastAfterInitialTick();
+        if (pending !== undefined && pending === initial) {
+          pending = undefined;
+        }
+        if (initial !== undefined) {
+          return initial;
+        }
+        return takePending();
       }
-      return JSON.stringify(result.updates);
+      return takePending();
     }
   });
 }

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

@@ -11,6 +11,9 @@ import type { EnvVariables } from '../lib';
  *
  * Requires env middleware to set `env` and `client` context variables.
  *
+ * NOTE: We read credentials fresh from disk to pick up changes made via CLI
+ * (e.g., email updates, account creation) without requiring a server restart.
+ *
  * @param c - Hono context with env variables
  * @param ctx - App context
  * @returns JSON response with user and courses

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

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,GAAG,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAU7F"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,GAAG,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAW7F"}

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

@@ -3,15 +3,17 @@
  *
  * GET /api/live - Multiplexed SSE stream combining status and events.
  *
- * See LiveService for detailed documentation on how tick intervals work.
+ * Uses a shared LivePoller per environment so all SSE connections receive
+ * the same data from a single polling loop. See LivePoller for details.
  */
 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.
+ * Subscribes to the shared LivePoller for the current environment.
+ * The poller broadcasts serialized updates which are forwarded to
+ * the client via the SSE tick function.
  *
  * @param c - Hono context with env variables
  * @returns SSE stream

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

@@ -1 +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"}
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/live.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC,YAiDjE"}

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

@@ -1 +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"}
+{"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,YA6ExD"}

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

@@ -60,5 +60,7 @@ export interface RunSSEOptions {
     sendInitial?: boolean;
     /** Return a string to emit, or undefined to skip this tick */
     tick: () => Promise<string | undefined>;
+    /** Called when the stream closes for any reason (superseded, client disconnect, error) */
+    onClose?: () => void;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +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"}
+{"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;IACvC,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACpB"}

package/dist/server/services/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/services/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAGpD,OAAO,KAAK,EACX,eAAe,EAIf,mBAAmB,EACnB,MAAM,SAAS,CAAA;AAyBhB;;;;GAIG;AACH,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IAEvC,YAAY,MAAM,EAAE,cAAc,EAEjC;IAED;;;;;OAKG;IACG,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC,CA8CzE;IAMD;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;YAkBN,oBAAoB;YAoEpB,0BAA0B;YA8F1B,cAAc;YAgGd,YAAY;YAgCZ,gBAAgB;YA2BhB,gBAAgB;CAmH9B"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/services/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAGpD,OAAO,KAAK,EACX,eAAe,EAIf,mBAAmB,EACnB,MAAM,SAAS,CAAA;AAiChB;;;;GAIG;AACH,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IAEvC,YAAY,MAAM,EAAE,cAAc,EAEjC;IAED;;;;;OAKG;IACG,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC,CAiDzE;IAMD;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;YAkBN,oBAAoB;YAoEpB,0BAA0B;YA8F1B,cAAc;YAgGd,YAAY;YAgCZ,gBAAgB;YA2BhB,gBAAgB;CAmH9B"}

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

@@ -6,8 +6,8 @@
 export { BootstrapService } from './bootstrap';
 export { EnrollmentService } from './enrollment';
 export { EventsService } from './events';
-export { LiveService } from './live';
+export { getOrCreatePoller } from './live';
 export { StatusService } from './status';
 export { StudentSearchService } from './student-search';
-export type { BootstrapResult, BootstrapStats, EnrichedComponentResource, EnrichedEnrollment, GetBootstrapOptions, EnrollmentActionOptions, EnrollmentResult, EnrollStudentOptions, GetNewEventsOptions, GetRecentEventsOptions, TickResult, TickState, SearchStudentsOptions, StudentSearchResponse, StudentSearchResult, } from './types';
+export type { BootstrapResult, BootstrapStats, EnrichedComponentResource, EnrichedEnrollment, GetBootstrapOptions, EnrollmentActionOptions, EnrollmentResult, EnrollStudentOptions, GetNewEventsOptions, GetRecentEventsOptions, TickState, SearchStudentsOptions, StudentSearchResponse, StudentSearchResult, } from './types';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/services/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAMvD,YAAY,EAEX,eAAe,EACf,cAAc,EACd,yBAAyB,EACzB,kBAAkB,EAClB,mBAAmB,EAEnB,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EAEpB,mBAAmB,EACnB,sBAAsB,EAEtB,UAAU,EACV,SAAS,EAET,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,GACnB,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/services/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAMvD,YAAY,EAEX,eAAe,EACf,cAAc,EACd,yBAAyB,EACzB,kBAAkB,EAClB,mBAAmB,EAEnB,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EAEpB,mBAAmB,EACnB,sBAAsB,EAEtB,SAAS,EAET,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,GACnB,MAAM,SAAS,CAAA"}