@spfn/core 0.3.0-beta.3 → 0.3.0-beta.31

package/dist/router-CX5uVjmU.d.ts

@@ -0,0 +1,406 @@
+import { TSchema } from '@sinclair/typebox';
+
+/**
+ * Event System Types
+ */
+
+/**
+ * Pub/Sub capable cache interface for multi-instance events
+ */
+interface PubSubCache {
+    /**
+     * Publish a message to a channel
+     */
+    publish(channel: string, message: unknown): Promise<void>;
+    /**
+     * Subscribe to a channel
+     */
+    subscribe(channel: string, handler: (message: unknown) => void | Promise<void>): Promise<void>;
+}
+/**
+ * Event handler function type
+ */
+type EventHandler<TPayload> = (payload: TPayload) => void | Promise<void>;
+/**
+ * Options for `EventDef.subscribe`.
+ */
+interface EventSubscribeOptions {
+    /**
+     * Run only for an `emit` made in this process, never for a delivery the
+     * cache transport received from another pod. For a handler whose work must
+     * happen once per emit, not once per pod (it would otherwise run on every
+     * pod the event is cached to). Without a cache it runs on every `emit`.
+     */
+    localOnly?: boolean;
+}
+/**
+ * Job queue sender function type (used by job module)
+ */
+type JobQueueSender = (queueName: string, payload: unknown) => Promise<void>;
+/**
+ * What a contracted event promises to clients compiled separately from the
+ * server, written into `contracts/current.json` by `@spfn/core:contract`.
+ *
+ * The same version markers a route's `.contract()` carries; the payload shape
+ * is the event's own schema, so it is not repeated here.
+ */
+interface EventContract {
+    /** Contract version the event first appeared in. */
+    since: string;
+    /** Contract version the event was announced for removal in. */
+    deprecatedIn?: string;
+    /** Contract version the event was removed in. */
+    removedIn?: string;
+}
+/**
+ * What the stream request asked for, copied once at connect.
+ *
+ * A plain snapshot, never the live Hono context, so a frame filter can read it
+ * on every frame long after the request object is gone. Header names are
+ * lowercased. It may hold `cookie` and `authorization` values — never log it.
+ */
+interface SubscribeRequest {
+    /** Query parameters of the stream URL (`events`, `token` and any the app adds). */
+    query: Record<string, string>;
+    /** Request headers, names lowercased. */
+    headers: Record<string, string>;
+}
+/**
+ * What `.canSubscribe()` decides on, once per connection per requested event.
+ *
+ * `P` is whatever the SSE auth config's `resolvePrincipal` returns — core never
+ * knows what a principal is.
+ */
+interface SubscribeContext<P = unknown> {
+    /** The subject the one-time token was issued to. */
+    subject: string;
+    /** The value `resolvePrincipal` returned for this connection, `undefined` without one. */
+    principal: P | undefined;
+    /** The connect request snapshot. */
+    request: SubscribeRequest;
+}
+/**
+ * Decides at connect whether a subject may receive an event. `false` or a
+ * throw denies the event on that connection; the connection stays open.
+ */
+type SubscribePredicate<P = unknown> = (ctx: SubscribeContext<P>) => boolean | Promise<boolean>;
+/**
+ * The frames a connection receives right after `connected`, for its own
+ * subject and query. Asked once per connection, after `canSubscribe` allowed
+ * the event; a throw or a rejection sends nothing for the event.
+ */
+type InitialProducer<TPayload, P = unknown> = (ctx: SubscribeContext<P>) => TPayload[] | Promise<TPayload[]>;
+/**
+ * What a per-event `.filter()` sees on every frame.
+ */
+interface FrameContext {
+    /** The connection's subject, `undefined` when the stream runs without auth. */
+    subject: string | undefined;
+    /** The connect request snapshot. */
+    request: SubscribeRequest;
+}
+/**
+ * Decides per frame whether one connection receives one payload. Sync: it runs
+ * for every connection on every emit, so it matches the payload against what
+ * the connection asked for and never reads storage.
+ */
+type FramePredicate<TPayload> = (payload: TPayload, ctx: FrameContext) => boolean;
+/**
+ * Which of a subject's connections a `grant` / `revoke` reaches: those whose
+ * connect query carries every named field with exactly that value. A
+ * connection that declared no such field never matches. Plain JSON, so it
+ * travels to other pods unchanged.
+ */
+interface SubscriptionMatch {
+    query: Record<string, string>;
+}
+/**
+ * How an SSE handler lets `grant` / `revoke` reach its open connections.
+ * Each handler registers one per router key of the event.
+ */
+interface SubscriptionControl {
+    /** Activate the event on every open connection of `subject` (matching `match`, when given) where it is denied. */
+    grant: (subject: string, match?: SubscriptionMatch) => void;
+    /** Deactivate the event on every open connection of `subject` (matching `match`, when given) where it is allowed. */
+    revoke: (subject: string, match?: SubscriptionMatch) => void;
+}
+/**
+ * Event definition interface
+ */
+interface EventDef<TPayload = void> {
+    /**
+     * Unique event name
+     */
+    readonly name: string;
+    /**
+     * TypeBox payload schema (optional)
+     */
+    readonly schema?: TSchema;
+    /**
+     * The contract declared with `.contract()`, absent when the event is not
+     * part of the published contract.
+     *
+     * Named with an underscore because `.contract()` holds the plain name, as
+     * a router's `_contractVersion` sits beside `.contractVersion()`.
+     */
+    readonly _contract?: EventContract;
+    /**
+     * Publish this event in `contracts/current.json`.
+     *
+     * Sets the contract on this definition and returns it. An event is defined
+     * once and shared, so a second call throws instead of one of the two
+     * declarations silently winning.
+     */
+    contract: (contract: EventContract) => EventDef<TPayload>;
+    /**
+     * The predicate declared with `.canSubscribe()`, absent when any subject
+     * that passes the global `authorize` may subscribe.
+     */
+    readonly _canSubscribe?: SubscribePredicate<any>;
+    /**
+     * Declare who may subscribe to this event over SSE.
+     *
+     * Runs once per connection, after the global `authorize`, only when the
+     * connection has a subject. `P` is the type of the principal the SSE auth
+     * config's `resolvePrincipal` returns. Set once: a second call throws.
+     *
+     * @example
+     * ```typescript
+     * export const auditLogged = defineEvent('audit.logged', payload)
+     *     .canSubscribe<AuthPrincipal>(({ principal }) => principal?.role === 'admin');
+     * ```
+     */
+    canSubscribe: <P = unknown>(predicate: SubscribePredicate<P>) => EventDef<TPayload>;
+    /**
+     * The per-frame predicate declared with `.filter()`.
+     */
+    readonly _filter?: FramePredicate<TPayload>;
+    /**
+     * Declare which frames of this event a connection receives.
+     *
+     * Runs per frame on every connection subscribed to the event, with or
+     * without a subject, beside the global `filter` map (both must pass). Sync.
+     * Set once: a second call throws.
+     *
+     * @example
+     * ```typescript
+     * export const runtimeChanged = defineEvent('runtime.changed', payload)
+     *     .filter((payload, { request }) => payload.workspaceId === request.query.workspaceId);
+     * ```
+     */
+    filter: (predicate: FramePredicate<TPayload>) => EventDef<TPayload>;
+    /**
+     * The producer declared with `.initial()`, absent when a connection
+     * receives only the frames emitted after it opened.
+     */
+    readonly _initial?: InitialProducer<TPayload, any>;
+    /**
+     * Declare the frames a connection receives right after `connected`, before
+     * any live frame — the event's current value for that connection.
+     *
+     * Runs once per connection with a subject, for an event `canSubscribe`
+     * allowed, with the same context `canSubscribe` receives. Its frames skip
+     * the frame filters: they were produced for this connection. A throw sends
+     * nothing for the event and leaves it out of `connected.initial`. Never on
+     * a `grant`. Set once: a second call throws.
+     *
+     * @example
+     * ```typescript
+     * export const runtimeChanged = defineEvent('runtime.changed', payload)
+     *     .initial(async ({ request }) => [await readRuntime(request.query.workspaceId)]);
+     * ```
+     */
+    initial: <P = unknown>(producer: InitialProducer<TPayload, P>) => EventDef<TPayload>;
+    /**
+     * Subscribe to this event (in-memory handler). With the cache transport a
+     * handler runs on every pod for every emit, unless `{ localOnly: true }`
+     * keeps it to emits made in this process.
+     */
+    subscribe: (handler: EventHandler<TPayload>, options?: EventSubscribeOptions) => () => void;
+    /**
+     * Unsubscribe all handlers, `localOnly` ones included
+     */
+    unsubscribeAll: () => void;
+    /**
+     * Emit the event (triggers all subscribers and queued jobs)
+     */
+    emit: TPayload extends void ? () => Promise<void> : (payload: TPayload) => Promise<void>;
+    /**
+     * Activate this event on every open SSE connection of `subject` where it is
+     * denied — by `canSubscribe` or `authorize` at connect, or by a `revoke`.
+     *
+     * Reaches every pod when the cache transport is attached. Never re-runs
+     * `canSubscribe`: it is an operator's statement about an open connection.
+     * An event the connection never requested cannot be granted.
+     *
+     * With `match`, only the connections whose connect query carries every
+     * field of `match.query` with that value are activated.
+     */
+    grant: (subject: string, match?: SubscriptionMatch) => Promise<void>;
+    /**
+     * Deactivate this event on every open SSE connection of `subject` where it
+     * is allowed; the client receives a `subscription.revoked` frame.
+     *
+     * Reaches every pod when the cache transport is attached. Affects open
+     * connections only — the next connect asks `canSubscribe` afresh.
+     *
+     * With `match`, only the connections whose connect query carries every
+     * field of `match.query` with that value are deactivated.
+     */
+    revoke: (subject: string, match?: SubscriptionMatch) => Promise<void>;
+    /**
+     * Enable cache-based pub/sub for multi-instance support
+     * Must await before emitting events to ensure subscription is ready
+     */
+    useCache: (cache: PubSubCache) => Promise<EventDef<TPayload>>;
+    /**
+     * Internal: Register a job queue to receive this event
+     * Called by job registration system
+     */
+    _registerJobQueue: (queueName: string, sender: JobQueueSender) => void;
+    /**
+     * Internal: Let an SSE handler's connection registry receive `grant` /
+     * `revoke`. Called by `createSSEHandler` once per router key; every
+     * registered control receives every call. Returns the unregister function.
+     */
+    _registerSubscriptionControl: (control: SubscriptionControl) => () => void;
+    /**
+     * Internal: Drop the cache binding (cache + subscribed flag).
+     * Called by the event cache transport on shutdown so a later useCache can
+     * rebind a fresh cache in the same process.
+     */
+    _resetCache: () => void;
+    /**
+     * Type inference helper
+     */
+    _payload: TPayload;
+}
+/**
+ * Infer payload type from EventDef
+ */
+type InferEventPayload$1<TEvent> = TEvent extends EventDef<infer TPayload> ? TPayload : never;
+
+/**
+ * Event Router
+ *
+ * Type-safe event router for SSE subscription
+ *
+ * @example
+ * ```typescript
+ * import { defineEvent, defineEventRouter } from '@spfn/core/event';
+ * import { Type } from '@sinclair/typebox';
+ *
+ * const userCreated = defineEvent('user.created', Type.Object({
+ *     userId: Type.String(),
+ * }));
+ *
+ * const orderPlaced = defineEvent('order.placed', Type.Object({
+ *     orderId: Type.String(),
+ *     amount: Type.Number(),
+ * }));
+ *
+ * export const eventRouter = defineEventRouter({
+ *     userCreated,
+ *     orderPlaced,
+ * });
+ *
+ * export type EventRouter = typeof eventRouter;
+ * ```
+ */
+
+/**
+ * How a client reaches the contracted events of a router.
+ *
+ * Declared on the router because it is the stream's promise, not one event's:
+ * `createServer` checks it against `.events()` at boot, so the document cannot
+ * describe a path or an auth mode the server does not serve.
+ */
+interface EventRouterContract {
+    /**
+     * `'tokenExchange'` when `.events()` enables `auth` — the client first posts
+     * to the token path and opens the stream with `?token=`. `'none'` otherwise.
+     */
+    auth: 'none' | 'tokenExchange';
+    /**
+     * The stream path `.events()` registers.
+     * @default '/events/stream'
+     */
+    streamPath?: string;
+}
+/**
+ * What every router of events carries — the SSE event router and the
+ * WebSocket router alike.
+ *
+ * The WebSocket router builds on this rather than on `EventRouterDef`, because
+ * only an SSE event router can be contracted.
+ */
+interface EventRouterBase<TEvents extends Record<string, EventDef<any>>> {
+    /**
+     * Event definitions
+     */
+    readonly events: TEvents;
+    /**
+     * Event names as array
+     */
+    readonly eventNames: (keyof TEvents)[];
+    /**
+     * Type inference helper - payload types by event name
+     */
+    readonly _types: {
+        [K in keyof TEvents]: TEvents[K]['_payload'];
+    };
+}
+/**
+ * Event Router Definition
+ */
+interface EventRouterDef<TEvents extends Record<string, EventDef<any>>> extends EventRouterBase<TEvents> {
+    /**
+     * The contract declared with `.contract()`, absent when the router declares
+     * none. Underscored for the same reason as `EventDef._contract`.
+     */
+    readonly _contract?: EventRouterContract;
+    /**
+     * Declare how a client reaches this router's contracted events.
+     *
+     * Sets the contract on this router and returns it. A `streamPath` that does
+     * not start with `/` throws here, where the typo is.
+     */
+    contract: (contract: EventRouterContract) => EventRouterDef<TEvents>;
+}
+/**
+ * Infer event names from EventRouter
+ */
+type InferEventNames<T> = T extends EventRouterBase<infer E> ? keyof E & string : never;
+/**
+ * Infer payload type for specific event
+ */
+type InferEventPayload<T extends EventRouterBase<any>, K extends InferEventNames<T>> = T['_types'][K];
+/**
+ * Infer all event payloads map
+ */
+type InferEventPayloads<T extends EventRouterBase<any>> = T['_types'];
+/**
+ * Define an event router for SSE subscription
+ *
+ * `.contract({ auth })` on the router, together with `.contract({ since })` on
+ * its events, publishes those events in `contracts/current.json` — see the
+ * contract README.
+ *
+ * @example
+ * ```typescript
+ * export const eventRouter = defineEventRouter({
+ *     userCreated,
+ *     orderPlaced,
+ * });
+ *
+ * // Type inference
+ * type Names = InferEventNames<typeof eventRouter>;
+ * // 'userCreated' | 'orderPlaced'
+ *
+ * type Payload = InferEventPayload<typeof eventRouter, 'userCreated'>;
+ * // { userId: string }
+ * ```
+ */
+declare function defineEventRouter<TEvents extends Record<string, EventDef<any>>>(events: TEvents): EventRouterDef<TEvents>;
+
+export { type EventRouterDef as E, type FrameContext as F, type InferEventNames as I, type JobQueueSender as J, type PubSubCache as P, type SubscribeContext as S, type EventDef as a, type EventContract as b, type EventHandler as c, type EventRouterContract as d, type EventSubscribeOptions as e, type FramePredicate as f, type InferEventPayload$1 as g, type InferEventPayloads as h, type InferEventPayload as i, type InitialProducer as j, type SubscribePredicate as k, type SubscribeRequest as l, type SubscriptionMatch as m, defineEventRouter as n, type EventRouterBase as o };

