@agent-native/scheduling 0.2.1 → 0.2.2-nightly-20260927013707

package/src/schema/credentials.ts

@@ -1,51 +1,27 @@
-/**
- * Credentials — thin view over framework `oauth_tokens` that records which
- * calendar / video integrations a user has connected. The actual OAuth
- * tokens live in core's `oauth_tokens` table; this table stores display
- * metadata and flags needed by the scheduling UI (display name, invalid
- * flag, app icon, default-for-type).
- */
 import { table, text } from "@agent-native/core/db/schema";
 import { boolean } from "drizzle-orm/pg-core";
 
 export const schedulingCredentials = table("scheduling_credentials", {
   id: text("id").primaryKey(),
-  /** Provider slug: "google_calendar", "office365_calendar", "zoom_video", "daily_video", … */
   type: text("type").notNull(),
-  /** Owner (user) — for team credentials, use teamId too */
   userEmail: text("user_email"),
   teamId: text("team_id"),
-  /** App id from framework app store */
   appId: text("app_id"),
-  /** Core `oauth_tokens.id` if applicable */
   oauthTokenId: text("oauth_token_id"),
-  /** Human-friendly label shown in UI */
   displayName: text("display_name"),
-  /** External account email (e.g. Google account email) */
   externalEmail: text("external_email"),
-  /** True after a 401/403 — UI prompts re-connect */
   invalid: boolean("invalid").notNull().default(false),
-  /** Whether this is the user's default for its category (e.g. default video) */
   isDefault: boolean("is_default").notNull().default(false),
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull(),
 });
 
-/**
- * Which external calendars a credential reads "busy" times from.
- * A single credential (e.g. a Google account) may expose multiple calendars
- * (primary, vacation, shared). Users pick a subset to check for conflicts,
- * plus exactly one as the destination for new events.
- */
 export const selectedCalendars = table("selected_calendars", {
   id: text("id").primaryKey(),
   credentialId: text("credential_id").notNull(),
   userEmail: text("user_email").notNull(),
-  /** External calendar id from the provider */
   externalId: text("external_id").notNull(),
-  /** Provider name for this entry */
   integration: text("integration").notNull(),
-  /** Optional event-type-level override (only check this calendar for that event) */
   eventTypeId: text("event_type_id"),
   createdAt: text("created_at").notNull(),
 });
@@ -54,16 +30,13 @@ export const destinationCalendars = table("destination_calendars", {
   id: text("id").primaryKey(),
   credentialId: text("credential_id").notNull(),
   userEmail: text("user_email").notNull(),
-  /** Provider name */
   integration: text("integration").notNull(),
   externalId: text("external_id").notNull(),
   primaryEmail: text("primary_email"),
-  /** Optional event-type-level override */
   eventTypeId: text("event_type_id"),
   createdAt: text("created_at").notNull(),
 });
 
