@digimuza/saas-core 0.0.2

package/dist/realtime/postgres.js

@@ -0,0 +1,151 @@
+/**
+ * The single PostgreSQL notification channel every message travels on.
+ *
+ * One PG channel rather than one per application channel, because `LISTEN` is
+ * per-connection and per-name: a workspace-per-channel design would mean
+ * thousands of `LISTEN` statements and constant `LISTEN`/`UNLISTEN` churn as
+ * clients come and go. Instead every server sees every message and filters to the
+ * channels it has authorized subscribers for.
+ *
+ * The trade-off is real: fan-out is O(servers), so at large scale every node
+ * decodes traffic it discards. That is the point at which to swap in a broker —
+ * which is why {@link RealtimeTransport} exists.
+ */
+export const PG_NOTIFY_CHANNEL = "saas_core_realtime";
+/**
+ * `pg_notify` rejects payloads over 8000 bytes. Staying under it with headroom
+ * for the envelope means a large event's `data` is dropped rather than the whole
+ * notification failing — the client re-reads the event by id.
+ */
+const MAX_PAYLOAD_BYTES = 7000;
+/** Shrink an over-large message rather than failing the notification. */
+export function encodeMessage(message, maxBytes = MAX_PAYLOAD_BYTES) {
+    const full = JSON.stringify(message);
+    if (Buffer.byteLength(full, "utf8") <= maxBytes) {
+        return full;
+    }
+    const { data: _dropped, ...rest } = message;
+    return JSON.stringify({ ...rest, truncated: true });
+}
+export function decodeMessage(payload) {
+    try {
+        const parsed = JSON.parse(payload);
+        /**
+         * Validated rather than cast. This payload arrived through the database, so
+         * anything with `NOTIFY` privileges could have written it — a shape check
+         * keeps a malformed or hostile notification from reaching subscribers as if
+         * it were a real event.
+         */
+        if (typeof parsed.channel !== "string" ||
+            typeof parsed.eventId !== "string" ||
+            typeof parsed.type !== "string" ||
+            typeof parsed.occurredAt !== "string") {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Realtime over PostgreSQL `LISTEN`/`NOTIFY`.
+ *
+ * The default transport because it adds no infrastructure: the database is
+ * already there. Browsers never touch `LISTEN`/`NOTIFY` — the server holds the
+ * listening connection and re-emits only what a given subscriber is authorized
+ * for, over SSE.
+ */
+export function createPostgresTransport(options) {
+    const notifyChannel = options.notifyChannel ?? PG_NOTIFY_CHANNEL;
+    const client = options.client;
+    /**
+     * Every local subscriber, each with the channel set it was authorized for.
+     *
+     * One database listener is shared across them all: a `LISTEN` per HTTP
+     * connection would exhaust the pool at a few hundred concurrent clients.
+     */
+    const subscribers = new Set();
+    let listening;
+    function handleNotification(payload) {
+        const message = decodeMessage(payload);
+        if (message === undefined) {
+            options.onError?.(new Error("Discarded a malformed realtime notification."));
+            return;
+        }
+        for (const subscriber of subscribers) {
+            // The authorization boundary: a subscriber only ever sees its own channels.
+            if (!subscriber.channels.has(message.channel)) {
+                continue;
+            }
+            try {
+                subscriber.onMessage(message);
+            }
+            catch (error) {
+                // One broken consumer must not stop delivery to the others.
+                options.onError?.(error);
+            }
+        }
+    }
+    async function ensureListening() {
+        listening ??= (async () => {
+            await client.listen(notifyChannel, handleNotification);
+        })();
+        try {
+            await listening;
+        }
+        catch (error) {
+            // Allow a later subscribe to retry rather than caching the failure.
+            listening = undefined;
+            throw error;
+        }
+    }
+    return {
+        name: "postgres",
+        async publish(messages) {
+            for (const message of messages) {
+                try {
+                    await client.notify(notifyChannel, encodeMessage(message));
+                }
+                catch (error) {
+                    /**
+                     * Realtime is best-effort by design. The event is already committed, so
+                     * a failed notification costs a client its live update, not the record
+                     * — and must not fail the operation that published it.
+                     */
+                    options.onError?.(error);
+                }
+            }
+        },
+        async subscribe(channels, onMessage) {
+            await ensureListening();
+            const subscriber = { channels: new Set(channels), onMessage };
+            subscribers.add(subscriber);
+            return {
+                close: async () => {
+                    subscribers.delete(subscriber);
+                },
+            };
+        },
+        async close() {
+            subscribers.clear();
+            if (listening !== undefined) {
+                listening = undefined;
+                await client.unlisten?.(notifyChannel);
+            }
+        },
+    };
+}
+/** Adapt a postgres.js `Sql` instance to {@link NotifyCapableClient}. */
+export function postgresJsNotifyClient(sql) {
+    return {
+        listen: async (channel, onNotify) => sql.listen(channel, onNotify),
+        notify: async (channel, payload) => {
+            if (typeof sql.notify !== "function") {
+                throw new Error("This postgres client does not support notify().");
+            }
+            return sql.notify(channel, payload);
+        },
+    };
+}
+//# sourceMappingURL=postgres.js.map

package/dist/realtime/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","sourceRoot":"","sources":["../../src/realtime/postgres.ts"],"names":[],"mappings":"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"}

package/dist/realtime/service.d.ts

@@ -0,0 +1,75 @@
+import type { SaasEvent } from "../events/registry.ts";
+import type { EventsService } from "../events/service.ts";
+import type { EventSchemaMap, Unsubscribe } from "../events/registry.ts";
+import type { WorkspacesService } from "../workspaces/service.ts";
+import type { RealtimeMessage, RealtimeSubscription, RealtimeTransport } from "./transport.ts";
+export interface AuthorizedChannels {
+    /** Channels the caller may receive. Safe to hand to a transport. */
+    readonly granted: readonly string[];
+    /**
+     * Channels refused, for the client's own diagnostics.
+     *
+     * Deliberately does not say *why*: "not a member" and "no such workspace" are
+     * the same answer, or a client could enumerate tenants by probing channels.
+     */
+    readonly denied: readonly string[];
+}
+export interface PublishOptions {
+    /**
+     * Extra channels beyond the event's own workspace — a user channel for
+     * something addressed to one person, for instance.
+     */
+    readonly channels?: readonly string[];
+}
+export interface SubscribeInput {
+    /** Resolved from the session. Never from a request body. */
+    readonly userId: string;
+    /** Requested by the client, therefore untrusted. */
+    readonly channels: readonly string[];
+    readonly onMessage: (message: RealtimeMessage) => void;
+}
+export interface RealtimeService {
+    /**
+     * Decide which of `channels` this user may receive.
+     *
+     * The one place channel access is decided. Transports do not filter, so a bug
+     * here is not caught downstream — and equally, there is only one rule to audit.
+     */
+    authorizeChannels(input: {
+        userId: string;
+        channels: readonly string[];
+    }): Promise<AuthorizedChannels>;
+    /** Project an event onto its channels and hand it to the transport. */
+    publish(event: SaasEvent, options?: PublishOptions): Promise<void>;
+    /**
+     * Authorize, then subscribe. Returns a subscription even when nothing was
+     * granted, so a caller has one code path.
+     */
+    subscribe(input: SubscribeInput): Promise<RealtimeSubscription & {
+        granted: readonly string[];
+    }>;
+    /**
+     * Mirror an events service onto the transport.
+     *
+     * Uses the existing `onAny` hook rather than reaching into the events service,
+     * so realtime stays an optional consumer of events and not a dependency of
+     * publishing.
+     */
+    attach<S extends EventSchemaMap>(events: EventsService<S>): Unsubscribe;
+}
+export interface RealtimeServiceDeps {
+    readonly transport: RealtimeTransport;
+    /** Used to verify workspace membership before granting a channel. */
+    readonly workspaces: Pick<WorkspacesService, "resolveContext">;
+    /**
+     * Which events reach clients at all.
+     *
+     * Defaults to workspace-scoped events only. Platform-wide events — a user
+     * being provisioned, say — have no tenant channel to go to, and broadcasting
+     * them would mean choosing an audience the event does not describe.
+     */
+    readonly broadcast?: (event: SaasEvent) => boolean;
+    readonly onError?: (error: unknown) => void;
+}
+export declare function createRealtimeService(deps: RealtimeServiceDeps): RealtimeService;
+//# sourceMappingURL=service.d.ts.map

package/dist/realtime/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/realtime/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAOlE,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE/F,MAAM,WAAW,kBAAkB;IACjC,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;CACxD;AAED,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;KAC7B,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAEhC,uEAAuE;IACvE,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnE;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,oBAAoB,GAAG;QAAE,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEjG;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,SAAS,cAAc,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;CACzE;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;IACtC,qEAAqE;IACrE,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,CAAC;IAC/D;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC;IACnD,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7C;AAMD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,GAAG,eAAe,CAkHhF"}

package/dist/realtime/service.js

@@ -0,0 +1,103 @@
+import { MAX_CHANNELS_PER_SUBSCRIPTION, parseChannel, userChannel, workspaceChannel, } from "./channels.js";
+function defaultBroadcast(event) {
+    return event.workspaceId !== null;
+}
+export function createRealtimeService(deps) {
+    const shouldBroadcast = deps.broadcast ?? defaultBroadcast;
+    function toMessage(event, channel) {
+        return {
+            channel,
+            eventId: event.id,
+            type: event.type,
+            occurredAt: event.occurredAt.toISOString(),
+            data: event.data,
+        };
+    }
+    const service = {
+        async authorizeChannels({ userId, channels }) {
+            const granted = [];
+            const denied = [];
+            // Bound the work a single unauthenticated-ish request can cause.
+            const requested = channels.slice(0, MAX_CHANNELS_PER_SUBSCRIPTION);
+            for (const extra of channels.slice(MAX_CHANNELS_PER_SUBSCRIPTION)) {
+                denied.push(extra);
+            }
+            // De-duplicated so a client repeating a channel cannot multiply the
+            // membership lookups it triggers.
+            for (const value of new Set(requested)) {
+                const channel = parseChannel(value);
+                if (channel === undefined) {
+                    denied.push(value);
+                    continue;
+                }
+                if (channel.kind === "user") {
+                    /**
+                     * A user channel is only ever your own. Comparing to the session's
+                     * user id is the whole check — there is no membership involved.
+                     */
+                    if (channel.userId === userId) {
+                        granted.push(value);
+                    }
+                    else {
+                        denied.push(value);
+                    }
+                    continue;
+                }
+                const context = await deps.workspaces.resolveContext({
+                    userId,
+                    workspaceId: channel.workspaceId,
+                });
+                if (context === undefined) {
+                    denied.push(value);
+                }
+                else {
+                    granted.push(value);
+                }
+            }
+            return { granted, denied };
+        },
+        async publish(event, options = {}) {
+            if (!shouldBroadcast(event)) {
+                return;
+            }
+            const channels = new Set(options.channels ?? []);
+            if (event.workspaceId !== null) {
+                channels.add(workspaceChannel(event.workspaceId));
+            }
+            if (channels.size === 0) {
+                return;
+            }
+            await deps.transport.publish([...channels].map((channel) => toMessage(event, channel)));
+        },
+        async subscribe({ userId, channels, onMessage }) {
+            const { granted } = await service.authorizeChannels({ userId, channels });
+            if (granted.length === 0) {
+                /**
+                 * Nothing authorized, so nothing is opened against the transport. The
+                 * caller still gets a subscription to close, which keeps its cleanup path
+                 * unconditional.
+                 */
+                return { granted, close: async () => undefined };
+            }
+            const subscription = await deps.transport.subscribe(granted, onMessage);
+            return { granted, close: () => subscription.close() };
+        },
+        attach(events) {
+            return events.onAny(async (event) => {
+                try {
+                    await service.publish(event);
+                }
+                catch (error) {
+                    /**
+                     * Realtime delivery must never fail a publish: the event is already
+                     * committed and durable, and a dropped live update is recoverable by
+                     * re-reading it.
+                     */
+                    deps.onError?.(error);
+                }
+            });
+        },
+    };
+    return service;
+}
+//# sourceMappingURL=service.js.map

package/dist/realtime/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../src/realtime/service.ts"],"names":[],"mappings":"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"}

package/dist/realtime/sse.d.ts

@@ -0,0 +1,55 @@
+import type { RealtimeService } from "./service.ts";
+/**
+ * A server-sent-event stream, as bytes plus the headers it needs.
+ *
+ * Deliberately not a `Response`. Returning one would tie this module to the fetch
+ * types and to a single framework; a stream and a header map compose with
+ * anything, including plain `node:http`.
+ */
+export interface EventStream {
+    readonly body: ReadableStream<Uint8Array>;
+    readonly headers: Record<string, string>;
+    /** Channels actually granted. Fewer than requested means some were refused. */
+    readonly granted: readonly string[];
+    close(): Promise<void>;
+}
+export interface EventStreamOptions {
+    readonly userId: string;
+    readonly channels: readonly string[];
+    /**
+     * Aborts the stream when the client disconnects.
+     *
+     * Without it a dropped connection leaks a subscription and a database listener
+     * slot for the lifetime of the process.
+     */
+    readonly signal?: AbortSignal;
+    /**
+     * Comment-only keep-alive interval. Defaults to 25 seconds — under the 30-second
+     * idle timeout most proxies and load balancers impose.
+     */
+    readonly heartbeatMs?: number;
+    /** Client reconnect delay hint, in milliseconds. */
+    readonly retryMs?: number;
+}
+/**
+ * Open an authorized SSE stream.
+ *
+ * ```ts
+ * // app/api/realtime/route.ts
+ * export async function GET(request: Request) {
+ *   const user = await auth.requireUser();
+ *   const stream = await createEventStream(realtime, {
+ *     userId: user.id,
+ *     channels: new URL(request.url).searchParams.getAll("channel"),
+ *     signal: request.signal,
+ *   });
+ *   return new Response(stream.body, { headers: stream.headers });
+ * }
+ * ```
+ *
+ * Channels are authorized before the stream opens, and unauthorized ones are
+ * silently dropped rather than failing the request — a client asking for a
+ * workspace it just left should keep receiving the rest.
+ */
+export declare function createEventStream(realtime: RealtimeService, options: EventStreamOptions): Promise<EventStream>;
+//# sourceMappingURL=sse.d.ts.map

package/dist/realtime/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/realtime/sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,oDAAoD;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAUD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,WAAW,CAAC,CA0GtB"}

package/dist/realtime/sse.js

@@ -0,0 +1,123 @@
+const DEFAULT_HEARTBEAT_MS = 25_000;
+const DEFAULT_RETRY_MS = 3_000;
+/** SSE frame. `id` lets a client resume with `Last-Event-ID`. */
+function frame(message) {
+    return `id: ${message.eventId}\nevent: ${message.type}\ndata: ${JSON.stringify(message)}\n\n`;
+}
+/**
+ * Open an authorized SSE stream.
+ *
+ * ```ts
+ * // app/api/realtime/route.ts
+ * export async function GET(request: Request) {
+ *   const user = await auth.requireUser();
+ *   const stream = await createEventStream(realtime, {
+ *     userId: user.id,
+ *     channels: new URL(request.url).searchParams.getAll("channel"),
+ *     signal: request.signal,
+ *   });
+ *   return new Response(stream.body, { headers: stream.headers });
+ * }
+ * ```
+ *
+ * Channels are authorized before the stream opens, and unauthorized ones are
+ * silently dropped rather than failing the request — a client asking for a
+ * workspace it just left should keep receiving the rest.
+ */
+export async function createEventStream(realtime, options) {
+    const encoder = new TextEncoder();
+    const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+    let heartbeat;
+    let closed = false;
+    let close = async () => undefined;
+    /**
+     * Frames that arrived before the stream was constructed.
+     *
+     * `subscribe` has to happen first — `granted` is part of the returned value —
+     * but `ReadableStream.start` does not run until the stream is built. Anything
+     * delivered in that window would otherwise be silently dropped.
+     */
+    const pending = [];
+    let enqueue = (chunk) => {
+        pending.push(chunk);
+    };
+    const subscription = await realtime.subscribe({
+        userId: options.userId,
+        channels: options.channels,
+        onMessage: (message) => {
+            enqueue(frame(message));
+        },
+    });
+    const body = new ReadableStream({
+        start(controller) {
+            const write = (chunk) => {
+                if (closed) {
+                    return;
+                }
+                try {
+                    controller.enqueue(encoder.encode(chunk));
+                }
+                catch {
+                    /**
+                     * The client went away between the readiness check and the write. Not
+                     * an error worth surfacing — tear down instead.
+                     */
+                    void close();
+                }
+            };
+            // Tells the browser how long to wait before reconnecting.
+            write(`retry: ${options.retryMs ?? DEFAULT_RETRY_MS}\n\n`);
+            // An immediate comment flushes headers, so the client's connection opens
+            // now rather than on the first real event.
+            write(`: connected\n\n`);
+            // Anything buffered during setup, in arrival order, then switch to direct
+            // writes for everything after.
+            for (const buffered of pending.splice(0, pending.length)) {
+                write(buffered);
+            }
+            enqueue = write;
+            heartbeat = setInterval(() => {
+                write(`: heartbeat\n\n`);
+            }, heartbeatMs);
+            // Do not hold the process open just for a keep-alive timer.
+            heartbeat.unref?.();
+            close = async () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                if (heartbeat !== undefined) {
+                    clearInterval(heartbeat);
+                }
+                await subscription.close();
+                try {
+                    controller.close();
+                }
+                catch {
+                    // Already closed by the runtime; nothing to do.
+                }
+            };
+            options.signal?.addEventListener("abort", () => void close(), { once: true });
+            if (options.signal?.aborted === true) {
+                void close();
+            }
+        },
+        cancel() {
+            return close();
+        },
+    });
+    return {
+        body,
+        granted: subscription.granted,
+        headers: {
+            "Content-Type": "text/event-stream",
+            // Proxies and CDNs must not buffer or cache a stream.
+            "Cache-Control": "no-cache, no-transform",
+            Connection: "keep-alive",
+            // Disables response buffering in nginx, which would defeat SSE entirely.
+            "X-Accel-Buffering": "no",
+        },
+        close: () => close(),
+    };
+}
+//# sourceMappingURL=sse.js.map

package/dist/realtime/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.js","sourceRoot":"","sources":["../../src/realtime/sse.ts"],"names":[],"mappings":"AAqCA,MAAM,oBAAoB,GAAG,MAAM,CAAC;AACpC,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAE/B,iEAAiE;AACjE,SAAS,KAAK,CAAC,OAAwB;IACrC,OAAO,OAAO,OAAO,CAAC,OAAO,YAAY,OAAO,CAAC,IAAI,WAAW,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC;AAChG,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,QAAyB,EACzB,OAA2B;IAE3B,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAClC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,oBAAoB,CAAC;IAEhE,IAAI,SAAqD,CAAC;IAC1D,IAAI,MAAM,GAAG,KAAK,CAAC;IACnB,IAAI,KAAK,GAAwB,KAAK,IAAI,EAAE,CAAC,SAAS,CAAC;IAEvD;;;;;;OAMG;IACH,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,IAAI,OAAO,GAA4B,CAAC,KAAK,EAAE,EAAE;QAC/C,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC,CAAC;IAEF,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC;QAC5C,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;YACrB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAC1B,CAAC;KACF,CAAC,CAAC;IAEH,MAAM,IAAI,GAAG,IAAI,cAAc,CAAa;QAC1C,KAAK,CAAC,UAAU;YACd,MAAM,KAAK,GAAG,CAAC,KAAa,EAAQ,EAAE;gBACpC,IAAI,MAAM,EAAE,CAAC;oBACX,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC;oBACH,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC5C,CAAC;gBAAC,MAAM,CAAC;oBACP;;;uBAGG;oBACH,KAAK,KAAK,EAAE,CAAC;gBACf,CAAC;YACH,CAAC,CAAC;YAEF,0DAA0D;YAC1D,KAAK,CAAC,UAAU,OAAO,CAAC,OAAO,IAAI,gBAAgB,MAAM,CAAC,CAAC;YAC3D,yEAAyE;YACzE,2CAA2C;YAC3C,KAAK,CAAC,iBAAiB,CAAC,CAAC;YAEzB,0EAA0E;YAC1E,+BAA+B;YAC/B,KAAK,MAAM,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;gBACzD,KAAK,CAAC,QAAQ,CAAC,CAAC;YAClB,CAAC;YACD,OAAO,GAAG,KAAK,CAAC;YAEhB,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE;gBAC3B,KAAK,CAAC,iBAAiB,CAAC,CAAC;YAC3B,CAAC,EAAE,WAAW,CAAC,CAAC;YAChB,4DAA4D;YAC5D,SAAS,CAAC,KAAK,EAAE,EAAE,CAAC;YAEpB,KAAK,GAAG,KAAK,IAAI,EAAE;gBACjB,IAAI,MAAM,EAAE,CAAC;oBACX,OAAO;gBACT,CAAC;gBACD,MAAM,GAAG,IAAI,CAAC;gBAEd,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;oBAC5B,aAAa,CAAC,SAAS,CAAC,CAAC;gBAC3B,CAAC;gBACD,MAAM,YAAY,CAAC,KAAK,EAAE,CAAC;gBAE3B,IAAI,CAAC;oBACH,UAAU,CAAC,KAAK,EAAE,CAAC;gBACrB,CAAC;gBAAC,MAAM,CAAC;oBACP,gDAAgD;gBAClD,CAAC;YACH,CAAC,CAAC;YAEF,OAAO,CAAC,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YAC9E,IAAI,OAAO,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,EAAE,CAAC;gBACrC,KAAK,KAAK,EAAE,CAAC;YACf,CAAC;QACH,CAAC;QAED,MAAM;YACJ,OAAO,KAAK,EAAE,CAAC;QACjB,CAAC;KACF,CAAC,CAAC;IAEH,OAAO;QACL,IAAI;QACJ,OAAO,EAAE,YAAY,CAAC,OAAO;QAC7B,OAAO,EAAE;YACP,cAAc,EAAE,mBAAmB;YACnC,sDAAsD;YACtD,eAAe,EAAE,wBAAwB;YACzC,UAAU,EAAE,YAAY;YACxB,yEAAyE;YACzE,mBAAmB,EAAE,IAAI;SAC1B;QACD,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE;KACrB,CAAC;AACJ,CAAC"}

package/dist/realtime/transport.d.ts

@@ -0,0 +1,52 @@
+/**
+ * One realtime delivery.
+ *
+ * A projection of a persisted event, not the event itself. Realtime is a
+ * delivery mechanism, never the source of truth: a client that missed a message
+ * re-reads from the `events` table.
+ */
+export interface RealtimeMessage {
+    /** Target channel, already authorized when it reaches a subscriber. */
+    readonly channel: string;
+    /** The `events.id` this projects, so a client can reconcile or re-fetch. */
+    readonly eventId: string;
+    readonly type: string;
+    /** ISO 8601. A string because this crosses a serialization boundary. */
+    readonly occurredAt: string;
+    /** Absent when the payload was too large to carry — see `truncated`. */
+    readonly data?: unknown;
+    /**
+     * True when `data` was dropped to fit the transport's size limit. The client
+     * should re-read the event by id rather than assume an empty payload.
+     */
+    readonly truncated?: boolean;
+}
+export interface RealtimeSubscription {
+    close(): Promise<void>;
+}
+/**
+ * The seam between the core and a realtime transport.
+ *
+ * Everything above this interface is transport-independent, so replacing the
+ * default PostgreSQL transport with Centrifugo, Soketi or a hosted service means
+ * writing an adapter rather than touching the service or its authorization.
+ *
+ * Implementations must not perform authorization. Channel access is decided once,
+ * server-side, before `subscribe` is called — a transport that also filtered
+ * would create two places for the rule to live and one of them would drift.
+ */
+export interface RealtimeTransport {
+    readonly name: string;
+    /** Fan out messages. Must not throw for an unknown channel. */
+    publish(messages: readonly RealtimeMessage[]): Promise<void>;
+    /**
+     * Deliver messages for exactly these channels.
+     *
+     * `channels` is already authorized. A transport must deliver to no channel
+     * outside the set.
+     */
+    subscribe(channels: readonly string[], onMessage: (message: RealtimeMessage) => void): Promise<RealtimeSubscription>;
+    /** Release transport-wide resources. */
+    close?(): Promise<void>;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/realtime/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/realtime/transport.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7D;;;;;OAKG;IACH,SAAS,CACP,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,SAAS,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,GAC5C,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEjC,wCAAwC;IACxC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB"}

package/dist/realtime/transport.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transport.js.map

package/dist/realtime/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/realtime/transport.ts"],"names":[],"mappings":""}

package/dist/storage/index.d.ts

@@ -0,0 +1,18 @@
+import { type StorageService } from "./service.ts";
+import type { StorageProvider } from "./provider.ts";
+export { assertKeyBelongsTo, assertObjectPath, isValidObjectPath, MAX_OBJECT_KEY_LENGTH, parseWorkspaceObjectKey, WORKSPACE_PREFIX, workspaceObjectKey, } from "./keys.ts";
+export { bodyBytes, createMemoryStorageProvider, type MemoryObject, type MemoryStorageOptions, type MemoryStorageProvider, } from "./memory.ts";
+export type { ObjectBody, ObjectStat, PutObjectInput, SignedDownloadInput, SignedUploadInput, SignedUrlInput, StorageProvider, StoredObject, } from "./provider.ts";
+export { createS3Provider, objectDigest, type S3ProviderOptions } from "./s3.ts";
+export { assertObjectExists, createStorageService, MAX_SIGNED_URL_SECONDS, type ScopedStorage, type StorageService, type StorageServiceDeps, type UploadInput, type UploadUrlOptions, type UrlOptions, } from "./service.ts";
+export { encodeObjectPath, presign, signingKey, uriEncode, type PresignInput, type PresignResult, type SigV4Credentials, } from "./sigv4.ts";
+/** An S3-compatible provider built from the `storage` configuration section. */
+export declare function createConfiguredStorageProvider(): StorageProvider;
+/**
+ * Default service, bound to configuration.
+ *
+ * The provider is a getter, so the `storage` configuration section resolves on
+ * first use — importing this module does not require credentials.
+ */
+export declare const storage: StorageService;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAuDA,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,SAAS,EACT,2BAA2B,EAC3B,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,YAAY,GACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjF,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,UAAU,GAChB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,gBAAgB,EAChB,OAAO,EACP,UAAU,EACV,SAAS,EACT,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,gBAAgB,GACtB,MAAM,YAAY,CAAC;AAEpB,gFAAgF;AAChF,wBAAgB,+BAA+B,IAAI,eAAe,CAajE;AAID;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,cAKpB,CAAC"}