package/dist/server/index.d.ts

@@ -5,13 +5,20 @@ import { serve } from '@hono/node-server';
 import { NamedMiddleware, Router } from '@spfn/core/route';
 import { OnErrorContext, ProxyGuardConfig, RateLimitOptions } from '@spfn/core/middleware';
 import { SafeFetchPolicy } from '@spfn/core/security';
-import { c as JobRouter, e as BossOptions } from '../boss-D16fO2oG.js';
-import { b as EventRouterDef, E as EventDef } from '../token-manager-BT5EnUAR.js';
-import { d as SSEHandlerConfig, e as SSEAuthConfig } from '../types-ZQODsBft.js';
-import { W as WSRouterDef, f as WSHandlerConfig, e as WSMessageHandlers, g as WSAuthConfig } from '../types-2AbaW4Ie.js';
+import { c as JobRouter, f as BossOptions } from '../boss-BiDCbbAQ.js';
+import { E as EventRouterDef, a as EventDef } from '../router-CX5uVjmU.js';
+import { d as SSEHandlerConfig, e as SSEAuthConfig } from '../types-CurMab2Q.js';
+import { W as WSRouterDef, f as WSHandlerConfig, e as WSMessageHandlers, g as WSAuthConfig } from '../types-DncqXfWN.js';
 import { DatabaseProvider, MigrationStatus, MigrationStatusDb } from '@spfn/core/db';
