@syncular/server 0.37.0 → 0.39.0

package/dist/content-encoding.d.ts

@@ -1,44 +1,45 @@
+export type ContentEncoding = 'zstd' | 'gzip';
+/** Does the `Accept-Encoding` header value accept `encoding` (q > 0)? */
+export declare function acceptsEncoding(header: string, encoding: ContentEncoding): boolean;
 /**
- * §5.8 shipped compression posture for the direct segment endpoint:
- * negotiate `Content-Encoding` from the request's `Accept-Encoding`
- * (zstd preferred, gzip fallback, identity when the client offers
- * neither), feature-detecting the runtime's codecs — zero dependencies.
- *
- * Segment bytes are stored and content-addressed UNCOMPRESSED (§5.1);
- * this is a per-response serving concern only. It is never applied to
- * stored objects or the signed-URL path (§5.8: presigned GETs serve the
- * addressed bytes verbatim; edge compression is a deployment concern).
- *
- * Decision data (2026-07-03, 100k-row bench table, Bun 1.3): rows
- * segments 6.2× in 8 ms (zstd) / 7.7× in 42 ms (gzip); sqlite images
- * 3.4× in 14 ms (zstd) / 51 ms (gzip); client decompression ≤ 8 ms.
+ * Add `Accept-Encoding` to a response's `Vary` header. Every response whose
+ * body was negotiated carries it, so a cache never serves one encoding to a
+ * client that asked for another.
  */