-/** Verified sender emails for workflows sending from a custom address. */
 export const verifiedEmails = table("verified_emails", {
   id: text("id").primaryKey(),
   email: text("email").notNull(),
@@ -72,7 +45,6 @@ export const verifiedEmails = table("verified_emails", {
   verifiedAt: text("verified_at").notNull(),
 });
 
-/** Verified phone numbers for workflows sending SMS. */
 export const verifiedNumbers = table("verified_numbers", {
   id: text("id").primaryKey(),
   phoneNumber: text("phone_number").notNull(),

package/src/schema/event-types.ts

@@ -1,14 +1,3 @@
-/**
- * Event types — the top-level bookable definition.
- *
- * An EventType represents "a 30-minute intro call", "a team round-robin sales
- * demo", or "a managed internal 1:1". It is the primary resource users create,
- * edit, and share booking links for.
- *
- * Ownership: personal event types are owned by a user (ownerEmail);
- * team event types are owned by a team (teamId). Sharing is via the framework
- * sharing system (`event_type_shares`).
- */
 import {
   table,
   text,
@@ -21,44 +10,33 @@ import { boolean } from "drizzle-orm/pg-core";
 export const eventTypes = table("event_types", {
   id: text("id").primaryKey(),
 
-  // Identity
   title: text("title").notNull(),
   slug: text("slug").notNull(),
   description: text("description"),
-  /** Default duration in minutes */
   length: integer("length").notNull().default(30),
-  /** JSON array of additional duration choices, e.g. [15, 30, 60] */
   durations: text("durations"),
   position: integer("position").notNull().default(0),
   hidden: boolean("hidden").notNull().default(false),
   color: text("color"),
 
-  // Scheduling model
   schedulingType: text("scheduling_type", {
     enum: ["personal", "collective", "round-robin", "managed"],
   })
     .notNull()
     .default("personal"),
-  /** Team id if this is a team event type; null for personal */
   teamId: text("team_id"),
 
-  // Locations (JSON array of Location objects)
   locations: text("locations"),
 
-  // Custom fields (JSON array of CustomField objects)
   customFields: text("custom_fields"),
 
-  // Default schedule reference
   scheduleId: text("schedule_id"),
 
-  // Buffers & notice
   minimumBookingNotice: integer("minimum_booking_notice").notNull().default(0),
   beforeEventBuffer: integer("before_event_buffer").notNull().default(0),
   afterEventBuffer: integer("after_event_buffer").notNull().default(0),
-  /** Slot granularity in minutes; null = use duration */
   slotInterval: integer("slot_interval"),
 
-  // Booking window
   periodType: text("period_type", {
     enum: ["unlimited", "rolling", "range"],
   })
@@ -68,7 +46,6 @@ export const eventTypes = table("event_types", {
   periodStartDate: text("period_start_date"),
   periodEndDate: text("period_end_date"),
 
-  // Capacity & policies
   seatsPerTimeSlot: integer("seats_per_time_slot"),
   requiresConfirmation: boolean("requires_confirmation")
     .notNull()
@@ -77,16 +54,12 @@ export const eventTypes = table("event_types", {
   hideCalendarNotes: boolean("hide_calendar_notes").notNull().default(false),
   successRedirectUrl: text("success_redirect_url"),
   bookingLimits: text("booking_limits"),
-  /** Lock timezone on Booker (for in-person or local-only events) */
   lockTimeZoneToggle: boolean("lock_time_zone_toggle").notNull().default(false),
 
-  // Recurring (JSON RecurringEventRule) — Tier 2
   recurringEvent: text("recurring_event"),
 
-  // Templated event name: "{name} + {host}"
   eventName: text("event_name"),
 
-  // Misc
   metadata: text("metadata"),
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull(),
@@ -94,26 +67,17 @@ export const eventTypes = table("event_types", {
   ...ownableColumns(),
 });
 
-/**
- * Host assignments for team / round-robin / collective event types.
- * Composite key (userEmail, eventTypeId).
- */
 export const eventTypeHosts = table("event_type_hosts", {
   eventTypeId: text("event_type_id").notNull(),
   userEmail: text("user_email").notNull(),
-  /** Fixed hosts always attend; non-fixed hosts rotate in round-robin */
   isFixed: boolean("is_fixed").notNull().default(false),
-  /** Relative weight for weighted round-robin (default 1) */
   weight: integer("weight").notNull().default(1),
-  /** Lower number = higher priority in round-robin tiebreak */
   priority: integer("priority").notNull().default(2),
-  /** Host-specific schedule override; null = use host's default */
   scheduleId: text("schedule_id"),
   groupId: text("group_id"),
   createdAt: text("created_at").notNull(),
 });
 
-/** Host groups — collective assignment within a round-robin group. */
 export const eventTypeHostGroups = table("event_type_host_groups", {
   id: text("id").primaryKey(),
   eventTypeId: text("event_type_id").notNull(),
@@ -121,19 +85,13 @@ export const eventTypeHostGroups = table("event_type_host_groups", {
   createdAt: text("created_at").notNull(),
 });
 
-/**
- * Rename history — e.g. `/me/old-slug` → `/me/new-slug`.
- * Public booker redirects the old slug to the new one.
- */
 export const eventTypeSlugRedirects = table("event_type_slug_redirects", {
-  /** Composite: "ownerEmail:slug" or "team:teamId:slug" — unique across ownership scope */
   oldKey: text("old_key").primaryKey(),
   newKey: text("new_key").notNull(),
   eventTypeId: text("event_type_id"),
   createdAt: text("created_at").notNull(),
 });
 
-/** Hashed private links (`/d/:hash/:slug`) — shareable tokens that don't expose the owner's username. */
 export const hashedLinks = table("hashed_links", {
   id: text("id").primaryKey(),
   hash: text("hash").notNull().unique(),

package/src/schema/index.ts

@@ -1,14 +1,3 @@
-/**
- * Barrel export for all scheduling schema tables.
- *
- * Consumer apps compose this with their own schema:
- *
- *   // server/db/schema.ts
- *   export * from "@agent-native/scheduling/schema";
- *   export * from "./local-tables.js";
- *
- * Drizzle's schema scanner picks up all tables from the combined namespace.
- */
 export * from "./event-types.js";
 export * from "./schedules.js";
 export * from "./bookings.js";

package/src/schema/routing-forms.ts

@@ -1,12 +1,3 @@
-/**
- * Routing forms — ChiliPiper-style pre-booking forms that route prospects to
- * the right event type based on their answers.
- *
- * A form has fields (text/select/multi), rules (match conditions → action),
- * and a fallback. Public form URL is `/forms/:formId`; on submit we evaluate
- * rules in order and either redirect to an event-type booker, open an
- * external URL, or show a custom message.
- */
 import {
   table,
   text,
@@ -21,11 +12,8 @@ export const routingForms = table("routing_forms", {
   description: text("description"),
   teamId: text("team_id"),
   disabled: boolean("disabled").notNull().default(false),
-  /** JSON array of RoutingFormField */
   fields: text("fields").notNull().default("[]"),
-  /** JSON array of RoutingFormRule */
   rules: text("rules").notNull().default("[]"),
-  /** JSON RoutingFormRule action object for when no rules match */
   fallback: text("fallback"),
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull(),
@@ -35,15 +23,10 @@ export const routingForms = table("routing_forms", {
 export const routingFormResponses = table("routing_form_responses", {
   id: text("id").primaryKey(),
   formId: text("form_id").notNull(),
-  /** JSON object of fieldId → value */
   response: text("response").notNull(),
-  /** Booking id if the response resulted in a booking */
   bookingId: text("booking_id"),
-  /** Which rule matched (null if fallback) */
   matchedRuleId: text("matched_rule_id"),
-  /** Resulting action description for quick filtering */
   routedTo: text("routed_to"),
-  /** Submitter context */
   submitterEmail: text("submitter_email"),
   submitterIp: text("submitter_ip"),
   createdAt: text("created_at").notNull(),

package/src/schema/schedules.ts

@@ -1,12 +1,3 @@
-/**
- * Schedules — named availability presets ("Working Hours", "Evenings").
- *
- * A Schedule has weekly rules (e.g. Mon-Fri 9am-5pm) stored as rows in
- * `schedule_availability`, plus one-off overrides stored in `date_overrides`.
- *
- * Each user has one default schedule; event types can pick any of the user's
- * schedules, or a host-specific override for team events.
- */
 import {
   table,
   text,
@@ -26,38 +17,23 @@ export const schedules = table("schedules", {
   ...ownableColumns(),
 });
 
-/**
- * Weekly availability rules.
- * Each row is one interval on one day-of-week for one schedule.
- * Example: scheduleId=X, day=1 (Mon), startTime="09:00", endTime="12:00".
- */
 export const scheduleAvailability = table("schedule_availability", {
   id: text("id").primaryKey(),
   scheduleId: text("schedule_id").notNull(),
-  /** 0=Sunday … 6=Saturday */
   day: integer("day").notNull(),
-  /** "HH:MM" in schedule's timezone */
   startTime: text("start_time").notNull(),
   endTime: text("end_time").notNull(),
   createdAt: text("created_at").notNull(),
 });
 
-/**
- * Date-specific overrides.
- * Example: scheduleId=X, date="2026-04-25", intervals=[] (fully blocked).
- * Or intervals=[{"09:00"-"11:00"}] (only 9-11 on that day).
- */
 export const dateOverrides = table("date_overrides", {
   id: text("id").primaryKey(),
   scheduleId: text("schedule_id").notNull(),
-  /** YYYY-MM-DD in schedule's timezone */
   date: text("date").notNull(),
-  /** JSON array of {startTime,endTime}. Empty = fully blocked. */
   intervals: text("intervals").notNull().default("[]"),
   createdAt: text("created_at").notNull(),
 });
 
-/** Time-zoned travel windows that override the user's default timezone. */
 export const travelSchedules = table("travel_schedules", {
   id: text("id").primaryKey(),
   userEmail: text("user_email").notNull(),
@@ -67,7 +43,6 @@ export const travelSchedules = table("travel_schedules", {
   createdAt: text("created_at").notNull(),
 });
 
-/** Out of office — blocks bookings and optionally redirects to a coworker. */
 export const outOfOfficeEntries = table("out_of_office_entries", {
   id: text("id").primaryKey(),
   userEmail: text("user_email").notNull(),

package/src/schema/teams.ts

@@ -1,10 +1,3 @@
-/**
- * Teams — groupings of users who share event types, round-robin across hosts,
- * and present a team booking page at `/team/:slug`.
- *
- * Framework `org` provides heavier identity (for full multi-tenant orgs);
- * teams here are lighter-weight and may be scoped to a single org.
- */
 import {
   table,
   text,

package/src/schema/workflows.ts

@@ -1,10 +1,3 @@
-/**
- * Workflows — trigger-based automations ("email attendee 1h before event").
- *
- * Each workflow has a trigger + ordered steps. Steps run on a schedule via
- * the framework's recurring-jobs mechanism: when a booking fires a trigger,
- * we materialize scheduled reminders; a job processes them when due.
- */
 import {
   table,
   text,
@@ -29,7 +22,6 @@ export const workflows = table("workflows", {
   }).notNull(),
   teamId: text("team_id"),
   disabled: boolean("disabled").notNull().default(false),
-  /** JSON array of eventTypeIds this workflow runs on. Empty = none. */
   activeOnEventTypeIds: text("active_on_event_type_ids")
     .notNull()
     .default("[]"),
@@ -53,24 +45,16 @@ export const workflowSteps = table("workflow_steps", {
       "webhook",
     ],
   }).notNull(),
-  /** Offset in minutes from the trigger. Negative = before (for before-event). */
   offsetMinutes: integer("offset_minutes").notNull().default(0),
-  /** Target email / phone / url depending on action */
   sendTo: text("send_to"),
   emailSubject: text("email_subject"),
   emailBody: text("email_body"),
   smsBody: text("sms_body"),
   webhookUrl: text("webhook_url"),
-  /** Named template key (e.g. "default-reminder") */
   template: text("template"),
   createdAt: text("created_at").notNull(),
 });
 
-/**
- * Materialized reminders waiting to fire.
- * Written by the booking-service hook when a trigger occurs.
- * Drained by a recurring job that processes due rows.
- */
 export const scheduledReminders = table("scheduled_reminders", {
   id: text("id").primaryKey(),
   bookingId: text("booking_id").notNull(),
@@ -87,14 +71,12 @@ export const scheduledReminders = table("scheduled_reminders", {
   createdAt: text("created_at").notNull(),
 });
 
-/** Outgoing webhook subscriptions. */
 export const webhooks = table("webhooks", {
   id: text("id").primaryKey(),
   name: text("name"),
   subscriberUrl: text("subscriber_url").notNull(),
   secret: text("secret"),
   active: boolean("active").notNull().default(true),
-  /** JSON array of trigger keys */
   eventTriggers: text("event_triggers").notNull().default("[]"),
   teamId: text("team_id"),
   eventTypeId: text("event_type_id"),
@@ -114,7 +96,6 @@ export const webhookDeliveries = table("webhook_deliveries", {
   attempts: integer("attempts").notNull().default(0),
 });
 
-/** API keys for programmatic access. */
 export const apiKeys = table("api_keys", {
   id: text("id").primaryKey(),
   hashedKey: text("hashed_key").notNull().unique(),

package/src/server/availability-engine.test.ts

@@ -29,7 +29,6 @@ interface FakeDbInput {
   }>;
   credentials?: CredentialRow[];
   selected?: SelectedCalendarRow[];
-  /** Supports the pre-batching implementation during characterization. */
   legacySelectedBatches?: SelectedCalendarRow[][];
 }
 

package/src/server/availability-engine.ts

@@ -1,11 +1,3 @@
-/**
- * Availability engine — combines an event type, schedule, and calendar busy
- * intervals into the slot list shown to the Booker.
- *
- * This is where the pure `computeAvailableSlots` gets plugged into the real
- * world: it fetches the schedule, merges busy times from the selected
- * calendars + existing bookings, and applies booking limits.
- */
 import { eq, gte, lt, and, inArray } from "drizzle-orm";
 
 import { expandSlotForConflictCheck } from "../core/buffers.js";
@@ -39,16 +31,9 @@ export interface AssertSlotAvailableInput {
   endTime: string;
   beforeEventBuffer?: number;
   afterEventBuffer?: number;
-  /** Booking uid to ignore when checking conflicts (e.g. the one being rescheduled). */
   excludeBookingUid?: string;
 }
 
-/**
- * Re-validate a single requested interval right before it's written —
- * cheap by design: aggregates busy only over the buffer-expanded window
- * instead of scanning a full day like `getAvailableSlots`. Throws
- * `SlotConflictError` if the window collides with existing busy time.
- */
 export async function assertSlotAvailable(
   input: AssertSlotAvailableInput,
 ): Promise<void> {
@@ -73,7 +58,6 @@ export async function assertSlotAvailable(
 
 export interface GetSlotsInput {
   eventType: EventType;
-  /** The user we're finding availability for — their schedule + calendars. */
   forUserEmail: string;
   rangeStart: Date;
   rangeEnd: Date;
@@ -141,10 +125,6 @@ async function resolveDefaultSchedule(
   return getScheduleById(rows[0].id);
 }
 
-/**
- * Merge busy intervals from: (a) existing bookings for the user, (b) selected
- * external calendars (via providers), (c) the calendar cache.
- */
 export async function aggregateBusy(input: {
   userEmail: string;
   rangeStart: Date;
@@ -154,7 +134,6 @@ export async function aggregateBusy(input: {
   const db = getDb();
   const busy: BusyInterval[] = [];
 
-  // Existing bookings where this user is the host
   const bookings = await db
     .select()
     .from(schema.bookings)
@@ -174,7 +153,6 @@ export async function aggregateBusy(input: {
     });
   }
 
-  // External calendars via registered providers
   const creds = await db
     .select()
     .from(schema.schedulingCredentials)

package/src/server/booking-service.spec.ts

@@ -305,7 +305,6 @@ afterEach(async () => {
   rmSync(dbDir, { recursive: true, force: true });
 });
 
-/** `rescheduleBooking` re-loads the event type by id, so it must exist. */
 async function seedEventType(eventType: EventType): Promise<void> {
   await execute({
     sql: `INSERT INTO event_types (
@@ -405,9 +404,6 @@ describe("insertBooking", () => {
         timezone: "UTC",
         attendees: [
           { email: ATTENDEE_EMAIL, name: "Attendee One" },
-          // A null email violates the NOT NULL constraint after the first
-          // attendee (and the booking row) have already been written —
-          // proving the whole write is one atomic unit.
           { email: null as unknown as string, name: "Bad Attendee" },
         ],
         ownerEmail: HOST_EMAIL,
@@ -499,8 +495,6 @@ describe("createBooking", () => {
       attendee: { email: ATTENDEE_EMAIL, name: "Attendee One" },
     });
 
-    // Starts exactly when the first booking ends, so the raw windows don't
-    // overlap — only the buffered event type's 15-minute lead-in collides.
     const bufferedEventType = makeEventType({
       id: "event-type-buffered",
       beforeEventBuffer: 15,
@@ -518,9 +512,6 @@ describe("createBooking", () => {
   });
 
   it("allows an out-of-availability free slot once the conflicting booking is cancelled", async () => {
-    // Sanity check that the conflict guard is scoped to the requested
-    // window, not a blanket rejection — a later, non-overlapping slot for
-    // the same host must still succeed.
     const eventType = makeEventType();
     await createBooking({
       eventType,
@@ -556,9 +547,6 @@ describe("rescheduleBooking", () => {
       attendee: { email: ATTENDEE_EMAIL, name: "Attendee One" },
     });
 
-    // Reschedule to an overlapping-but-shifted slot; if the original
-    // booking's own busy interval weren't excluded, this would always
-    // conflict with itself.
     const rescheduled = await rescheduleBooking({
       uid: original.uid,
       newStartTime: "2026-08-08T10:15:00.000Z",
@@ -597,9 +585,6 @@ describe("rescheduleBooking", () => {
       }),
     ).rejects.toBeInstanceOf(SlotConflictError);
 
-    // The original booking must stay intact after a failed reschedule
-    // attempt — it should never be left marked "rescheduled" with no
-    // successor.
     const stillOriginal = await getBookingByUid(original.uid);
     expect(stillOriginal?.status).toBe("confirmed");
   });

package/src/server/booking-service.ts

@@ -1,17 +1,5 @@
 import { eq } from "drizzle-orm";
 
-/**
- * Booking lifecycle — create, reschedule, cancel — wired to providers and
- * workflow hooks.
- *
- * The booking flow:
- *   1. Load event type and resolve host (1:1, round-robin).
- *   2. Validate requested slot against availability engine.
- *   3. Insert the booking row + attendees.
- *   4. For each video/calendar provider, create external events and attach
- *      references to the booking.
- *   5. Emit lifecycle event → workflows materialize scheduled reminders.
- */
 import type {
   Booking,
   Attendee,
@@ -50,9 +38,7 @@ export interface CreateBookingInput {
   iCalUid?: string;
   iCalSequence?: number;
   orgId?: string;
-  /** If set, we're rescheduling from this booking uid */
   fromReschedule?: string;
-  /** Keep Zoom reschedules uncommitted until the replacement meeting is usable. */
   requireZoomMeeting?: boolean;
 }
 
@@ -107,7 +93,6 @@ export async function createBooking(
 
   let usableZoomMeeting = false;
 
-  // Create video meeting if location is a video kind
   if (booking.location && isVideoKind(booking.location.kind)) {
     const provider = getVideoProvider(
       videoProviderKindFor(booking.location.kind),
@@ -150,10 +135,8 @@ export async function createBooking(
     );
   }
 
-  // Write to destination calendar
   await writeToDestinationCalendars(booking);
 
-  // Fire workflow hooks
   await onBookingCreated(booking);
 
   const final = await getBookingByUid(booking.uid);
@@ -175,9 +158,6 @@ export async function rescheduleBooking(input: {
   if (!eventType) throw new Error("Event type missing");
   requireZoomMeetingResolution(original, input.zoomMeetingResolved);
 
-  // Create the new booking (validated against availability, ignoring the
-  // original's own slot) before touching the original, so a slot conflict
-  // never leaves the original marked "rescheduled" with no successor.
   const attendee = original.attendees[0];
   const guests = original.attendees.slice(1);
   const newBooking = await createBooking({
@@ -217,12 +197,10 @@ export async function rescheduleBooking(input: {
     throw error;
   }
 
-  // Mark old as rescheduled now that the replacement exists.
   await updateBookingStatus(input.uid, "rescheduled", {
     reschedulingReason: input.reason,
   });
 
-  // Update external calendar events (PATCH, not delete+create)
   for (const ref of original.references) {
     const provider = getCalendarProvider(ref.type);
     if (provider?.updateEvent && ref.credentialId) {

package/src/server/bookings-repo.ts

@@ -1,7 +1,4 @@
 import { accessFilter } from "@agent-native/core/sharing";
-/**
- * Data access for bookings + their attendees, references, and notes.
- */
 import { eq, and, gte, lt, or, desc, asc, isNotNull } from "drizzle-orm";
 import { nanoid } from "nanoid";
 
@@ -98,16 +95,9 @@ export interface ListBookingsFilter {
   eventTypeId?: string;
   status?: BookingStatus | "upcoming" | "past" | "unconfirmed" | "recurring";
   attendeeEmail?: string;
-  /** Inclusive start (ISO) */
   from?: string;
-  /** Exclusive end (ISO) */
   to?: string;
   limit?: number;
-  /**
-   * If true, admit any booking the current user owns, has been shared on, or
-   * matches via org-visibility — in addition to the explicit `hostEmail`
-   * filter (which still narrows further when set).
-   */
   useAccessFilter?: boolean;
 }
 

package/src/server/context.ts

@@ -1,32 +1,16 @@
-/**
- * Server-side context — the package's view of the world.
- *
- * Actions and server logic call `getSchedulingContext()` to get handles to
- * the DB, provider registry, current user, and configuration. The consumer
- * wires this up at app startup via `setSchedulingContext()`.
- *
- * The context is pinned on `globalThis` under a symbol key so Vite SSR +
- * Nitro can safely end up with two module instances (e.g. source via
- * workspace linking vs. dist/) and still share state. Same pattern core uses
- * for the secrets registry.
- */
 import type { GetDbFn, SchedulingSchema } from "./db-types.js";
 
 export interface SchedulingContext {
   getDb: GetDbFn;
   schema: SchedulingSchema;
-  /** How the consumer resolves the current user's email (typically from request ctx). */
   getCurrentUserEmail: () => string | undefined;
-  /** How the consumer resolves the current user's org id (if multi-tenant). */
   getCurrentOrgId?: () => string | undefined;
-  /** Default brand/timezone/week-start for a user (from settings). */
   getUserPreferences?: (email: string) => Promise<{
     timezone?: string;
     weekStartsOn?: 0 | 1;
     brandColor?: string;
     darkBrandColor?: string;
   }>;
-  /** Base public URL, e.g. "https://sched.example.com" — used in emails + ICS. */
   publicBaseUrl?: string;
 }
 

package/src/server/db-types.ts

@@ -1,16 +1,5 @@
-/**
- * DB shape contracts.
- *
- * The package doesn't own a live DB connection — it takes `getDb()` from the
- * consumer, which returns a Drizzle client wired to the consumer's schema.
- * This file declares the minimum shape the package needs.
- */
 import type * as schemaAll from "../schema/index.js";
 
 export type SchedulingSchema = typeof schemaAll;
 
-/**
- * GetDb accessor — consumer-provided. Typically returns the Drizzle client
- * used everywhere in the template.
- */
 export type GetDbFn = () => any;