-import '@sinclair/typebox';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { Static } from '@sinclair/typebox';
+import { R as RouteDef } from '../route-builder-DRW-MSCJ.js';
+import { a as EnvRegistry } from '../registry-C2KQCh0m.js';
 import 'pg-boss';
+import '../token-manager-Ckjt2-qq.js';
+import '../define-middleware-CVKgqo8S.js';
+import 'hono/utils/http-status';
+import '../route/types.js';
 
 /**
  * @deprecated Use `loadEnv` from '@spfn/core/env/loader' instead.
@@ -22,6 +29,33 @@ import 'pg-boss';
  */
 declare function loadEnvFiles(): void;
 
+/** Stable operation identity used by separately deployed clients. */
+declare const CORE_TIME_OPERATION_ID = "core.time";
+/**
+ * Closed response shape for the server-time wire capability.
+ *
+ * Millisecond timestamps use integers throughout SPFN's external contracts.
+ */
+declare const ServerTimeResponseSchema: _sinclair_typebox.TObject<{
+    serverTimeMillis: _sinclair_typebox.TInteger;
+}>;
+type ServerTimeResponse = Static<typeof ServerTimeResponseSchema>;
+/** Injectable source of Unix epoch milliseconds. */
+interface ServerClock {
+    now(): number;
+}
+/**
+ * Build the route from a clock so tests and alternate runtimes can supply the
+ * epoch source without replacing global time.
+ */
+declare function createCoreTimeRoute(clock?: ServerClock): RouteDef<{}, {}, {
+    serverTimeMillis: number;
+}>;
+/** The production route and the public wire-contract source of truth. */
+declare const CORE_TIME_ROUTE: RouteDef<{}, {}, {
+    serverTimeMillis: number;
+}>;
+
 /**
  * Workflow router interface for @spfn/core integration
  *
@@ -202,6 +236,8 @@ interface ServerConfig {
      * Jobs defined with job()...handler() style
      * Uses pg-boss for PostgreSQL-based job queue
      *
+     * Merged across every `.jobs()` call, so this holds all of them.
+     *
      * @example
      * ```typescript
      * import { job, defineJobRouter } from '@spfn/core/job';
@@ -489,6 +525,15 @@ interface ServerConfig {
          */
         detailed?: boolean;
     };