-export type SegmentContentEncoding = 'zstd' | 'gzip';
-export interface EncodedSegmentBody {
+export declare function varyOnAcceptEncoding(headers: Headers): void;
+export interface EncodedBody {
     readonly bytes: Uint8Array;
     /** Absent ⇒ identity (no `Content-Encoding` header). */
-    readonly contentEncoding?: SegmentContentEncoding;
+    readonly contentEncoding?: ContentEncoding;
 }
 /**
- * Compress a buffered segment body per §5.8. Returns the original bytes
+ * Compress a buffered response body per §1.3. Returns the original bytes
  * (identity) when the client offered no supported encoding, the body is
  * tiny, or the runtime has no codec.
  */
-export declare function encodeSegmentBody(bytes: Uint8Array, acceptEncoding: string | undefined): EncodedSegmentBody;
+export declare function encodeBody(bytes: Uint8Array, acceptEncoding: string | undefined): Promise<EncodedBody>;
 /**
  * Segments above this size are relayed as a stream instead of being
  * buffered and compressed in memory: a sqlite image can exceed the memory of
  * a Workers isolate (128 MB).
  */
 export declare const SEGMENT_STREAM_THRESHOLD_BYTES: number;
-export interface EncodedSegmentStream {
+export interface EncodedStreamBody {
     readonly body: ReadableStream<Uint8Array<ArrayBuffer>>;
     /** Absent ⇒ identity (no `Content-Encoding` header). */
     readonly contentEncoding?: 'gzip';
 }
 /**
- * Compress a streamed segment body per §5.8 with the runtime's
- * `CompressionStream`: gzip when the client accepts it, identity otherwise
- * (zstd has no standard streaming codec).
+ * Compress a streamed body per §1.3 with the runtime's `CompressionStream`:
+ * gzip when the client accepts it, identity otherwise (zstd has no standard
+ * streaming codec).
  */
-export declare function encodeSegmentStream(body: ReadableStream<Uint8Array<ArrayBuffer>>, acceptEncoding: string | undefined): EncodedSegmentStream;
+export declare function encodeStream(body: ReadableStream<Uint8Array<ArrayBuffer>>, acceptEncoding: string | undefined): EncodedStreamBody;
+/**
+ * The bytes of a request body, decompressed when the client sent
+ * `Content-Encoding: gzip` (§1.3: clients MAY compress a request body and
+ * servers MUST accept it). Returns `undefined` for any other declared
+ * encoding — the adapter answers 415 rather than parse bytes it cannot read.
+ * A gzip body that does not decompress is a `sync.invalid_request`.
+ */
+export declare function decodeRequestBody(request: Request): Promise<Uint8Array | undefined>;

package/dist/content-encoding.js

@@ -1,20 +1,33 @@
 /**
- * §5.8 shipped compression posture for the direct segment endpoint:
- * negotiate `Content-Encoding` from the request's `Accept-Encoding`
- * (zstd preferred, gzip fallback, identity when the client offers
- * neither), feature-detecting the runtime's codecs — zero dependencies.
+ * §1.3 transport compression for every buffered HTTP body the adapters
+ * serve — `<mount>/sync`, `<mount>/operations`, blob GETs and segment
+ * downloads: negotiate `Content-Encoding` from the request's
+ * `Accept-Encoding` (zstd preferred, gzip fallback, identity when the client
+ * offers neither), feature-detecting the runtime's codecs, zero
+ * dependencies. Bun supplies zstd + gzip natively; every other runtime
+ * (workerd, Node, Deno) gets gzip through the standard `CompressionStream`.
  *
- * Segment bytes are stored and content-addressed UNCOMPRESSED (§5.1);
- * this is a per-response serving concern only. It is never applied to
- * stored objects or the signed-URL path (§5.8: presigned GETs serve the
- * addressed bytes verbatim; edge compression is a deployment concern).
+ * Body bytes are stored and content-addressed UNCOMPRESSED (§5.1); this is a
+ * per-response serving concern only. It is never applied to stored objects or
+ * the signed-URL path (§5.8: presigned GETs serve the addressed bytes
+ * verbatim; edge compression is a deployment concern). Clients MAY gzip a
+ * request body (§1.3) — `decodeRequestBody` is the accepting half.
  *
  * Decision data (2026-07-03, 100k-row bench table, Bun 1.3): rows
  * segments 6.2× in 8 ms (zstd) / 7.7× in 42 ms (gzip); sqlite images
  * 3.4× in 14 ms (zstd) / 51 ms (gzip); client decompression ≤ 8 ms.
  */
-/** Preference order is zstd, gzip (§5.8). Non-Bun runtimes without these
- * codecs serve identity — negotiation, never a hard requirement here. */
+import { syncError } from './errors.js';
+/** Bodies below this size are served identity (headers outweigh gains). */
+const MIN_COMPRESS_BYTES = 1024;
+async function gzipWithCompressionStream(bytes) {
+    const compressed = await new Response(new Blob([bytes.slice().buffer])
+        .stream()
+        .pipeThrough(new CompressionStream('gzip'))).arrayBuffer();
+    return new Uint8Array(compressed);
+}
+/** Preference order is zstd, gzip (§1.3). A runtime with neither codec
+ * serves identity: negotiation, never a hard requirement here. */
 function detectCodecs() {
     const bun = globalThis.Bun;
     const codecs = [];
@@ -26,13 +39,14 @@ function detectCodecs() {
     if (typeof gzip === 'function') {
         codecs.push({ encoding: 'gzip', compress: (bytes) => gzip(bytes) });
     }
+    else if (typeof CompressionStream === 'function') {
+        codecs.push({ encoding: 'gzip', compress: gzipWithCompressionStream });
+    }
     return codecs;
 }
 const CODECS = detectCodecs();
-/** Bodies below this size are served identity (headers outweigh gains). */
-const MIN_COMPRESS_BYTES = 1024;
 /** Does the `Accept-Encoding` header value accept `encoding` (q > 0)? */
-function accepts(header, encoding) {
+export function acceptsEncoding(header, encoding) {
     for (const entry of header.split(',')) {
         const [rawName, ...params] = entry.trim().split(';');
         const name = rawName?.trim().toLowerCase();
@@ -49,18 +63,31 @@ function accepts(header, encoding) {
     return false;
 }
 /**
- * Compress a buffered segment body per §5.8. Returns the original bytes
+ * Add `Accept-Encoding` to a response's `Vary` header. Every response whose
+ * body was negotiated carries it, so a cache never serves one encoding to a
+ * client that asked for another.
+ */
+export function varyOnAcceptEncoding(headers) {
+    const vary = headers.get('vary');
+    if (vary === null)
+        headers.set('vary', 'Accept-Encoding');
+    else if (!/\baccept-encoding\b/i.test(vary)) {
+        headers.set('vary', `${vary}, Accept-Encoding`);
+    }
+}
+/**
+ * Compress a buffered response body per §1.3. Returns the original bytes
  * (identity) when the client offered no supported encoding, the body is
  * tiny, or the runtime has no codec.
  */
-export function encodeSegmentBody(bytes, acceptEncoding) {
+export async function encodeBody(bytes, acceptEncoding) {
     if (acceptEncoding === undefined || bytes.length < MIN_COMPRESS_BYTES) {
         return { bytes };
     }
     for (const codec of CODECS) {
-        if (accepts(acceptEncoding, codec.encoding)) {
+        if (acceptsEncoding(acceptEncoding, codec.encoding)) {
             return {
-                bytes: codec.compress(bytes),
+                bytes: await codec.compress(bytes),
                 contentEncoding: codec.encoding,
             };
         }
@@ -74,13 +101,13 @@ export function encodeSegmentBody(bytes, acceptEncoding) {
  */
 export const SEGMENT_STREAM_THRESHOLD_BYTES = 16 * 1024 * 1024;
 /**
- * Compress a streamed segment body per §5.8 with the runtime's
- * `CompressionStream`: gzip when the client accepts it, identity otherwise
- * (zstd has no standard streaming codec).
+ * Compress a streamed body per §1.3 with the runtime's `CompressionStream`:
+ * gzip when the client accepts it, identity otherwise (zstd has no standard
+ * streaming codec).
  */
-export function encodeSegmentStream(body, acceptEncoding) {
+export function encodeStream(body, acceptEncoding) {
     if (acceptEncoding === undefined ||
-        !accepts(acceptEncoding, 'gzip') ||
+        !acceptsEncoding(acceptEncoding, 'gzip') ||
         typeof CompressionStream !== 'function') {
         return { body };
     }
@@ -89,3 +116,31 @@ export function encodeSegmentStream(body, acceptEncoding) {
         contentEncoding: 'gzip',
     };
 }
+/**
+ * The bytes of a request body, decompressed when the client sent
+ * `Content-Encoding: gzip` (§1.3: clients MAY compress a request body and
+ * servers MUST accept it). Returns `undefined` for any other declared
+ * encoding — the adapter answers 415 rather than parse bytes it cannot read.
+ * A gzip body that does not decompress is a `sync.invalid_request`.
+ */
+export async function decodeRequestBody(request) {
+    const encoding = request.headers
+        .get('content-encoding')
+        ?.trim()
+        .toLowerCase();
+    if (encoding === undefined || encoding === '' || encoding === 'identity') {
+        return new Uint8Array(await request.arrayBuffer());
+    }
+    if (encoding !== 'gzip' || typeof DecompressionStream !== 'function') {
+        return undefined;
+    }
+    if (request.body === null) {
+        throw syncError('sync.invalid_request', 'malformed gzip request body');
+    }
+    try {
+        return new Uint8Array(await new Response(request.body.pipeThrough(new DecompressionStream('gzip'))).arrayBuffer());
+    }
+    catch {
+        throw syncError('sync.invalid_request', 'malformed gzip request body');
+    }
+}

package/dist/d1-storage.js

@@ -1,6 +1,7 @@
 var _a;
 import { validateCommitPruneQuery } from './prune.js';
 import { StorageQueryError } from './storage-errors.js';
+import { PARTITION_TOUCH_INTERVAL_MS } from './storage.js';
 /**
  * Cloudflare D1 server storage for Workers deployments.
  *
@@ -45,7 +46,7 @@ import { StorageQueryError } from './storage-errors.js';
 import { decodeRow } from '@syncular/core';
 import { bindAuthoritativePartition, prepareAuthoritativeQuery, } from './authoritative-query.js';
 import { syncError } from './errors.js';
-import { assertAppendOnlyMigration, assertPhysicalColumns, assertStoredLayouts, commitWindowPageSql, LATEST_SCOPED_CHANGE_SEQ_SQLITE_SQL, deleteRowSql, deleteSqliteRowScopesSql, dropTableDdl, indexRowPageStatement, layoutsOf, migratePayload, parseLayouts, quoteIdent, retiredTableNames, rewritePlan, rewriteRowSql, rewriteValues, SCHEMA_META_DDL_SQLITE, SYNC_COLUMN_VERSIONS_COLUMN, SYNC_PARTITION_COLUMN, SYNC_PAYLOAD_COLUMN, SYNC_ROW_ID_COLUMN, SYNC_SCOPES_COLUMN, SYNC_VERSION_COLUMN, scanRowPageSql, schemaDdl, selectRowScopesSql, selectRowSql, selectRowsForRewriteSql, tableColumnNames, toSqlValue, upsertSql, upsertValues, } from './relational-rows.js';
+import { assertAppendOnlyMigration, assertPhysicalColumns, assertStoredLayouts, commitWindowPageSql, LATEST_SCOPED_CHANGE_SEQ_SQLITE_SQL, deleteRowSql, deleteSqliteRowScopesSql, dropTableDdl, indexRowPageStatement, layoutsOf, migratePayload, parseLayouts, quoteIdent, retiredTableNames, rewritePlan, rewriteRowSql, rewriteValues, SCHEMA_META_DDL_SQLITE, SYNC_COLUMN_VERSIONS_COLUMN, SYNC_PARTITION_COLUMN, SYNC_PAYLOAD_COLUMN, SYNC_ROW_ID_COLUMN, SYNC_SCOPES_COLUMN, SYNC_VERSION_COLUMN, scanRowPageSql, schemaDdl, SQLITE_TABLE_INDEXES_SQL, sqliteIndexSignatures, selectRowScopesSql, selectRowSql, selectRowsForRewriteSql, tableColumnNames, toSqlValue, upsertSql, upsertValues, } from './relational-rows.js';
 import { matchesEffective } from './scopes.js';
 import { asUint8Array, collectCommitWindowPage, deserializePushResult, placeholders, ERASE_SCOPE_VALUE_HISTORY_SQLITE_SQL, eraseScopeValueHistoryParams, LIST_SCOPE_VALUE_ROWS_SQLITE_SQL, serializePushResult, sqliteDdlStatements, toStoredChange, toStoredRow, } from './sqlite-dialect.js';
 import { isD1ConstraintError, StorageConstraintError } from './storage-errors.js';
@@ -833,7 +834,8 @@ export class D1ServerStorage {
                         .prepare(`PRAGMA table_info(${quoteIdent(table.name)})`)
                         .all();
                     const indexes = await this.#db
-                        .prepare(`PRAGMA index_list(${quoteIdent(table.name)})`)
+                        .prepare(SQLITE_TABLE_INDEXES_SQL)
+                        .bind(table.name)
                         .all();
                     // Validate the old codec before any application DDL or row rewrite.
                     rewritePlan(table, sourceLayouts[table.name], columns.results.length > 0
@@ -852,9 +854,7 @@ export class D1ServerStorage {
                         },
                         indexes: {
                             ...state.indexes,
-                            [table.name]: indexes.results
-                                .filter((index) => index.origin === 'c')
-                                .map((index) => index.name),
+                            [table.name]: sqliteIndexSignatures(indexes.results),
                         },
                     }, [])))
                         break;
@@ -864,9 +864,9 @@ export class D1ServerStorage {
                     name,
                     new Set(names),
                 ]));
-                const indexes = new Map(Object.entries(state.indexes).map(([name, names]) => [
+                const indexes = new Map(Object.entries(state.indexes).map(([name, signatures]) => [
                     name,
-                    new Set(names),
+                    new Map(Object.entries(signatures)),
                 ]));
                 const rewrites = tables.flatMap((table) => {
                     const plan = rewritePlan(table, sourceLayouts[table.name], columns.get(table.name));
@@ -943,7 +943,7 @@ export class D1ServerStorage {
                         ? migratePayload(plan.oldLayout, table, bytes)
                         : bytes;
                     return this.#db
-                        .prepare(rewriteRowSql(table, 'sqlite'))
+                        .prepare(rewriteRowSql(table))
                         .bind(...rewriteValues(table, row.partition, row.row_id, payload, 'sqlite'));
                 });
                 const last = results.at(-1);
@@ -1068,19 +1068,24 @@ export class D1ServerStorage {
         if (initialLogEpoch.length === 0) {
             throw new Error('initial log epoch must be non-empty');
         }
-        await this.#db
-            .prepare(`INSERT INTO sync_partition_registry(
-           partition, log_epoch, last_authenticated_at_ms
-         ) VALUES (?,?,?)
-         ON CONFLICT(partition) DO UPDATE SET
-           last_authenticated_at_ms=excluded.last_authenticated_at_ms`)
-            .bind(partition, initialLogEpoch, authenticatedAtMs)
-            .run();
-        const row = await this.#db
+        const select = this.#db
             .prepare(`SELECT log_epoch, epoch_required, last_authenticated_at_ms
            FROM sync_partition_registry WHERE partition=?`)
-            .bind(partition)
-            .first();
+            .bind(partition);
+        let row = await select.first();
+        if (row === null ||
+            authenticatedAtMs - row.last_authenticated_at_ms >=
+                PARTITION_TOUCH_INTERVAL_MS) {
+            await this.#db
+                .prepare(`INSERT INTO sync_partition_registry(
+             partition, log_epoch, last_authenticated_at_ms
+           ) VALUES (?,?,?)
+           ON CONFLICT(partition) DO UPDATE SET
+             last_authenticated_at_ms=excluded.last_authenticated_at_ms`)
+                .bind(partition, initialLogEpoch, authenticatedAtMs)
+                .run();
+            row = await select.first();
+        }
         if (row === null)
             throw new Error('partition registry write did not persist');
         return {

package/dist/postgres-storage.d.ts

@@ -53,7 +53,7 @@ import type { AuthoritativeQueryRequest, AuthoritativeQueryResult, CheckpointDec
  * their table.
  *
  * `sync_row_scopes_by_row (partition, tbl, row_id)` is the one secondary
- * scope index: `writeRowOn` and `deleteRow` replace a row's scope entries
+ * scope index: `writeRowsOn` and `deleteRow` replace a row's scope entries
  * with a `(partition, tbl, row_id)` predicate, and `row_id` is the LAST
  * column of the inverted PRIMARY KEY, so without this index that predicate
  * scans the table's whole scope range on every row written (a bulk import