slotlock 0.2.0 → 0.5.0

package/event-schema.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+export declare const SLOTLOCK_EVENT_OUTPUT: z.ZodObject<{
+    id: z.ZodString;
+    resource_id: z.ZodString;
+    starts_at: z.ZodString;
+    ends_at: z.ZodString;
+    timezone: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    location: z.ZodNullable<z.ZodString>;
+    organizer: z.ZodNullable<z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    attendees: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        role: z.ZodEnum<{
+            chair: "chair";
+            non_participant: "non_participant";
+            optional: "optional";
+            required: "required";
+        }>;
+        participation_status: z.ZodEnum<{
+            accepted: "accepted";
+            declined: "declined";
+            delegated: "delegated";
+            needs_action: "needs_action";
+            tentative: "tentative";
+        }>;
+        rsvp: z.ZodBoolean;
+    }, z.core.$strict>>;
+    reminders: z.ZodArray<z.ZodObject<{
+        minutes_before: z.ZodNumber;
+        channel: z.ZodEnum<{
+            display: "display";
+            email: "email";
+        }>;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        confirmed: "confirmed";
+        tentative: "tentative";
+    }>;
+    transparency: z.ZodEnum<{
+        opaque: "opaque";
+        transparent: "transparent";
+    }>;
+    sequence: z.ZodNumber;
+    revision: z.ZodNumber;
+    recurrence_rule: z.ZodNullable<z.ZodString>;
+    recurrence_exceptions: z.ZodArray<z.ZodObject<{
+        recurrence_id: z.ZodString;
+        cancelled: z.ZodBoolean;
+        starts_at: z.ZodNullable<z.ZodString>;
+        ends_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    recurrence_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;

package/event-schema.js

@@ -0,0 +1,85 @@
+// A calendar event as the event tools return it, and as the application API returns any of a
+// tenant's events. Its own module because both the agent server and the application API describe
+// events with it, and the application API imports nothing from the agent server at runtime (the
+// agent server imports it, so the reverse would be a cycle).
+import { z } from 'zod';
+const DATE_TIME = z.string().datetime({ offset: true });
+const RESOURCE_ID = z.string().trim().min(1).max(200);
+const EVENT_ID = z.string().trim().min(1).max(500);
+const REVISION = z.number().int().positive();
+// Output bounds mirror the trusted store's byte ceilings. A value admitted by a UTF-8 byte
+// ceiling can never exceed that many UTF-16 code units, so every valid stored/provider event is
+// serializable without truncating recurrence semantics or calendar identities.
+const TRUSTED_SUMMARY_OUTPUT_MAX = 4_096;
+const TRUSTED_TEXT_OUTPUT_MAX = 16_384;
+const TRUSTED_PERSON_NAME_OUTPUT_MAX = 1_024;
+const TRUSTED_RECURRENCE_EXCEPTION_OUTPUT_MAX = 1_000;
+const TRUSTED_REMINDER_MINUTES_OUTPUT_MAX = 366 * 24 * 60;
+// The grammar the store keeps an address in (normalizeEmail in sync.ts), so every stored one can be
+// returned: an address from an imported feed need not be one z.email() takes (ops@localhost).
+const STORED_ADDRESS = z
+    .string()
+    .min(3)
+    .max(320)
+    .refine((value) => /^[^\s@]+@[^\s@]+$/.test(value), {
+    message: 'must be one @ between characters other than spaces',
+});
+const ORGANIZER = z
+    .object({
+    address: STORED_ADDRESS,
+    name: z.string().trim().max(TRUSTED_PERSON_NAME_OUTPUT_MAX).nullable(),
+})
+    .strict();
+const ATTENDEE = z
+    .object({
+    address: STORED_ADDRESS,
+    name: z.string().trim().max(TRUSTED_PERSON_NAME_OUTPUT_MAX).nullable(),
+    role: z.enum(['chair', 'required', 'optional', 'non_participant']),
+    participation_status: z.enum([
+        'needs_action',
+        'accepted',
+        'declined',
+        'tentative',
+        'delegated',
+    ]),
+    rsvp: z.boolean(),
+})
+    .strict();
+const REMINDER = z
+    .object({
+    minutes_before: z.number().int().min(0).max(TRUSTED_REMINDER_MINUTES_OUTPUT_MAX),
+    channel: z.enum(['display', 'email']),
+})
+    .strict();
+const RECURRENCE_EXCEPTION = z
+    .object({
+    recurrence_id: DATE_TIME,
+    cancelled: z.boolean(),
+    starts_at: DATE_TIME.nullable(),
+    ends_at: DATE_TIME.nullable(),
+})
+    .strict();
+export const SLOTLOCK_EVENT_OUTPUT = z
+    .object({
+    id: EVENT_ID,
+    resource_id: RESOURCE_ID,
+    starts_at: DATE_TIME,
+    ends_at: DATE_TIME,
+    timezone: z.string().min(1).max(100),
+    title: z.string().max(TRUSTED_SUMMARY_OUTPUT_MAX).nullable(),
+    description: z.string().max(TRUSTED_TEXT_OUTPUT_MAX).nullable(),
+    location: z.string().max(TRUSTED_TEXT_OUTPUT_MAX).nullable(),
+    organizer: ORGANIZER.nullable(),
+    attendees: z.array(ATTENDEE).max(100),
+    reminders: z.array(REMINDER).max(20),
+    status: z.enum(['tentative', 'confirmed', 'cancelled']),
+    transparency: z.enum(['opaque', 'transparent']),
+    sequence: z.number().int().nonnegative(),
+    revision: REVISION,
+    recurrence_rule: z.string().max(TRUSTED_SUMMARY_OUTPUT_MAX).nullable(),
+    recurrence_exceptions: z
+        .array(RECURRENCE_EXCEPTION)
+        .max(TRUSTED_RECURRENCE_EXCEPTION_OUTPUT_MAX),
+    recurrence_id: DATE_TIME.nullable(),
+})
+    .strict();

package/ical-worker-thread.js

@@ -1,7 +1,7 @@
 // One worker of createICalendarWorkerPool: reads the feeds it is sent with the ordinary parsers and
 // posts back what they return, or the code of the CalendarContractError they throw.
 import { parentPort } from 'node:worker_threads';
-import { CalendarContractError, CalendarExpansionLimitError, parseICalendarChanges, parseTrustedICalendarEvents, } from './sync.js';
+import { CalendarContractError, CalendarExpansionLimitError, parseICalendarChanges, parseICalendarFeed, parseTrustedICalendarEvents, } from './sync.js';
 const port = parentPort;
 if (!port)
     throw new Error('slotlock: ical-worker-thread runs only as a worker thread');
@@ -10,7 +10,9 @@ port.on('message', (request) => {
     try {
         const value = request.op === 'changes'
             ? parseICalendarChanges(request.input, request.calendarTimezone, request.window)
-            : parseTrustedICalendarEvents(request.input, request.calendarTimezone);
+            : request.op === 'feed'
+                ? parseICalendarFeed(request.input, request.calendarTimezone, request.window)
+                : parseTrustedICalendarEvents(request.input, request.calendarTimezone);
         reply = { id: request.id, ok: true, value };
     }
     catch (error) {

package/ical-worker.d.ts

@@ -1,9 +1,9 @@
-import { CalendarContractError, type ExternalCalendarChange, type ICalendarExpansionWindow } from './sync.js';
+import { CalendarContractError, type ExternalCalendarChange, type ICalendarExpansionWindow, type ICalendarFeedRead } from './sync.js';
 import type { TrustedICalendarEvent } from './types.js';
 /** What the pool posts to a worker. */
 export type ICalendarWorkerRequest = {
     id: number;
-    op: 'changes';
+    op: 'changes' | 'feed';
     input: string;
     calendarTimezone: string | undefined;
     window: ICalendarExpansionWindow | undefined;
@@ -29,8 +29,8 @@ export interface ICalendarWorkerPoolOptions {
     size?: number;
     /**
      * How long one parse may run on its worker, in ms, before the worker is stopped and the feed
-     * refused (CalendarExpansionLimitError), 100-60,000. Defaults to 3,000: three times the parser's
-     * own limit, with room for a new worker to start.
+     * refused (CalendarExpansionLimitError), 100-60,000. Defaults to 3,000: several times what the
+     * parser's step budget takes, with room for a new worker to start.
      */
     deadlineMs?: number;
     /** Parses that may wait for a worker, 0-10,000; more are refused at once. Defaults to 64. */
@@ -46,6 +46,8 @@ export interface ICalendarWorkerPoolOptions {
 export interface ICalendarWorkerPool {
     /** `parseICalendarChanges`, run on a worker. */
     parseICalendarChanges(input: string, calendarTimezone?: string, expansionWindow?: ICalendarExpansionWindow): Promise<ExternalCalendarChange[]>;
+    /** `parseICalendarFeed`, run on a worker. */
+    parseICalendarFeed(input: string, calendarTimezone?: string, expansionWindow?: ICalendarExpansionWindow): Promise<ICalendarFeedRead>;
     /** `parseTrustedICalendarEvents`, run on a worker. */
     parseTrustedICalendarEvents(input: string, calendarTimezone?: string): Promise<TrustedICalendarEvent[]>;
     /** Refuse waiting parses and stop every worker. */
@@ -63,7 +65,8 @@ export declare class ICalendarWorkerPoolClosedError extends Error {
 }
 /**
  * A pool of worker threads that read untrusted iCalendar for the calling thread. Results and
- * errors are those of `parseICalendarChanges` and `parseTrustedICalendarEvents` (the same
+ * errors are those of `parseICalendarChanges`, `parseICalendarFeed` and
+ * `parseTrustedICalendarEvents` (the same
  * `CalendarContractError` codes), plus CalendarExpansionLimitError when a worker passes its
  * deadline or its heap, ICalendarWorkerBusyError when the queue is full, and
  * ICalendarWorkerPoolClosedError after `close()`. Idle workers do not keep the process alive.

package/ical-worker.js

@@ -31,7 +31,8 @@ function workerFailure(error) {
 }
 /**
  * A pool of worker threads that read untrusted iCalendar for the calling thread. Results and
- * errors are those of `parseICalendarChanges` and `parseTrustedICalendarEvents` (the same
+ * errors are those of `parseICalendarChanges`, `parseICalendarFeed` and
+ * `parseTrustedICalendarEvents` (the same
  * `CalendarContractError` codes), plus CalendarExpansionLimitError when a worker passes its
  * deadline or its heap, ICalendarWorkerBusyError when the queue is full, and
  * ICalendarWorkerPoolClosedError after `close()`. Idle workers do not keep the process alive.
@@ -134,7 +135,7 @@ export function createICalendarWorkerPool(options = {}) {
         if (request.calendarTimezone !== undefined && typeof request.calendarTimezone !== 'string') {
             throw new CalendarContractError('invalid_icalendar');
         }
-        if (request.op === 'changes' &&
+        if (request.op !== 'trusted' &&
             request.window !== undefined &&
             !(request.window?.start instanceof Date && request.window.end instanceof Date)) {
             throw new CalendarContractError('invalid_icalendar');
@@ -172,6 +173,12 @@ export function createICalendarWorkerPool(options = {}) {
                 window,
             }));
         },
+        async parseICalendarFeed(input, calendarTimezone, expansionWindow) {
+            const window = expansionWindow
+                ? { start: expansionWindow.start, end: expansionWindow.end }
+                : undefined;
+            return (await run({ op: 'feed', input, calendarTimezone, window }));
+        },
         async parseTrustedICalendarEvents(input, calendarTimezone) {
             return (await run({ op: 'trusted', input, calendarTimezone }));
         },

package/index.d.ts

@@ -1,8 +1,14 @@
 /// <reference types="node" preserve="true" />
 export { findNextAvailable, mergeIntervals, subtractBusy } from './engine.js';
+export { type SlotlockBookingRule, type SlotlockBookingRules, bookingRuleBroken, bookingSearch, nextStepStart, parseBookingRules, } from './booking-rules.js';
+export { type CreateWebhookEndpointResult, type ListChangesResult, SLOTLOCK_CHANGE_RETENTION_DAYS, SLOTLOCK_CHANGE_TYPES, SLOTLOCK_MAX_WEBHOOK_ENDPOINTS, SLOTLOCK_WEBHOOK_FAILING_LIMIT_MS, type SlotlockChange, type SlotlockChangeType, type SlotlockEventFeed, type SlotlockWebhookClaim, type SlotlockWebhookEndpoint, } from './event-feed.js';
+export { type SlotlockCloudEvent, type SlotlockWebhookPassResult, type SlotlockWebhookResponse, type SlotlockWebhookScheduler, type SlotlockWebhookSender, createSlotlockWebhookSender, deliverSlotlockWebhooks, isPrivateAddress, signSlotlockWebhook, slotlockCloudEvent, slotlockWebhookRetryDelayMs, startSlotlockWebhookDelivery, } from './webhooks.js';
+export { type SlotlockMetrics, createSlotlockMetrics } from './metrics.js';
 export { expandRules } from './rules.js';
 export { availabilityRuleProblem, parseAvailabilityRules, rulesToWeeklyHours, SLOTLOCK_MAX_AVAILABILITY_RULES, weeklyHoursToRules, } from './weekly-hours.js';
 export type { HoursWindow, Weekday, WeeklyHours } from './weekly-hours.js';
+export { emitVAvailability, parseVAvailability, recurrenceRuleFromRRule, SLOTLOCK_MAX_VAVAILABILITY_CHARACTERS, toJSCalendarEvent, } from './interop.js';
+export type { EmitVAvailabilityOptions, JSCalendarAlert, JSCalendarEvent, JSCalendarParticipant, JSCalendarRecurrenceRule, ParsedVAvailability, } from './interop.js';
 export { createTimeZoneConverter, zonedCalendarDate, zonedDateTimeToUtc, zonedWallTime, } from './timezone.js';
 export type { LocalDateTime, TimeZoneConverter, ZonedCalendarDate, ZonedWallTime, } from './timezone.js';
 export { createSlotlockAgentServer, clientSupportsSlotlockMcpApp, invokeSlotlockAgentOperation, isSlotlockAgentOperation, slotlockAgentTools, slotlockApplicationOperations, slotlockOpenApi, slotlockCalendarResourceUri, slotlockMcpToolResult, parseSlotlockA2ATimestamp, resolveSlotlockAgentOperation, slotlockAgentOperationScope, SLOTLOCK_A2A_PROTOCOL_VERSION, SLOTLOCK_A2A_TASK_PAGE_SIZE, SLOTLOCK_A2A_TASK_STATES, SLOTLOCK_AGENT_OPERATION_LEGACY_NAMES, SLOTLOCK_AGENT_SERVER_VERSION, SLOTLOCK_MCP_LEGACY_PROTOCOL_VERSION, SLOTLOCK_MCP_PROTOCOL_VERSION, SLOTLOCK_MCP_RATE_LIMITED_ERROR_CODE, SLOTLOCK_MCP_RESOURCE_URI_TEMPLATE, SLOTLOCK_MCP_SUPPORTED_PROTOCOL_VERSIONS, SLOTLOCK_MCP_APP_HTML, SLOTLOCK_MCP_APP_MIME_TYPE, SLOTLOCK_MCP_APP_RESOURCE, SLOTLOCK_MCP_APP_RESOURCE_URI, SLOTLOCK_MCP_APPS_EXTENSION, SlotlockAgentOperationError, } from './agent-server.js';
@@ -16,13 +22,13 @@ export type { SlotlockApplicationBackend, SlotlockApplicationInvocationContext,
 export { maintainSlotlockTenant, startSlotlockMaintenance, withSlotlockMaintenanceLock, } from './maintenance.js';
 export type { SlotlockMaintenanceResult, SlotlockMaintenanceScheduler, SlotlockMaintenanceSchedulerOptions, } from './maintenance.js';
 export { createSlotlockApiKeyAuthenticator, createSlotlockApiKeyStore, generateSlotlockApiKey, isSlotlockApiKey, slotlockApiKeyDigest, SLOTLOCK_API_KEY_ACTIVE_LIMIT, SLOTLOCK_API_KEY_MAX_LIFETIME_DAYS, SLOTLOCK_API_KEY_PREFIX, SLOTLOCK_API_KEY_RETAINED_LIMIT, SLOTLOCK_API_KEY_SCOPES, } from './api-keys.js';
-export { createSlotlockDashboard, createSlotlockDashboardResources, createSlotlockDashboardState, createSlotlockMemoryDashboardState, SLOTLOCK_DASHBOARD_MAX_RESOURCES, } from './dashboard.js';
+export { createSlotlockDashboard, createSlotlockDashboardResources, createSlotlockAcceptanceRecords, createSlotlockDashboardState, createSlotlockMemoryDashboardState, SLOTLOCK_DASHBOARD_MAX_RESOURCES, } from './dashboard.js';
 export type { SlotlockDashboard, SlotlockDashboardOptions, SlotlockDashboardResources, SlotlockDashboardState, } from './dashboard.js';
 export type { CreateSlotlockApiKeyInput, SlotlockApiKey, SlotlockApiKeyAuthenticatorOptions, SlotlockApiKeyIdentity, SlotlockApiKeyScope, SlotlockApiKeyStore, } from './api-keys.js';
 export { ICalendarWorkerBusyError, ICalendarWorkerPoolClosedError, createICalendarWorkerPool, } from './ical-worker.js';
 export type { ICalendarWorkerPool, ICalendarWorkerPoolOptions } from './ical-worker.js';
-export { CalendarContractError, CalendarExpansionLimitError, emitICalendar, emitITipCalendar, expandCalendarEventOccurrences, normalizeCalendarEventContent, normalizeExternalCalendarChange, parseICalendarChanges, parseTrustedICalendarEvents, } from './sync.js';
-export type { ExternalCalendarChange, ExternalCalendarChangeInput, ExternalCalendarStatus, ICalendarEvent, ICalendarExpansionWindow, ITipMethod, } from './sync.js';
-export { createSlotlockApplicationRoleGrantsDdl, createSlotlockTenantRlsDdl, SLOTLOCK_API_KEY_FUNCTIONS, SLOTLOCK_API_KEY_TABLES, SLOTLOCK_CORE_DDL, SLOTLOCK_DASHBOARD_FUNCTIONS, SLOTLOCK_DASHBOARD_TABLES, SLOTLOCK_DEFINER_FUNCTIONS, SLOTLOCK_DEFINER_TABLES, SLOTLOCK_TENANT_CONTEXT_SETTING, SLOTLOCK_TENANT_RLS_DDL, SLOTLOCK_TENANT_TABLES, } from './ddl.js';
-export { calendarEventRollingHorizon, createSlotlockStore, SLOTLOCK_AGENT_OWNER_COMMAND_QUOTA, SLOTLOCK_AGENT_OWNER_EVENT_QUOTA, SLOTLOCK_CALENDAR_HORIZON_DAYS, SLOTLOCK_EVENT_COMMAND_RETENTION_DAYS, SLOTLOCK_INTERNAL_EVENT_OWNER_REF, SLOTLOCK_LOCAL_RECURRENCE_COVERAGE_SOURCE, SLOTLOCK_MAX_EVENT_DURATION_DAYS, type SlotlockHoldTenantOptions, type SlotlockSql, type SlotlockStore, type SlotlockStoreOptions, type SlotlockTenantStore, } from './store.js';
-export type { AcquireHoldResult, CalendarAttendee, CalendarAttendeeRole, CalendarCoverageAssessment, CalendarCoverageCommand, CalendarCoverageResult, CalendarEventContent, CalendarEventOccurrence, CalendarEventRetentionResult, CalendarEventStatus, CalendarFreeBusy, CalendarHorizonRollCursor, CalendarHorizonRollResult, CalendarOrganizer, CalendarParticipationStatus, CalendarRecurrence, CalendarRecurrenceException, CalendarReminder, CalendarTransparency, ConfirmHoldResult, CancelCalendarEventResult, CancelExternalReservationResult, CreateReservationResult, ExternalReservationCommand, ExternalReservationResult, Interval, SlotlockHold, SlotlockCalendarEvent, SlotlockReservation, SlotlockResource, PutCalendarEventCommand, PutCalendarEventResult, ReleaseHoldResult, TrustedICalendarEvent, WeeklyAvailabilityRule, } from './types.js';
+export { CalendarContractError, CalendarExpansionLimitError, emitICalendar, emitITipCalendar, expandCalendarEventOccurrences, normalizeCalendarEventContent, normalizeExternalCalendarChange, parseICalendarChanges, parseICalendarFeed, parseTrustedICalendarEvents, recurrenceRuleProblem, storedCalendarEventProblem, } from './sync.js';
+export type { ExternalCalendarChange, ExternalCalendarChangeInput, ExternalCalendarStatus, ICalendarEvent, ICalendarExpansionWindow, ICalendarFeedRead, ICalendarSeriesRefusal, ITipMethod, } from './sync.js';
+export { createSlotlockApplicationRoleGrantsDdl, createSlotlockTenantRlsDdl, SLOTLOCK_API_KEY_FUNCTIONS, SLOTLOCK_API_KEY_TABLES, SLOTLOCK_CORE_DDL, SLOTLOCK_DASHBOARD_FUNCTIONS, SLOTLOCK_DASHBOARD_TABLES, SLOTLOCK_DEFINER_FUNCTIONS, SLOTLOCK_DEFINER_TABLES, SLOTLOCK_OPERATOR_FUNCTIONS, SLOTLOCK_SCHEMA_FUNCTIONS, SLOTLOCK_SCHEMA_TABLES, SLOTLOCK_SCHEMA_VERSION, SLOTLOCK_TENANT_ADMIN_FUNCTIONS, SLOTLOCK_TENANT_ADMIN_TABLES, SLOTLOCK_TENANT_CONTEXT_SETTING, SLOTLOCK_TENANT_RLS_DDL, SLOTLOCK_TENANT_TABLES, } from './ddl.js';
+export { assertSlotlockSchemaCurrent, calendarEventRollingHorizon, createSlotlockStore, readSlotlockSchemaVersion, SLOTLOCK_AGENT_OWNER_COMMAND_QUOTA, SLOTLOCK_AGENT_OWNER_EVENT_QUOTA, SLOTLOCK_CALENDAR_HORIZON_DAYS, SLOTLOCK_EVENT_COMMAND_RETENTION_DAYS, SLOTLOCK_INTERNAL_EVENT_OWNER_REF, SLOTLOCK_LOCAL_RECURRENCE_COVERAGE_SOURCE, SLOTLOCK_MATERIALIZATION_WINDOW_DAYS, SLOTLOCK_MAX_EVENT_DURATION_DAYS, SLOTLOCK_TENANT_WRITE_METHODS, type SlotlockHoldTenantOptions, type SlotlockMigrationOptions, type SlotlockSql, type SlotlockStore, type SlotlockStoreOptions, type SlotlockTenantLimits, type SlotlockTenantStore, } from './store.js';
+export type { AcquireHoldResult, BookingRetentionResult, CalendarAttendee, CalendarAttendeeRole, CalendarCoverageAssessment, CalendarCoverageCommand, CalendarCoverageResult, CalendarEventContent, CalendarEventOccurrence, CalendarEventRetentionResult, CalendarEventStatus, CalendarFreeBusy, CalendarHorizonRollCursor, CalendarHorizonRollResult, CalendarOrganizer, CalendarParticipationStatus, CalendarRecurrence, CalendarRecurrenceException, CalendarReminder, CalendarTransparency, ConfirmHoldResult, CancelCalendarEventResult, CancelExternalReservationResult, CreateReservationResult, DeleteResourceResult, ExternalReservationCommand, ExternalReservationResult, Interval, SlotlockAgendaEntry, SlotlockHold, SlotlockCalendarEvent, SlotlockReservation, SlotlockResource, SlotlockTenantErasure, PutCalendarEventCommand, PutCalendarEventResult, ReleaseHoldResult, TrustedICalendarEvent, WeeklyAvailabilityRule, } from './types.js';

package/index.js

@@ -4,8 +4,13 @@
 // TypeScript 6 default) still loads @types/node.
 /// <reference types="node" preserve="true" />
 export { findNextAvailable, mergeIntervals, subtractBusy } from './engine.js';
+export { bookingRuleBroken, bookingSearch, nextStepStart, parseBookingRules, } from './booking-rules.js';
+export { SLOTLOCK_CHANGE_RETENTION_DAYS, SLOTLOCK_CHANGE_TYPES, SLOTLOCK_MAX_WEBHOOK_ENDPOINTS, SLOTLOCK_WEBHOOK_FAILING_LIMIT_MS, } from './event-feed.js';
+export { createSlotlockWebhookSender, deliverSlotlockWebhooks, isPrivateAddress, signSlotlockWebhook, slotlockCloudEvent, slotlockWebhookRetryDelayMs, startSlotlockWebhookDelivery, } from './webhooks.js';
+export { createSlotlockMetrics } from './metrics.js';
 export { expandRules } from './rules.js';
 export { availabilityRuleProblem, parseAvailabilityRules, rulesToWeeklyHours, SLOTLOCK_MAX_AVAILABILITY_RULES, weeklyHoursToRules, } from './weekly-hours.js';
+export { emitVAvailability, parseVAvailability, recurrenceRuleFromRRule, SLOTLOCK_MAX_VAVAILABILITY_CHARACTERS, toJSCalendarEvent, } from './interop.js';
 export { createTimeZoneConverter, zonedCalendarDate, zonedDateTimeToUtc, zonedWallTime, } from './timezone.js';
 export { createSlotlockAgentServer, clientSupportsSlotlockMcpApp, invokeSlotlockAgentOperation, isSlotlockAgentOperation, slotlockAgentTools, slotlockApplicationOperations, slotlockOpenApi, slotlockCalendarResourceUri, slotlockMcpToolResult, parseSlotlockA2ATimestamp, resolveSlotlockAgentOperation, slotlockAgentOperationScope, SLOTLOCK_A2A_PROTOCOL_VERSION, SLOTLOCK_A2A_TASK_PAGE_SIZE, SLOTLOCK_A2A_TASK_STATES, SLOTLOCK_AGENT_OPERATION_LEGACY_NAMES, SLOTLOCK_AGENT_SERVER_VERSION, SLOTLOCK_MCP_LEGACY_PROTOCOL_VERSION, SLOTLOCK_MCP_PROTOCOL_VERSION, SLOTLOCK_MCP_RATE_LIMITED_ERROR_CODE, SLOTLOCK_MCP_RESOURCE_URI_TEMPLATE, SLOTLOCK_MCP_SUPPORTED_PROTOCOL_VERSIONS, SLOTLOCK_MCP_APP_HTML, SLOTLOCK_MCP_APP_MIME_TYPE, SLOTLOCK_MCP_APP_RESOURCE, SLOTLOCK_MCP_APP_RESOURCE_URI, SLOTLOCK_MCP_APPS_EXTENSION, SlotlockAgentOperationError, } from './agent-server.js';
 export { createSlotlockNodeServer } from './node-server.js';
@@ -13,8 +18,8 @@ export { createSlotlockStoreAgentBackend, createSlotlockStoreApplicationBackend,
 export { SLOTLOCK_APPLICATION_OPERATIONS, SLOTLOCK_APPLICATION_SCOPE, isSlotlockApplicationOperation, } from './application-api.js';
 export { maintainSlotlockTenant, startSlotlockMaintenance, withSlotlockMaintenanceLock, } from './maintenance.js';
 export { createSlotlockApiKeyAuthenticator, createSlotlockApiKeyStore, generateSlotlockApiKey, isSlotlockApiKey, slotlockApiKeyDigest, SLOTLOCK_API_KEY_ACTIVE_LIMIT, SLOTLOCK_API_KEY_MAX_LIFETIME_DAYS, SLOTLOCK_API_KEY_PREFIX, SLOTLOCK_API_KEY_RETAINED_LIMIT, SLOTLOCK_API_KEY_SCOPES, } from './api-keys.js';
-export { createSlotlockDashboard, createSlotlockDashboardResources, createSlotlockDashboardState, createSlotlockMemoryDashboardState, SLOTLOCK_DASHBOARD_MAX_RESOURCES, } from './dashboard.js';
+export { createSlotlockDashboard, createSlotlockDashboardResources, createSlotlockAcceptanceRecords, createSlotlockDashboardState, createSlotlockMemoryDashboardState, SLOTLOCK_DASHBOARD_MAX_RESOURCES, } from './dashboard.js';
 export { ICalendarWorkerBusyError, ICalendarWorkerPoolClosedError, createICalendarWorkerPool, } from './ical-worker.js';
-export { CalendarContractError, CalendarExpansionLimitError, emitICalendar, emitITipCalendar, expandCalendarEventOccurrences, normalizeCalendarEventContent, normalizeExternalCalendarChange, parseICalendarChanges, parseTrustedICalendarEvents, } from './sync.js';
-export { createSlotlockApplicationRoleGrantsDdl, createSlotlockTenantRlsDdl, SLOTLOCK_API_KEY_FUNCTIONS, SLOTLOCK_API_KEY_TABLES, SLOTLOCK_CORE_DDL, SLOTLOCK_DASHBOARD_FUNCTIONS, SLOTLOCK_DASHBOARD_TABLES, SLOTLOCK_DEFINER_FUNCTIONS, SLOTLOCK_DEFINER_TABLES, SLOTLOCK_TENANT_CONTEXT_SETTING, SLOTLOCK_TENANT_RLS_DDL, SLOTLOCK_TENANT_TABLES, } from './ddl.js';
-export { calendarEventRollingHorizon, createSlotlockStore, SLOTLOCK_AGENT_OWNER_COMMAND_QUOTA, SLOTLOCK_AGENT_OWNER_EVENT_QUOTA, SLOTLOCK_CALENDAR_HORIZON_DAYS, SLOTLOCK_EVENT_COMMAND_RETENTION_DAYS, SLOTLOCK_INTERNAL_EVENT_OWNER_REF, SLOTLOCK_LOCAL_RECURRENCE_COVERAGE_SOURCE, SLOTLOCK_MAX_EVENT_DURATION_DAYS, } from './store.js';
+export { CalendarContractError, CalendarExpansionLimitError, emitICalendar, emitITipCalendar, expandCalendarEventOccurrences, normalizeCalendarEventContent, normalizeExternalCalendarChange, parseICalendarChanges, parseICalendarFeed, parseTrustedICalendarEvents, recurrenceRuleProblem, storedCalendarEventProblem, } from './sync.js';
+export { createSlotlockApplicationRoleGrantsDdl, createSlotlockTenantRlsDdl, SLOTLOCK_API_KEY_FUNCTIONS, SLOTLOCK_API_KEY_TABLES, SLOTLOCK_CORE_DDL, SLOTLOCK_DASHBOARD_FUNCTIONS, SLOTLOCK_DASHBOARD_TABLES, SLOTLOCK_DEFINER_FUNCTIONS, SLOTLOCK_DEFINER_TABLES, SLOTLOCK_OPERATOR_FUNCTIONS, SLOTLOCK_SCHEMA_FUNCTIONS, SLOTLOCK_SCHEMA_TABLES, SLOTLOCK_SCHEMA_VERSION, SLOTLOCK_TENANT_ADMIN_FUNCTIONS, SLOTLOCK_TENANT_ADMIN_TABLES, SLOTLOCK_TENANT_CONTEXT_SETTING, SLOTLOCK_TENANT_RLS_DDL, SLOTLOCK_TENANT_TABLES, } from './ddl.js';
+export { assertSlotlockSchemaCurrent, calendarEventRollingHorizon, createSlotlockStore, readSlotlockSchemaVersion, SLOTLOCK_AGENT_OWNER_COMMAND_QUOTA, SLOTLOCK_AGENT_OWNER_EVENT_QUOTA, SLOTLOCK_CALENDAR_HORIZON_DAYS, SLOTLOCK_EVENT_COMMAND_RETENTION_DAYS, SLOTLOCK_INTERNAL_EVENT_OWNER_REF, SLOTLOCK_LOCAL_RECURRENCE_COVERAGE_SOURCE, SLOTLOCK_MATERIALIZATION_WINDOW_DAYS, SLOTLOCK_MAX_EVENT_DURATION_DAYS, SLOTLOCK_TENANT_WRITE_METHODS, } from './store.js';

package/interop.d.ts

@@ -0,0 +1,117 @@
+import type { SlotlockCalendarEvent, WeeklyAvailabilityRule } from './types.js';
+/** The longest VAVAILABILITY text `parseVAvailability` reads. */
+export declare const SLOTLOCK_MAX_VAVAILABILITY_CHARACTERS = 65536;
+export interface EmitVAvailabilityOptions {
+    /** The resource's weekly rules, in `timezone`. */
+    rules: readonly WeeklyAvailabilityRule[];
+    /** The IANA zone the rules are read in: every DTSTART names it as its TZID. */
+    timezone: string;
+    /** The VAVAILABILITY's UID; each AVAILABLE's is this with its index. */
+    uid: string;
+}
+/**
+ * A VCALENDAR with one VAVAILABILITY holding an AVAILABLE per rule: DTSTART on the rule's first day
+ * in a reference week of January 2024, with the IANA zone as TZID (no VTIMEZONE: RFC 7809 lets the
+ * two sides agree on IANA names), DURATION and the rule's RRULE. `[]` is a VAVAILABILITY with no
+ * AVAILABLE: never bookable. CRLF line endings, folded at 75 octets.
+ */
+export declare function emitVAvailability({ rules, timezone, uid }: EmitVAvailabilityOptions): string;
+export interface ParsedVAvailability {
+    /** The TZID every AVAILABLE named, `UTC` for UTC times, or null when they are all floating. */
+    timezone: string | null;
+    rules: WeeklyAvailabilityRule[];
+}
+/**
+ * Weekly rules from an iCalendar VAVAILABILITY (RFC 7953): one VAVAILABILITY, each AVAILABLE a
+ * weekly RRULE with a time of day and a length. Refuses (`invalid_availability`) what weekly
+ * rules cannot say: a VAVAILABILITY bounded by DTSTART or DTEND, more than one, an AVAILABLE
+ * without RRULE, with RDATE, EXDATE or RECURRENCE-ID, a whole-day DTSTART, seconds, AVAILABLEs in
+ * different zones, and any rule `parseAvailabilityRules` refuses. An RRULE without BYDAY takes
+ * DTSTART's day, as RFC 5545 reads it.
+ */
+export declare function parseVAvailability(text: string): ParsedVAvailability;
+/** A JSCalendar Event object (RFC 8984 §5.1): the properties Slotlock fills. */
+export interface JSCalendarEvent {
+    '@type': 'Event';
+    uid: string;
+    updated: string;
+    created: string;
+    sequence: number;
+    prodId: string;
+    title: string;
+    description?: string;
+    start: string;
+    timeZone: string;
+    duration: string;
+    status: 'confirmed' | 'tentative';
+    freeBusyStatus: 'free' | 'busy';
+    locations?: Record<string, {
+        '@type': 'Location';
+        name: string;
+    }>;
+    participants?: Record<string, JSCalendarParticipant>;
+    alerts?: Record<string, JSCalendarAlert>;
+    recurrenceRules?: JSCalendarRecurrenceRule[];
+    recurrenceOverrides?: Record<string, {
+        excluded: true;
+    } | {
+        start: string;
+        duration: string;
+    }>;
+    /** The RRULE the recurrence was written as, kept verbatim (RFC 8984 §3.3 vendor property). */
+    'slotlock.pylota.io:rrule'?: string;
+}
+export interface JSCalendarParticipant {
+    '@type': 'Participant';
+    name?: string;
+    email: string;
+    sendTo: {
+        imip: string;
+    };
+    roles: Record<string, true>;
+    participationStatus?: 'needs-action' | 'accepted' | 'declined' | 'tentative' | 'delegated';
+    expectReply?: boolean;
+}
+export interface JSCalendarAlert {
+    '@type': 'Alert';
+    trigger: {
+        '@type': 'OffsetTrigger';
+        offset: string;
+        relativeTo: 'start';
+    };
+    action: 'display' | 'email';
+}
+export interface JSCalendarRecurrenceRule {
+    '@type': 'RecurrenceRule';
+    frequency: 'yearly' | 'monthly' | 'weekly' | 'daily' | 'hourly' | 'minutely' | 'secondly';
+    interval?: number;
+    firstDayOfWeek?: string;
+    byDay?: {
+        '@type': 'NDay';
+        day: string;
+        nthOfPeriod?: number;
+    }[];
+    byMonthDay?: number[];
+    byMonth?: string[];
+    byYearDay?: number[];
+    byWeekNo?: number[];
+    byHour?: number[];
+    byMinute?: number[];
+    bySecond?: number[];
+    bySetPosition?: number[];
+    count?: number;
+    until?: string;
+}
+/**
+ * An RRULE as a JSCalendar RecurrenceRule (RFC 8984 §4.3.3), or null when it holds a part the
+ * mapping does not know (the verbatim RRULE is exported beside it either way). A UTC UNTIL becomes
+ * the wall time in `timezone`; a date UNTIL the end of that day.
+ */
+export declare function recurrenceRuleFromRRule(rrule: string, timezone: string): JSCalendarRecurrenceRule | null;
+/**
+ * A Slotlock calendar event as a JSCalendar Event (RFC 8984): its id as `uid`, its revision as
+ * `sequence`, start as a LocalDateTime in its zone with an exact duration, the organizer an
+ * `owner` participant, reminders `OffsetTrigger` alerts before the start, and the recurrence as
+ * `recurrenceRules` with `recurrenceOverrides` keyed by each exception's original start.
+ */
+export declare function toJSCalendarEvent(event: SlotlockCalendarEvent): JSCalendarEvent;