+    /**
+     * Server-time capability dependencies.
+     *
+     * The endpoint is always enabled at `GET /_core/time`. Supplying a clock is
+     * primarily a deterministic test seam; production defaults to `Date.now()`.
+     */
+    serverTime?: {
+        clock?: ServerClock;
+    };
     /**
      * Migration boot gate
      *
@@ -510,6 +555,35 @@ interface ServerConfig {
          */
         allowPending?: boolean;
     };
+    /**
+     * Environment boot check
+     *
+     * Before serving, the server validates every variable of `@spfn/core`'s
+     * registry and of the registries listed here: a required variable must be
+     * set, and a set variable must pass its `validator`. On failure it logs
+     * each key with the reason — never a value — and refuses to start.
+     * `SKIP_ENV_VALIDATION` does not skip this check.
+     *
+     * @example
+     * ```typescript
+     * // src/server/config/env.config.ts
+     * export const envSchema = defineEnvSchema({ ... });
+     * export const envRegistry = createEnvRegistry(envSchema);
+     * export const env = envRegistry.validate();
+     *
+     * // src/server/server.config.ts
+     * export default defineServerConfig()
+     *     .env({ registries: [envRegistry] })
+     *     .build();
+     * ```
+     */
+    env?: {
+        /**
+         * Registries checked alongside `@spfn/core`'s: the app's own, and any
+         * package registry the app wants held to the same gate.
+         */
+        registries?: EnvRegistry<any>[];
+    };
     /**
      * Infrastructure initialization control
      * Controls automatic initialization of database and Redis
@@ -757,6 +831,13 @@ declare const CORE_NAMESPACE = "/_core";
  * balancer console — and a version bump migrates none of them.
  */
 declare const CORE_HEALTH_PATH = "/_core/health";
