@syncular/server 0.37.0 → 0.39.0

package/dist/storage.d.ts

@@ -283,6 +283,8 @@ export interface ClientCursorInfo {
     readonly updatedAtMs: number;
 }
 /** Durable partition identity refreshed after host authentication (§2.1). */
+/** Longest age of `lastAuthenticatedAtMs` that `touchPartition` leaves unwritten. */
+export declare const PARTITION_TOUCH_INTERVAL_MS = 60000;
 export interface PartitionRegistryEntry {
     readonly partition: string;
     readonly logEpoch: string;
@@ -526,7 +528,12 @@ export interface ServerStorage {
      * lazily as a defensive backstop.
      */
     ensureSchema(schema: CompiledSchema, checkpoints?: readonly CheckpointDeclaration[]): Promise<void>;
-    /** Create or refresh the authenticated partition registry row (§2.1). */
+    /**
+     * Create or refresh the authenticated partition registry row (§2.1). A
+     * row whose `lastAuthenticatedAtMs` is less than
+     * {@link PARTITION_TOUCH_INTERVAL_MS} behind `authenticatedAtMs` is read
+     * back without a write, so a request that only reads takes no write lock.
+     */
     touchPartition(partition: string, authenticatedAtMs: number, initialLogEpoch: string): Promise<PartitionRegistryEntry>;
     /** Rotate log continuity after restore and discard stale cursor records. */
     rotatePartitionLogEpoch(partition: string, logEpoch: string, authenticatedAtMs: number): Promise<PartitionRegistryEntry>;

package/dist/storage.js

@@ -38,3 +38,6 @@ export function serveGateTokenChanged(before, after) {
     }
     return undefined;
 }
+/** Durable partition identity refreshed after host authentication (§2.1). */
+/** Longest age of `lastAuthenticatedAtMs` that `touchPartition` leaves unwritten. */
+export const PARTITION_TOUCH_INTERVAL_MS = 60_000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/server",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "Syncular server: handleSyncRequest + storage/auth interfaces for the sync protocol",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -68,7 +68,7 @@
     "verify:node": "cd ../.. && bun build ./packages/server/test/sqlite-runtime/verify-node.mjs --target=node --conditions=bun --outfile=./packages/server/.verify-node.built.mjs && node ./packages/server/.verify-node.built.mjs"
   },
   "dependencies": {
-    "@syncular/core": "0.37.0"
+    "@syncular/core": "0.39.0"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.5.4"

package/src/content-encoding.ts

@@ -1,24 +1,29 @@
 /**
- * §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.
  */
+import { syncError } from './errors';
 
-export type SegmentContentEncoding = 'zstd' | 'gzip';
+export type ContentEncoding = 'zstd' | 'gzip';
 
 interface Codec {
-  readonly encoding: SegmentContentEncoding;
-  readonly compress: (bytes: Uint8Array) => Uint8Array;
+  readonly encoding: ContentEncoding;
+  readonly compress: (bytes: Uint8Array) => Uint8Array | Promise<Uint8Array>;
 }
 
 interface BunCompressors {
@@ -26,8 +31,22 @@ interface BunCompressors {
   readonly gzipSync?: (bytes: Uint8Array) => Uint8Array;
 }
 
-/** Preference order is zstd, gzip (§5.8). Non-Bun runtimes without these
- * codecs serve identity — negotiation, never a hard requirement here. */
+/** Bodies below this size are served identity (headers outweigh gains). */
+const MIN_COMPRESS_BYTES = 1024;
+
+async function gzipWithCompressionStream(
+  bytes: Uint8Array,
+): Promise<Uint8Array> {
+  const compressed = await new Response(
+    new Blob([bytes.slice().buffer as ArrayBuffer])
+      .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(): readonly Codec[] {
   const bun = (globalThis as { Bun?: BunCompressors }).Bun;
   const codecs: Codec[] = [];
@@ -38,17 +57,19 @@ function detectCodecs(): readonly Codec[] {
   const gzip = bun?.gzipSync;
   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: string, encoding: SegmentContentEncoding): boolean {
+export function acceptsEncoding(
+  header: string,
+  encoding: ContentEncoding,
+): boolean {
   for (const entry of header.split(',')) {
     const [rawName, ...params] = entry.trim().split(';');
     const name = rawName?.trim().toLowerCase();
@@ -64,28 +85,41 @@ function accepts(header: string, encoding: SegmentContentEncoding): boolean {
   return false;
 }
 
-export interface EncodedSegmentBody {
+/**
+ * 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: Headers): void {
+  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`);
+  }
+}
+
+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 function encodeSegmentBody(
+export async function encodeBody(
   bytes: Uint8Array,
   acceptEncoding: string | undefined,
-): EncodedSegmentBody {
+): Promise<EncodedBody> {
   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,
       };
     }
@@ -100,24 +134,24 @@ export function encodeSegmentBody(
  */
 export const SEGMENT_STREAM_THRESHOLD_BYTES = 16 * 1024 * 1024;
 
-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 function encodeSegmentStream(
+export function encodeStream(
   body: ReadableStream<Uint8Array<ArrayBuffer>>,
   acceptEncoding: string | undefined,
-): EncodedSegmentStream {
+): EncodedStreamBody {
   if (
     acceptEncoding === undefined ||
-    !accepts(acceptEncoding, 'gzip') ||
+    !acceptsEncoding(acceptEncoding, 'gzip') ||
     typeof CompressionStream !== 'function'
   ) {
     return { body };
@@ -127,3 +161,37 @@ export function encodeSegmentStream(
     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: Request,
+): Promise<Uint8Array | undefined> {
+  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/src/d1-storage.ts

@@ -1,6 +1,7 @@
 import { validateCommitPruneQuery } from './prune';
 import { StorageQueryError } from './storage-errors';
 import type { CommitPruneQuery, CommitPruneResult } from './storage';
+import { PARTITION_TOUCH_INTERVAL_MS } from './storage';
 /**
  * Cloudflare D1 server storage for Workers deployments.
  *
@@ -77,6 +78,9 @@ import {
   type StoredColumnLayout,
   scanRowPageSql,
   schemaDdl,
+  SQLITE_TABLE_INDEXES_SQL,
+  type SqliteTableIndexRow,
+  sqliteIndexSignatures,
   selectRowScopesSql,
   selectRowSql,
   selectRowsForRewriteSql,
@@ -938,7 +942,7 @@ interface D1MigrationState {
   phase: 'core' | 'prepare' | 'ddl' | 'rewrite';
   offset: number;
   columns: Record<string, string[]>;
-  indexes: Record<string, string[]>;
+  indexes: Record<string, Record<string, string>>;
   ddl: string[];
   rewrites: Array<{ table: string; oldLayout?: readonly StoredColumnLayout[] }>;
   afterPartition: string;
@@ -1269,8 +1273,9 @@ export class D1ServerStorage implements ServerStorage {
             .prepare(`PRAGMA table_info(${quoteIdent(table.name)})`)
             .all<{ name: string }>();
           const indexes = await this.#db
-            .prepare(`PRAGMA index_list(${quoteIdent(table.name)})`)
-            .all<{ name: string; origin: string }>();
+            .prepare(SQLITE_TABLE_INDEXES_SQL)
+            .bind(table.name)
+            .all<SqliteTableIndexRow>();
           // Validate the old codec before any application DDL or row rewrite.
           rewritePlan(
             table,
@@ -1296,9 +1301,7 @@ export class D1ServerStorage implements ServerStorage {
                 },
                 indexes: {
                   ...state.indexes,
-                  [table.name]: indexes.results
-                    .filter((index) => index.origin === 'c')
-                    .map((index) => index.name),
+                  [table.name]: sqliteIndexSignatures(indexes.results),
                 },
               },
               [],
@@ -1314,9 +1317,9 @@ export class D1ServerStorage implements ServerStorage {
           ]),
         );
         const indexes = new Map(
-          Object.entries(state.indexes).map(([name, names]) => [
+          Object.entries(state.indexes).map(([name, signatures]) => [
             name,
-            new Set(names),
+            new Map(Object.entries(signatures)),
           ]),
         );
         const rewrites = tables.flatMap((table) => {
@@ -1422,7 +1425,7 @@ export class D1ServerStorage implements ServerStorage {
               ? migratePayload(plan.oldLayout, table, bytes)
               : bytes;
           return this.#db
-            .prepare(rewriteRowSql(table, 'sqlite'))
+            .prepare(rewriteRowSql(table))
             .bind(
               ...rewriteValues(
                 table,
@@ -1581,27 +1584,38 @@ export class D1ServerStorage implements ServerStorage {
     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<{
+      log_epoch: string;
+      epoch_required: number;
+      last_authenticated_at_ms: number;
+    }>();
+    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<{
         log_epoch: string;
         epoch_required: number;
         last_authenticated_at_ms: number;
       }>();
+    }
     if (row === null)
       throw new Error('partition registry write did not persist');
     return {