@syncular/server 0.32.0 → 0.33.0

package/dist/bucket-segment-store.js

@@ -0,0 +1,445 @@
+import { mergeSegmentRecord, publicationRecord, publicationsForRecord, segmentBytesEqual, segmentIdFor, selectSegmentPublication, } from './segment-store.js';
+import { sha256Hex } from './sigv4.js';
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const SEGMENT_ID_PATTERN = /^sha256:[0-9a-f]{64}$/;
+/** Legacy record carried in the bytes object's user metadata. */
+const LEGACY_RECORD_META_KEY = 'syncular-record';
+/**
+ * Stats accumulator (§ "S3 stats" in the README). The store keeps a small
+ * counter object under a fixed key, updated read-modify-write on `put`. It
+ * exists because a LIST-free store (every lookup is a GET/HEAD) has no cheap
+ * way to count objects on demand — so `stats()` reads the accumulator instead
+ * of enumerating the bucket.
+ *
+ * The write is guarded by an ETag compare-and-swap (`ifMatch`, or `createOnly`
+ * to create): the loop re-reads and retries on a failed precondition, so
+ * concurrent writers do not silently clobber each other's increment. The
+ * counters are still APPROXIMATE — a crash between the segment PUT and the
+ * accumulator CAS, or a writer against a backend that ignores conditional
+ * writes, can drift them — so the admin surface labels these stats
+ * `approximate: true`. They are a health gauge, not an invoice.
+ */
+const STATS_KEY_SUFFIX = 'stats/segments.json';
+const CAS_ATTEMPTS = 16;
+function emptyStats() {
+    return { count: 0, bytes: 0, rowsSegments: 0, sqliteSegments: 0 };
+}
+function parseStatsJson(json) {
+    const parsed = JSON.parse(json);
+    return {
+        count: Number(parsed.count ?? 0),
+        bytes: Number(parsed.bytes ?? 0),
+        rowsSegments: Number(parsed.rowsSegments ?? 0),
+        sqliteSegments: Number(parsed.sqliteSegments ?? 0),
+    };
+}
+// Runtime-neutral base64url: `Buffer` is not present on
+// Cloudflare Workers without `nodejs_compat`, so a legacy object-metadata
+// record header is decoded with `atob`, available in every runtime.
+function base64urlToUtf8(value) {
+    const binary = atob(value.replaceAll('-', '+').replaceAll('_', '/'));
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+}
+function recordToJson(record) {
+    return JSON.stringify(record);
+}
+function isMediaType(value) {
+    return value === 'rows' || value === 'sqlite';
+}
+/** One publication inside a stored record (or a legacy materialized one). */
+function parsePublication(value, source, label) {
+    if (typeof value !== 'object' || value === null) {
+        throw new Error(`${label}: corrupt publication in ${source}`);
+    }
+    const p = value;
+    const strings = ['partition', 'logEpoch', 'table', 'scopeDigest'];
+    const numbers = [
+        'schemaVersion',
+        'asOfCommitSeq',
+        'rowCount',
+        'byteLength',
+        'createdAtMs',
+        'expiresAtMs',
+    ];
+    for (const field of strings) {
+        if (typeof p[field] !== 'string') {
+            throw new Error(`${label}: bad publication field ${field} in ${source}`);
+        }
+    }
+    for (const field of numbers) {
+        if (typeof p[field] !== 'number') {
+            throw new Error(`${label}: bad publication field ${field} in ${source}`);
+        }
+    }
+    if (!isMediaType(p.mediaType)) {
+        throw new Error(`${label}: bad publication mediaType in ${source}`);
+    }
+    const cursorOk = (v) => v === null || typeof v === 'string';
+    if (!cursorOk(p.rowCursor) || !cursorOk(p.nextRowCursor)) {
+        throw new Error(`${label}: bad publication cursor in ${source}`);
+    }
+    return {
+        partition: p.partition,
+        logEpoch: p.logEpoch,
+        table: p.table,
+        schemaVersion: p.schemaVersion,
+        mediaType: p.mediaType,
+        scopeDigest: p.scopeDigest,
+        asOfCommitSeq: p.asOfCommitSeq,
+        rowCount: p.rowCount,
+        rowCursor: p.rowCursor,
+        nextRowCursor: p.nextRowCursor,
+        byteLength: p.byteLength,
+        createdAtMs: p.createdAtMs,
+        expiresAtMs: p.expiresAtMs,
+    };
+}
+function parseRecordJson(json, source, label) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        throw new Error(`${label}: corrupt record JSON in ${source}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error(`${label}: corrupt record in ${source}`);
+    }
+    const r = parsed;
+    const strings = [
+        'segmentId',
+        'partition',
+        'logEpoch',
+        'table',
+        'scopeDigest',
+    ];
+    const numbers = [
+        'schemaVersion',
+        'asOfCommitSeq',
+        'rowCount',
+        'byteLength',
+        'createdAtMs',
+        'expiresAtMs',
+    ];
+    for (const field of strings) {
+        if (typeof r[field] !== 'string') {
+            throw new Error(`${label}: bad record field ${field} in ${source}`);
+        }
+    }
+    for (const field of numbers) {
+        if (typeof r[field] !== 'number') {
+            throw new Error(`${label}: bad record field ${field} in ${source}`);
+        }
+    }
+    if (!isMediaType(r.mediaType)) {
+        throw new Error(`${label}: bad record mediaType in ${source}`);
+    }
+    const cursorOk = (v) => v === null || typeof v === 'string';
+    if (!cursorOk(r.rowCursor) || !cursorOk(r.nextRowCursor)) {
+        throw new Error(`${label}: bad record cursor in ${source}`);
+    }
+    const scopeDigest = r.scopeDigest;
+    // Records written before §5.1 recorded the digest set carry only the
+    // primary digest; the object is a cache entry with a TTL, so reading it
+    // back as a one-digest record is correct, not a degraded path.
+    const rawDigests = r.scopeDigests;
+    if (rawDigests !== undefined &&
+        (!Array.isArray(rawDigests) ||
+            rawDigests.some((digest) => typeof digest !== 'string'))) {
+        throw new Error(`${label}: bad record scopeDigests in ${source}`);
+    }
+    const rawPublications = r.publications;
+    if (rawPublications !== undefined && !Array.isArray(rawPublications)) {
+        throw new Error(`${label}: bad record publications in ${source}`);
+    }
+    const top = {
+        segmentId: r.segmentId,
+        partition: r.partition,
+        logEpoch: r.logEpoch,
+        table: r.table,
+        schemaVersion: r.schemaVersion,
+        mediaType: r.mediaType,
+        scopeDigest,
+        scopeDigests: [
+            scopeDigest,
+            ...(rawDigests ?? []).filter((digest) => digest !== scopeDigest),
+        ],
+        asOfCommitSeq: r.asOfCommitSeq,
+        rowCount: r.rowCount,
+        rowCursor: r.rowCursor,
+        nextRowCursor: r.nextRowCursor,
+        byteLength: r.byteLength,
+        createdAtMs: r.createdAtMs,
+        expiresAtMs: r.expiresAtMs,
+    };
+    return {
+        ...top,
+        // A record from before per-publication provenance, or a legacy record
+        // whose union came from object metadata, materializes its publications
+        // from the merged top-level context — the old single-record read.
+        publications: rawPublications === undefined
+            ? publicationsForRecord(top)
+            : rawPublications.map((value) => parsePublication(value, source, label)),
+    };
+}
+export class BucketSegmentStore {
+    #bucket;
+    #ttlMs;
+    #prefix;
+    /** Error prefix: the concrete store class the host constructed. */
+    #label;
+    constructor(bucket, options) {
+        this.#bucket = bucket;
+        this.#ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+        this.#prefix = options?.keyPrefix ?? '';
+        this.#label = this.constructor.name;
+    }
+    /** `{keyPrefix}seg/sha256/{hex}` — the §5.4 "key embeds the segmentId". */
+    objectKeyFor(segmentId) {
+        return `${this.#prefix}seg/${segmentId.replace(':', '/')}`;
+    }
+    /** `{keyPrefix}rec/sha256/{hex}.json` — the §5.1 record (§5.1 union). */
+    #recordKeyFor(segmentId) {
+        return `${this.#prefix}rec/${segmentId.replace(':', '/')}.json`;
+    }
+    async #findKeyFor(key) {
+        const canonical = JSON.stringify([
+            key.partition,
+            key.logEpoch,
+            key.table,
+            key.schemaVersion,
+            key.mediaType,
+            key.scopeDigest,
+            key.asOfCommitSeq,
+        ]);
+        return `${this.#prefix}find/${await sha256Hex(canonical)}.json`;
+    }
+    #statsKey() {
+        return `${this.#prefix}${STATS_KEY_SUFFIX}`;
+    }
+    /** Read the stats accumulator + its ETag (for the CAS write), or none. */
+    async #readStats() {
+        const object = await this.#bucket.get(this.#statsKey());
+        if (object === undefined) {
+            return { stats: emptyStats(), etag: undefined };
+        }
+        return {
+            stats: parseStatsJson(await object.text()),
+            etag: object.etag,
+        };
+    }
+    /**
+     * Conditionally write the stats accumulator. `etag` present ⇒ `ifMatch`
+     * (update the object we read); absent ⇒ `createOnly` (create only). Returns
+     * `false` on a failed precondition so the caller retries.
+     */
+    async #writeStatsCas(stats, etag) {
+        return this.#bucket.put(this.#statsKey(), {
+            body: new TextEncoder().encode(JSON.stringify(stats)),
+            contentType: 'application/json',
+            ...(etag === undefined ? { createOnly: true } : { ifMatch: etag }),
+        });
+    }
+    /**
+     * Fold `delta` into the stats accumulator under an ETag compare-and-swap
+     * retry loop. Best-effort: exhausting the retry budget leaves the counters
+     * drifted (they are documented APPROXIMATE) rather than failing the `put`
+     * that already stored the bytes.
+     */
+    async #bumpStats(delta) {
+        for (let attempt = 0; attempt < CAS_ATTEMPTS; attempt++) {
+            const { stats, etag } = await this.#readStats();
+            const next = {
+                count: stats.count + delta.count,
+                bytes: stats.bytes + delta.bytes,
+                rowsSegments: stats.rowsSegments + delta.rowsSegments,
+                sqliteSegments: stats.sqliteSegments + delta.sqliteSegments,
+            };
+            if (await this.#writeStatsCas(next, etag))
+                return;
+        }
+        // Lost the CAS race `CAS_ATTEMPTS` times running — leave the
+        // counters as-is. `stats()` stays APPROXIMATE by contract.
+    }
+    async put(metadata, bytes, nowMs) {
+        const segmentId = await segmentIdFor(bytes);
+        await this.#putBytes(segmentId, bytes);
+        for (let attempt = 0; attempt < CAS_ATTEMPTS; attempt++) {
+            // The id IS the content address, so an existing record means a second
+            // scope published the same bytes: read it back and merge the digest set
+            // (§5.1).
+            const preexisting = await this.#readRecord(segmentId);
+            const record = mergeSegmentRecord(preexisting?.record, metadata, segmentId, bytes.length, nowMs, this.#ttlMs);
+            const recordJson = recordToJson(record);
+            // The digest set is monotone (§5.1) and this is a read-modify-write: a
+            // concurrent publisher of the same bytes computed its own union from the
+            // same pre-state, so an unconditional PUT would drop one of the digests
+            // and make that scope's download `sync.forbidden`. The write is
+            // conditional on the record body that was read — the record ETag is the
+            // body hash, so it changes whenever the union does — and a failed
+            // precondition re-reads and merges again. In-process dedupe cannot cover
+            // this: two scopes whose rows are byte-identical are two builds, and two
+            // server instances share one bucket.
+            const written = await this.#bucket.put(this.#recordKeyFor(segmentId), {
+                body: new TextEncoder().encode(recordJson),
+                contentType: 'application/json',
+                ...(preexisting?.etag === undefined
+                    ? { createOnly: true }
+                    : { ifMatch: preexisting.etag }),
+            });
+            if (!written)
+                continue;
+            if (preexisting === undefined) {
+                await this.#bumpStats({
+                    count: 1,
+                    bytes: bytes.length,
+                    rowsSegments: metadata.mediaType === 'rows' ? 1 : 0,
+                    sqliteSegments: metadata.mediaType === 'sqlite' ? 1 : 0,
+                });
+            }
+            if (metadata.rowCursor === null) {
+                await this.#bucket.put(await this.#findKeyFor(metadata), {
+                    body: new TextEncoder().encode(recordJson),
+                    contentType: 'application/json',
+                });
+            }
+            return record;
+        }
+        throw new Error(`${this.#label}: ${CAS_ATTEMPTS} conditional writes in a row lost the race for ${segmentId} — the stored digest set would have dropped a scope`);
+    }
+    /**
+     * Write the immutable bytes object. Create-only, so a second publisher of
+     * identical bytes is a no-op and a second publisher of DIFFERENT bytes under
+     * the same content address is the hash collision §5.1 requires to fail
+     * loudly instead of overwriting.
+     */
+    async #putBytes(segmentId, bytes) {
+        const key = this.objectKeyFor(segmentId);
+        const written = await this.#bucket.put(key, {
+            body: bytes,
+            contentType: 'application/octet-stream',
+            createOnly: true,
+        });
+        if (written)
+            return;
+        const current = await this.#bucket.get(key);
+        if (current === undefined)
+            return;
+        const stored = new Uint8Array(await current.arrayBuffer());
+        if (!segmentBytesEqual(stored, bytes)) {
+            throw new Error(`${this.#label}: content-address collision at ${segmentId} (§5.1)`);
+        }
+    }
+    /**
+     * Read the record object plus the ETag of the body that was read, so the
+     * union write can be made conditional on exactly that pre-state (§5.1).
+     *
+     * A record written before the record/bytes split rides in the bytes object's
+     * user metadata; it is read here and its union is materialized into a record
+     * object by the next `put`. That shape carries no usable ETag for the union
+     * (the bytes ETag is a content hash), which is exactly why it was replaced.
+     * A bytes object with neither a record object nor the legacy metadata is an
+     * entry whose record is missing — a cache miss, not corruption, so `get`
+     * reports it as absent and the client re-pulls.
+     */
+    async #readRecord(segmentId) {
+        if (!SEGMENT_ID_PATTERN.test(segmentId))
+            return undefined;
+        const object = await this.#bucket.get(this.#recordKeyFor(segmentId));
+        if (object !== undefined) {
+            return {
+                record: parseRecordJson(await object.text(), 'segment record', this.#label),
+                etag: object.etag,
+            };
+        }
+        const legacy = await this.#bucket.get(this.objectKeyFor(segmentId));
+        if (legacy === undefined)
+            return undefined;
+        const meta = legacy.metadata[LEGACY_RECORD_META_KEY];
+        await legacy.arrayBuffer();
+        if (meta === undefined)
+            return undefined;
+        return {
+            record: parseRecordJson(base64urlToUtf8(meta), segmentId, this.#label),
+            etag: undefined,
+        };
+    }
+    async get(segmentId) {
+        if (!SEGMENT_ID_PATTERN.test(segmentId))
+            return undefined;
+        const record = await this.#readRecord(segmentId);
+        if (record === undefined)
+            return undefined;
+        const object = await this.#bucket.get(this.objectKeyFor(segmentId));
+        if (object === undefined)
+            return undefined;
+        return {
+            record: record.record,
+            bytes: new Uint8Array(await object.arrayBuffer()),
+        };
+    }
+    /** The record plus the object GET's body, never buffered (see `get`). */
+    async open(segmentId) {
+        if (!SEGMENT_ID_PATTERN.test(segmentId))
+            return undefined;
+        const record = await this.#readRecord(segmentId);
+        if (record === undefined)
+            return undefined;
+        const object = await this.#bucket.get(this.objectKeyFor(segmentId));
+        if (object === undefined || object.body === null)
+            return undefined;
+        return {
+            record: record.record,
+            body: object.body,
+            byteLength: record.record.byteLength,
+        };
+    }
+    async find(key, nowMs) {
+        const pointer = await this.#bucket.get(await this.#findKeyFor(key));
+        if (pointer === undefined)
+            return undefined;
+        const record = parseRecordJson(await pointer.text(), 'reuse pointer', this.#label);
+        // The pointer is keyed by the full context, but the record body is the
+        // whole merged entry: select the publication the key names, never the
+        // top-level fields or the digest union (§5.1).
+        const publication = selectSegmentPublication(record, {
+            partition: key.partition,
+            logEpoch: key.logEpoch,
+            table: key.table,
+            schemaVersion: key.schemaVersion,
+            mediaType: key.mediaType,
+            scopeDigest: key.scopeDigest,
+            asOfCommitSeq: key.asOfCommitSeq,
+            rowCursor: null,
+            nowMs,
+        });
+        if (publication === undefined)
+            return undefined;
+        // Lifecycle GC may have removed the object while the pointer survived.
+        const head = await this.#bucket.head(this.objectKeyFor(record.segmentId));
+        if (head === undefined)
+            return undefined;
+        return publicationRecord(record, publication);
+    }
+    /**
+     * Store-wide counters from the pointer-object accumulator (never a LIST).
+     * Marked `approximate: true`: the counters are maintained by a best-effort
+     * ETag-CAS read-modify-write on `put`, so a crash between the segment PUT
+     * and the accumulator write, or lifecycle GC that deletes objects the
+     * accumulator still counts, can drift them. Exact within a single writer;
+     * a health gauge under concurrency. See the README "S3 stats".
+     */
+    async stats() {
+        const { stats } = await this.#readStats();
+        return {
+            count: stats.count,
+            bytes: stats.bytes,
+            rowsSegments: stats.rowsSegments,
+            sqliteSegments: stats.sqliteSegments,
+            approximate: true,
+        };
+    }
+}

package/dist/context.d.ts

@@ -69,6 +69,13 @@ export declare const DEFAULT_LIMITS: ServerLimits;
 /** Receives applied commits for realtime fanout (§8.2). */
 export interface RealtimeNotifier {
     notifyCommit(partition: string, commit: StoredCommit): void | Promise<void>;
+    /**
+     * A pull changed the client's persisted subscription list (§8.7). A hub
+     * re-registers that client's live sockets, so a client that runs its
+     * rounds over HTTP while a socket is open receives deltas for the new
+     * subscriptions.
+     */
+    notifySubscriptions?(partition: string, clientId: string): void | Promise<void>;
 }
 export interface SyncServerConfig {
     readonly schema: ServerSchema;

package/dist/d1-storage.js

@@ -144,6 +144,7 @@ class D1Transaction {
      * `tbl\u0000rowId` → the pending state, consulted by `getRow` before D1.
      */
     #pending = new Map();
+    #clearedTombstones = new Set();
     constructor(db, partition, resolveTable, prepareQuery, pushApplySerialized) {
         this.#db = db;
         this.#partition = partition;
@@ -175,6 +176,9 @@ class D1Transaction {
     }
     async getTombstoneSeq(table, rowId) {
         this.#assertOpen();
+        if (this.#clearedTombstones.has(_a.#key(table, rowId))) {
+            return undefined;
+        }
         // Persisted read, no #pending overlay: a delete buffered by this commit
         // records its tombstone at appendCommit, matching the SQLite/Postgres
         // adapters where the tombstone insert also runs at commit append.
@@ -186,6 +190,7 @@ class D1Transaction {
     }
     async clearTombstone(table, rowId) {
         this.#assertOpen();
+        this.#clearedTombstones.add(_a.#key(table, rowId));
         this.#buffer_('DELETE FROM sync_tombstones WHERE partition=? AND tbl=? AND row_id=?', [this.#partition, table, rowId]);
     }
     async getPushResult(clientId, clientCommitId) {
@@ -250,7 +255,7 @@ class D1Transaction {
             }
         }
         return [...rows.values()]
-            .sort((left, right) => left.rowId.localeCompare(right.rowId))
+            .sort((left, right) => left.rowId < right.rowId ? -1 : left.rowId > right.rowId ? 1 : 0)
             .slice(0, query.limit);
     }
     async scanRowsByIndex(query) {
@@ -287,7 +292,7 @@ class D1Transaction {
                 rows.set(rowId, pending.row);
         }
         return [...rows.values()]
-            .sort((left, right) => left.rowId.localeCompare(right.rowId))
+            .sort((left, right) => left.rowId < right.rowId ? -1 : left.rowId > right.rowId ? 1 : 0)
             .slice(0, query.limit);
     }
     async queryAuthoritative(query) {
@@ -334,6 +339,7 @@ class D1Transaction {
         }
         this.#buffer.length = checkpoint;
         this.#pending.clear();
+        this.#clearedTombstones.clear();
         this.#maxCommitSeq = undefined;
         this.#applicationOpIndexes.clear();
         await this.putPushResult(clientId, clientCommitId, result);

package/dist/handler.js

@@ -341,25 +341,35 @@ async function* streamResponse(plan, ctx, schema, report) {
     }
     try {
         // Push half (§6): one PUSH_RESULT per PUSH_COMMIT, in request order.
+        const currentSchema = compileSchema(ctx.schema);
         let acceptedThrough = 0;
         for (const push of plan.pushes) {
-            const processed = await processPushCommitWithTrace(ctx, compileSchema(ctx.schema), plan.resolved, plan.header.clientId, push, schema);
+            const processed = await processPushCommitWithTrace(ctx, currentSchema, plan.resolved, plan.header.clientId, push, schema);
             acceptedThrough = Math.max(acceptedThrough, processed.frame.commitSeq ?? 0);
             const frame = {
                 ...processed.frame,
                 results: processed.frame.results.map((result) => {
-                    if (result.status !== 'conflict')
+                    if (result.status !== 'conflict' || schema === currentSchema) {
                         return result;
+                    }
                     const operation = push.operations[result.opIndex];
+                    // §2.3: a replay returns the persisted result without rebuilding
+                    // operations, so a reused clientCommitId with changed operations
+                    // leaves no table to project the stored conflict row through.
+                    if (operation === undefined) {
+                        throw syncError('sync.invalid_request', 'replayed clientCommitId carries changed operations', JSON.stringify({
+                            clientCommitId: push.clientCommitId,
+                            opIndex: result.opIndex,
+                        }));
+                    }
                     const target = schema.tables.get(operation.table);
-                    const current = compileSchema(ctx.schema).tables.get(operation.table);
+                    const bitmapBytes = Math.ceil(target.columns.length / 8);
                     return {
                         ...result,
-                        serverRow: projectRowPayload(current, target, result.serverRow),
+                        serverRow: projectRowPayload(currentSchema.tables.get(operation.table), target, result.serverRow),
                         conflictColumns: result.conflictColumns
-                            .slice(0, Math.ceil(target.columns.length / 8))
-                            .map((byte, i) => i === Math.ceil(target.columns.length / 8) - 1 &&
-                            target.columns.length % 8 !== 0
+                            .slice(0, bitmapBytes)
+                            .map((byte, i) => i === bitmapBytes - 1 && target.columns.length % 8 !== 0
                             ? byte & ((1 << (target.columns.length % 8)) - 1)
                             : byte),
                     };
@@ -474,6 +484,10 @@ async function* streamResponse(plan, ctx, schema, report) {
             updatedAtMs: clockOf(ctx)(),
             subscriptions,
         });
+        if (ctx.realtime?.notifySubscriptions !== undefined &&
+            JSON.stringify((previous?.subscriptions ?? []).map((s) => [s.id, s.table, s.scopes])) !== JSON.stringify(subscriptions.map((s) => [s.id, s.table, s.scopes]))) {
+            await ctx.realtime.notifySubscriptions(ctx.partition, plan.header.clientId);
+        }
     }
     catch (error) {
         if (error instanceof SyncError) {

package/dist/index.d.ts

@@ -11,6 +11,8 @@ export * from './admin.js';
 export * from './authoritative-query.js';
 export * from './blob-handlers.js';
 export * from './blob-store.js';
+export * from './bucket-blob-store.js';
+export * from './bucket-segment-store.js';
 export * from './content-encoding.js';
 export * from './context.js';
 export * from './crdt-merger.js';
@@ -33,8 +35,10 @@ export * from './readiness.js';
 export { DEFAULT_REACTION_INITIAL_BACKOFF_MS, DEFAULT_REACTION_LEASE_MS, DEFAULT_REACTION_MAX_ATTEMPTS, DEFAULT_REACTION_MAX_BACKOFF_MS, DEFAULT_REACTION_RETENTION, MAX_REACTION_FAILURE_DETAILS_BYTES, MAX_REACTION_PAYLOAD_BYTES, MAX_REACTIONS_PER_COMMIT, PermanentReactionError, pruneReactions, ReactionRunner, reactionIdempotencyKey, retryDeadLetterReaction, RetryableReactionError, type PlannedReaction, type PruneReactionsOptions, type ReactionHandler, type ReactionHandlerInput, type ReactionHandlers, type ReactionPlan, type ReactionPlanner, type ReactionPlannerInput, type ReactionPruneResult, type ReactionRetentionPolicy, type ReactionRunnerOptions, type ReactionRunResult, type ReactionTypeMap, } from './reactions.js';
 export * from './realtime.js';
 export * from './restore.js';
+export * from './object-bucket.js';
 export * from './relational-rows.js';
 export * from './s3-blob-store.js';
+export * from './s3-object-bucket.js';
 export * from './s3-segment-store.js';
 export * from './schema.js';
 export * from './scopes.js';

package/dist/index.js

@@ -11,6 +11,8 @@ export * from './admin.js';
 export * from './authoritative-query.js';
 export * from './blob-handlers.js';
 export * from './blob-store.js';
+export * from './bucket-blob-store.js';
+export * from './bucket-segment-store.js';
 export * from './content-encoding.js';
 export * from './context.js';
 export * from './crdt-merger.js';
@@ -37,8 +39,10 @@ export * from './readiness.js';
 export { DEFAULT_REACTION_INITIAL_BACKOFF_MS, DEFAULT_REACTION_LEASE_MS, DEFAULT_REACTION_MAX_ATTEMPTS, DEFAULT_REACTION_MAX_BACKOFF_MS, DEFAULT_REACTION_RETENTION, MAX_REACTION_FAILURE_DETAILS_BYTES, MAX_REACTION_PAYLOAD_BYTES, MAX_REACTIONS_PER_COMMIT, PermanentReactionError, pruneReactions, ReactionRunner, reactionIdempotencyKey, retryDeadLetterReaction, RetryableReactionError, } from './reactions.js';
 export * from './realtime.js';
 export * from './restore.js';
+export * from './object-bucket.js';
 export * from './relational-rows.js';
 export * from './s3-blob-store.js';
+export * from './s3-object-bucket.js';
 export * from './s3-segment-store.js';
 export * from './schema.js';
 export * from './scopes.js';