+/**
+ * Where clients obtain the server's current Unix epoch in milliseconds.
+ *
+ * This endpoint is registered before application routes and application auth
+ * middleware so a client can call it before it has a proof or session.
+ */
+declare const CORE_TIME_PATH = "/_core/time";
 
 /**
  * Start SPFN Server
@@ -768,6 +849,8 @@ declare const CORE_HEALTH_PATH = "/_core/health";
  * Start SPFN server
  *
  * Automatically loads server.config.ts if exists
+ * Validates the environment (core's registry + `config.env.registries`) and
+ * exits with code 1 when a variable is missing or invalid
  * Automatically initializes Database and Redis from environment
  * Sets up graceful shutdown handlers for SIGTERM and SIGINT
  *
@@ -911,6 +994,9 @@ declare function getShutdownManager(): ShutdownManager;
  *   - does NOT run seed/RBAC provisioning per cold start — that moves to a
  *     deploy-time step, see {@link provisionInfrastructure}.
  *
+ * Like {@link startServer}, it runs the environment boot check before building
+ * the app; a failure rejects the returned promise instead of exiting.
+ *
  * `startServer()` / `spfn start` (the always-on path) is unchanged by this module.
  */
 
@@ -1097,6 +1183,20 @@ declare class ServerConfigBuilder {
     /**
      * Register background jobs router
      *
+     * May be called once per domain router: repeated calls **merge** into one
+     * router, the way `.routes()` composes. Calling it several times used to
+     * keep only the last router and register nothing else, without warning.
+     *
+     * The pg-boss `config` is per server, so pass it on one call only.
+     *
+     * Two names can collide, and both fail loudly:
+     * - a router **key** present in two calls throws here, at config time;
+     * - two jobs sharing a **`job.name`** (the pg-boss queue name) throw in
+     *   `registerJobs()` at boot, before any queue or worker is created.
+     *
+     * @throws if a router key was already registered by an earlier call
+     * @throws if `config` is given when an earlier call already gave one
+     *
      * @example
      * ```typescript
      * import { job, defineJobRouter } from '@spfn/core/job';
@@ -1109,7 +1209,8 @@ declare class ServerConfigBuilder {
      *
      * export default defineServerConfig()
      *   .routes(appRouter)
-     *   .jobs(jobRouter)
+     *   .jobs(jobRouter, { clearOnStart: isDev })   // config on one call only
+     *   .jobs(billingJobRouter)                     // merged, not replaced
      *   .build();
      * ```
      */
@@ -1197,6 +1298,12 @@ declare class ServerConfigBuilder {
      * Configure health check endpoint
      */
     healthCheck(healthCheck: ServerConfig['healthCheck']): this;
+    /**
+     * Supply the clock used by the built-in `GET /_core/time` capability.
+     * Production servers normally keep the default `Date.now()` clock; this is
+     * exposed so tests can assert an exact wire value without replacing globals.
+     */
+    serverTime(serverTime: ServerConfig['serverTime']): this;
     /**
      * Configure infrastructure initialization
      */
@@ -1213,6 +1320,22 @@ declare class ServerConfigBuilder {
      * ```
      */
     migrations(migrations: ServerConfig['migrations']): this;
+    /**
+     * Hand the app's env registries to the boot check
+     *
+     * `@spfn/core`'s own registry is always checked; the registries given here
+     * are checked with it, before the server listens.
+     *
+     * @example
+     * ```typescript
+     * import { envRegistry } from '@/server/config/env.config';
+     *
+     * export default defineServerConfig()
+     *     .env({ registries: [envRegistry] })
+     *     .build();
+     * ```
+     */
+    env(env: ServerConfig['env']): this;
     /**
      * Register workflow router for workflow orchestration
      *
@@ -1273,4 +1396,4 @@ declare class ServerConfigBuilder {
  */
 declare function defineServerConfig(): ServerConfigBuilder;
 
-export { type AppFactory, CORE_HEALTH_PATH, CORE_NAMESPACE, type MigrationSnapshot, PendingMigrationsError, type ServerConfig, type ServerInstance, type ShutdownHookOptions, createServer, createServerlessApp, defineServerConfig, getMigrationSnapshot, getShutdownManager, loadEnvFiles, provisionInfrastructure, resetMigrationSnapshot, resetServerlessApp, startServer };
+export { type AppFactory, CORE_HEALTH_PATH, CORE_NAMESPACE, CORE_TIME_OPERATION_ID, CORE_TIME_PATH, CORE_TIME_ROUTE, type MigrationSnapshot, PendingMigrationsError, type ServerClock, type ServerConfig, type ServerInstance, type ServerTimeResponse, ServerTimeResponseSchema, type ShutdownHookOptions, createCoreTimeRoute, createServer, createServerlessApp, defineServerConfig, getMigrationSnapshot, getShutdownManager, loadEnvFiles, provisionInfrastructure, resetMigrationSnapshot, resetServerlessApp, startServer };