@syncular/core 0.1.3 → 0.2.1

package/src/row-codec.ts

@@ -0,0 +1,265 @@
+/**
+ * Schema-IR row codec (SPEC.md §2.4).
+ *
+ * A row is a null bitmap of ceil(columnCount / 8) bytes (bit i set =
+ * column i is NULL; LSB-first within each byte, byte i/8), followed by the
+ * non-null values encoded positionally in schema-IR declaration order.
+ * Used for `COMMIT` change payloads, rows-segment row data, push operation
+ * payloads, and conflict `serverRow` values.
+ */
+import { parseBlobRef } from './blob-ref';
+import { ByteReader, ByteWriter } from './bytes';
+import { DecodeError } from './errors';
+
+export type ColumnType =
+  | 'string'
+  | 'integer'
+  | 'float'
+  | 'boolean'
+  | 'json'
+  | 'bytes'
+  | 'blob_ref'
+  | 'crdt';
+
+export interface RowColumn {
+  readonly name: string;
+  readonly type: ColumnType;
+  readonly nullable: boolean;
+  /**
+   * For a `crdt` column (§2.4 tag 8, §5.10.1): the named merger the server
+   * selects (this rung defines exactly `'yjs-doc'`). Schema-IR metadata
+   * ONLY — never on the wire (the SSG2 column table carries name/type/
+   * nullable, and `crdt` shares the `bytes` tag). Ignored for other types.
+   */
+  readonly crdtType?: string;
+  /**
+   * §5.11: this column is encrypted end-to-end. When set, `type` is `bytes`
+   * (the wire/stored type — the ciphertext envelope rides the bytes machinery)
+   * and `declaredType` is the pre-flip app type. Both are schema-IR metadata,
+   * never on the wire (like `crdtType`). The row codec ignores these — it
+   * only ever sees a `bytes` value; encryption/decryption is the client
+   * encode/apply seam (§5.11).
+   */
+  readonly encrypted?: boolean;
+  /** §5.11: the app-side type of an encrypted column (its type before the
+   * wire flip to `bytes`). Present iff `encrypted` is set. */
+  readonly declaredType?: ColumnType;
+}
+
+/**
+ * `integer` is `i64` within the ±(2^53−1) contract; `json` is the raw JSON
+ * document string, preserved byte-for-byte on round-trip.
+ */
+export type RowValue = string | number | boolean | Uint8Array | null;
+
+/** Wire tags, unchanged from v1's binary-table-v1 assignment (SPEC.md §2.4). */
+const TYPE_TO_TAG: Readonly<Record<ColumnType, number>> = {
+  string: 1,
+  integer: 2,
+  float: 3,
+  boolean: 4,
+  json: 5,
+  bytes: 6,
+  blob_ref: 7,
+  crdt: 8,
+};
+
+const TAG_TO_TYPE = new Map<number, ColumnType>(
+  Object.entries(TYPE_TO_TAG).map(([type, tag]) => [tag, type as ColumnType]),
+);
+
+export function columnTypeTag(type: ColumnType): number {
+  return TYPE_TO_TAG[type];
+}
+
+export function columnTypeFromTag(tag: number): ColumnType {
+  const type = TAG_TO_TYPE.get(tag);
+  if (type === undefined) {
+    throw new DecodeError(
+      'sync.invalid_request',
+      `unknown column type tag ${tag}`,
+    );
+  }
+  return type;
+}
+
+function writeValue(
+  writer: ByteWriter,
+  column: RowColumn,
+  value: Exclude<RowValue, null>,
+): void {
+  switch (column.type) {
+    case 'string':
+    case 'json':
+    case 'blob_ref':
+      if (typeof value !== 'string') {
+        throw new Error(
+          `column ${column.name} (${column.type}) requires a string value`,
+        );
+      }
+      writer.str(value);
+      return;
+    case 'integer':
+      if (typeof value !== 'number' || !Number.isSafeInteger(value)) {
+        throw new Error(
+          `column ${column.name} (integer) requires a safe integer value`,
+        );
+      }
+      writer.i64(value);
+      return;
+    case 'float':
+      if (typeof value !== 'number') {
+        throw new Error(
+          `column ${column.name} (float) requires a number value`,
+        );
+      }
+      writer.f64(value);
+      return;
+    case 'boolean':
+      if (typeof value !== 'boolean') {
+        throw new Error(
+          `column ${column.name} (boolean) requires a boolean value`,
+        );
+      }
+      writer.bool(value);
+      return;
+    case 'bytes':
+    case 'crdt':
+      // §2.4 tag 8: a `crdt` value is byte-for-byte a `bytes` value —
+      // opaque CRDT bytes (§5.10), no structural validation. `crdtType`
+      // selects the server merger and never touches the codec.
+      if (!(value instanceof Uint8Array)) {
+        throw new Error(
+          `column ${column.name} (${column.type}) requires a Uint8Array value`,
+        );
+      }
+      writer.bytes(value);
+      return;
+  }
+}
+
+function readValue(reader: ByteReader, column: RowColumn): RowValue {
+  switch (column.type) {
+    case 'string':
+      return reader.str();
+    case 'json': {
+      // Conventions `json` MUST, applied at row-codec decode (SPEC.md §2.4
+      // tag 5): the value must parse as a JSON document; the raw string is
+      // preserved verbatim for round-trip fidelity.
+      const raw = reader.str();
+      try {
+        JSON.parse(raw);
+      } catch {
+        throw new DecodeError(
+          'sync.invalid_request',
+          `json column ${column.name} does not parse as a JSON document`,
+        );
+      }
+      return raw;
+    }
+    case 'blob_ref': {
+      // §2.4 tag 7: the value is a canonical BlobRef JSON document
+      // (§5.9.1). Validated at decode, same class as tag-5 json; the raw
+      // string is preserved verbatim for re-encoding.
+      const raw = reader.str();
+      parseBlobRef(raw);
+      return raw;
+    }
+    case 'integer':
+      return reader.i64();
+    case 'float':
+      return reader.f64();
+    case 'boolean':
+      return reader.bool();
+    case 'bytes':
+    case 'crdt':
+      // §2.4 tag 8: opaque bytes, decoded exactly like tag 6 (no parse).
+      return reader.bytes();
+  }
+}
+
+export function writeRow(
+  writer: ByteWriter,
+  columns: readonly RowColumn[],
+  values: readonly RowValue[],
+): void {
+  if (values.length !== columns.length) {
+    throw new Error(
+      `row value count ${values.length} does not match column count ${columns.length}`,
+    );
+  }
+  const bitmapLength = Math.ceil(columns.length / 8);
+  const bitmap = new Uint8Array(bitmapLength);
+  for (let i = 0; i < columns.length; i++) {
+    const column = columns[i];
+    if (column === undefined) continue;
+    if (values[i] === null) {
+      if (!column.nullable) {
+        throw new Error(`column ${column.name} is not nullable`);
+      }
+      bitmap[i >> 3] = (bitmap[i >> 3] ?? 0) | (1 << (i & 7));
+    }
+  }
+  writer.raw(bitmap);
+  for (let i = 0; i < columns.length; i++) {
+    const column = columns[i];
+    const value = values[i];
+    if (column === undefined || value === null || value === undefined) continue;
+    writeValue(writer, column, value);
+  }
+}
+
+export function readRow(
+  reader: ByteReader,
+  columns: readonly RowColumn[],
+): RowValue[] {
+  const bitmapLength = Math.ceil(columns.length / 8);
+  const bitmap = reader.raw(bitmapLength);
+  for (let i = columns.length; i < bitmapLength * 8; i++) {
+    if ((((bitmap[i >> 3] ?? 0) >> (i & 7)) & 1) !== 0) {
+      throw new DecodeError(
+        'sync.invalid_request',
+        'non-zero padding bit in row null bitmap',
+      );
+    }
+  }
+  const values: RowValue[] = [];
+  for (let i = 0; i < columns.length; i++) {
+    const column = columns[i];
+    if (column === undefined) continue;
+    const isNull = (((bitmap[i >> 3] ?? 0) >> (i & 7)) & 1) !== 0;
+    if (isNull) {
+      if (!column.nullable) {
+        throw new DecodeError(
+          'sync.invalid_request',
+          `null bit set for non-nullable column ${column.name}`,
+        );
+      }
+      values.push(null);
+    } else {
+      values.push(readValue(reader, column));
+    }
+  }
+  return values;
+}
+
+/** Encode one standalone row (e.g. a push payload or conflict serverRow). */
+export function encodeRow(
+  columns: readonly RowColumn[],
+  values: readonly RowValue[],
+): Uint8Array {
+  const writer = new ByteWriter();
+  writeRow(writer, columns, values);
+  return writer.finish();
+}
+
+/** Decode one standalone row; the bytes must contain exactly one row. */
+export function decodeRow(
+  columns: readonly RowColumn[],
+  bytes: Uint8Array,
+): RowValue[] {
+  const reader = new ByteReader(bytes);
+  const values = readRow(reader, columns);
+  reader.expectFullyConsumed('row payload');
+  return values;
+}

package/src/segment.ts

@@ -0,0 +1,150 @@
+/**
+ * SSG2 rows segments (SPEC.md §5.2) — the mandatory bootstrap format.
+ *
+ * A standalone binary container: magic, format version, flags, a column
+ * descriptor header (validation checksum, never inference), then
+ * self-delimiting row blocks terminated by a mandatory `rowCount = 0` end
+ * marker. Each row record carries the row's current `server_version`
+ * (`serverVersion`, ≥ 1) ahead of the row-codec bytes, so segment-applied
+ * rows participate in §6.2 conflict detection (§5.6).
+ */
+import { ByteReader, ByteWriter, utf8Encode } from './bytes';
+import { DecodeError } from './errors';
+import {
+  columnTypeFromTag,
+  columnTypeTag,
+  type RowColumn,
+  type RowValue,
+  readRow,
+  writeRow,
+} from './row-codec';
+
+export const ROWS_SEGMENT_MAGIC = 'SSG2';
+export const ROWS_SEGMENT_FORMAT_VERSION = 1;
+
+const MAGIC_BYTES = utf8Encode(ROWS_SEGMENT_MAGIC);
+
+/** One §5.2 row record: the row's `server_version` plus its values. */
+export interface SegmentRow {
+  /** The row's `server_version` at `asOfCommitSeq` (§2.2); always ≥ 1. */
+  readonly serverVersion: number;
+  readonly values: readonly RowValue[];
+}
+
+export interface RowsSegment {
+  readonly table: string;
+  readonly schemaVersion: number;
+  readonly columns: readonly RowColumn[];
+  /** Row blocks in wire order; each block is applied in one transaction. */
+  readonly blocks: readonly (readonly SegmentRow[])[];
+}
+
+export function encodeRowsSegment(segment: RowsSegment): Uint8Array {
+  const writer = new ByteWriter();
+  writer.raw(MAGIC_BYTES);
+  writer.u16(ROWS_SEGMENT_FORMAT_VERSION);
+  writer.u16(0);
+  writer.str(segment.table);
+  writer.i32(segment.schemaVersion);
+  writer.u16(segment.columns.length);
+  for (const column of segment.columns) {
+    writer.str(column.name);
+    writer.u8(columnTypeTag(column.type));
+    writer.u8(column.nullable ? 1 : 0);
+  }
+  for (const block of segment.blocks) {
+    if (block.length === 0) {
+      throw new Error('a rows-segment block must contain at least one row');
+    }
+    const rowsWriter = new ByteWriter();
+    for (const row of block) {
+      if (row.serverVersion < 1) {
+        throw new Error(
+          `a rows-segment row serverVersion must be >= 1, got ${row.serverVersion}`,
+        );
+      }
+      rowsWriter.i64(row.serverVersion);
+      writeRow(rowsWriter, segment.columns, row.values);
+    }
+    const rows = rowsWriter.finish();
+    writer.u32(block.length);
+    writer.u32(rows.length);
+    writer.raw(rows);
+  }
+  writer.u32(0);
+  return writer.finish();
+}
+
+export function decodeRowsSegment(bytes: Uint8Array): RowsSegment {
+  const reader = new ByteReader(bytes);
+  const magic = reader.raw(4);
+  if (
+    magic[0] !== MAGIC_BYTES[0] ||
+    magic[1] !== MAGIC_BYTES[1] ||
+    magic[2] !== MAGIC_BYTES[2] ||
+    magic[3] !== MAGIC_BYTES[3]
+  ) {
+    throw new DecodeError('sync.invalid_request', 'bad rows segment magic');
+  }
+  const formatVersion = reader.u16();
+  if (formatVersion !== ROWS_SEGMENT_FORMAT_VERSION) {
+    throw new DecodeError(
+      'sync.invalid_request',
+      `unsupported rows segment format version ${formatVersion}`,
+    );
+  }
+  const flags = reader.u16();
+  if (flags !== 0) {
+    throw new DecodeError(
+      'sync.invalid_request',
+      `non-zero rows segment flags 0x${flags.toString(16)}`,
+    );
+  }
+  const table = reader.str();
+  const schemaVersion = reader.i32();
+  const columnCount = reader.u16();
+  const columns: RowColumn[] = [];
+  for (let i = 0; i < columnCount; i++) {
+    const name = reader.str();
+    const type = columnTypeFromTag(reader.u8());
+    const columnFlags = reader.u8();
+    if ((columnFlags & 0xfe) !== 0) {
+      throw new DecodeError(
+        'sync.invalid_request',
+        `reserved column flag bits set for column ${name}`,
+      );
+    }
+    columns.push({ name, type, nullable: columnFlags === 1 });
+  }
+  const blocks: SegmentRow[][] = [];
+  for (;;) {
+    if (reader.remaining < 4) {
+      throw new DecodeError(
+        'sync.invalid_request',
+        'rows segment truncated: missing end marker',
+      );
+    }
+    const rowCount = reader.u32();
+    if (rowCount === 0) {
+      reader.expectFullyConsumed('rows segment end marker');
+      break;
+    }
+    const byteLength = reader.u32();
+    const rowBytes = reader.raw(byteLength);
+    const blockReader = new ByteReader(rowBytes);
+    const block: SegmentRow[] = [];
+    for (let i = 0; i < rowCount; i++) {
+      const serverVersion = blockReader.i64();
+      if (serverVersion < 1) {
+        throw new DecodeError(
+          'sync.invalid_request',
+          `rows segment row serverVersion must be >= 1, got ${serverVersion}`,
+        );
+      }
+      block.push({ serverVersion, values: readRow(blockReader, columns) });
+    }
+    blockReader.expectFullyConsumed('rows block');
+    blocks.push(block);
+  }
+  return { table, schemaVersion, columns, blocks };
+}

package/src/stream.ts

@@ -0,0 +1,128 @@
+/**
+ * Incremental SSP2 message-stream scanner (SPEC.md §1.4, §8.7).
+ *
+ * The envelope grammar is self-delimiting — an 8-byte header, then
+ * length-prefixed frames until `END` — so a byte stream split across
+ * arbitrary chunk boundaries (WebSocket messages, §8.7) needs no
+ * reassembly protocol beyond concatenation plus this scanner: feed
+ * chunks, learn exactly where one complete envelope ends. Used by the
+ * server session (request assembly, pipelining detection), the client
+ * (response assembly), and the conformance harness (round attribution).
+ *
+ * The scanner validates only the 8-byte header (a stream whose header is
+ * not a valid SSP2 envelope has no findable end, §8.7 connection-fatal
+ * rule) and walks frame length prefixes; full decoding stays with
+ * `decodeMessage`.
+ */
+import { utf8Encode } from './bytes';
+import { PROTOCOL_WIRE_VERSION, SYNC_PACK_MAGIC } from './constants';
+import { DecodeError } from './errors';
+
+const MAGIC = utf8Encode(SYNC_PACK_MAGIC);
+/** `END` frame type byte (§1.2). */
+const END_FRAME_TYPE = 0x00;
+
+export interface ScannedMessage {
+  /** The complete envelope bytes (header through the END frame). */
+  readonly message: Uint8Array;
+  /** Byte count buffered PAST the END frame — a §8.7 stream MUST end
+   * exactly at the END frame's last byte, so any excess is a protocol
+   * violation (pipelining) for the caller to act on. */
+  readonly excess: number;
+}
+
+export class MessageStreamScanner {
+  #buffer = new Uint8Array(1024);
+  #length = 0;
+  /** Parse cursor: start of the next frame header; -1 while the 8-byte
+   * envelope header is still incomplete. */
+  #offset = -1;
+  #complete = false;
+
+  /** True once any bytes were fed. */
+  get started(): boolean {
+    return this.#length > 0;
+  }
+
+  /**
+   * Feed one chunk. Returns the completed message once the END frame is
+   * fully buffered, `undefined` while more bytes are needed. Throws
+   * `DecodeError` on an invalid envelope header (connection-fatal per
+   * §8.7) and plain `Error` on use after completion.
+   */
+  push(chunk: Uint8Array): ScannedMessage | undefined {
+    if (this.#complete) {
+      throw new Error('MessageStreamScanner: message already complete');
+    }
+    this.#append(chunk);
+    if (this.#offset < 0) {
+      if (this.#length < 8) return undefined;
+      this.#checkHeader();
+      this.#offset = 8;
+    }
+    for (;;) {
+      if (this.#length - this.#offset < 5) return undefined;
+      const frameType = this.#buffer[this.#offset] as number;
+      const view = new DataView(
+        this.#buffer.buffer,
+        this.#buffer.byteOffset + this.#offset + 1,
+        4,
+      );
+      const frameLength = view.getUint32(0, true);
+      const frameEnd = this.#offset + 5 + frameLength;
+      if (this.#length < frameEnd) return undefined;
+      this.#offset = frameEnd;
+      if (frameType === END_FRAME_TYPE) {
+        this.#complete = true;
+        return {
+          message: this.#buffer.subarray(0, frameEnd),
+          excess: this.#length - frameEnd,
+        };
+      }
+    }
+  }
+
+  #append(chunk: Uint8Array): void {
+    const needed = this.#length + chunk.length;
+    if (needed > this.#buffer.length) {
+      let capacity = this.#buffer.length;
+      while (capacity < needed) capacity *= 2;
+      const grown = new Uint8Array(capacity);
+      grown.set(this.#buffer.subarray(0, this.#length));
+      this.#buffer = grown;
+    }
+    this.#buffer.set(chunk, this.#length);
+    this.#length = needed;
+  }
+
+  #checkHeader(): void {
+    const b = this.#buffer;
+    if (
+      b[0] !== MAGIC[0] ||
+      b[1] !== MAGIC[1] ||
+      b[2] !== MAGIC[2] ||
+      b[3] !== MAGIC[3]
+    ) {
+      throw new DecodeError('sync.invalid_request', 'bad envelope magic');
+    }
+    const wireVersion = (b[4] as number) | ((b[5] as number) << 8);
+    if (wireVersion !== PROTOCOL_WIRE_VERSION) {
+      throw new DecodeError(
+        'sync.invalid_request',
+        `unsupported wireVersion ${wireVersion}`,
+      );
+    }
+    if (b[6] !== 0x01 && b[6] !== 0x02) {
+      throw new DecodeError(
+        'sync.invalid_request',
+        `unknown msgKind byte 0x${(b[6] as number).toString(16)}`,
+      );
+    }
+    if (b[7] !== 0x00) {
+      throw new DecodeError(
+        'sync.invalid_request',
+        `non-zero envelope flags 0x${(b[7] as number).toString(16)}`,
+      );
+    }
+  }
+}

package/dist/blobs.d.ts

@@ -1,153 +0,0 @@
-/**
- * @syncular/core - Blob types for media/binary handling
- *
- * Content-addressable blob storage with presigned URL support.
- * Protocol types (BlobRef, BlobMetadata, etc.) live in ./schemas/blobs.ts
- */
-import type { BlobRef } from './schemas/blobs';
-/**
- * Transport interface for client-server blob communication.
- * This is used by the client blob manager to communicate with the server.
- */
-export interface BlobTransport {
-    /**
-     * Initiate a blob upload.
-     * Returns presigned URL info or indicates blob already exists (dedup).
-     */
-    initiateUpload(args: {
-        hash: string;
-        size: number;
-        mimeType: string;
-    }): Promise<{
-        exists: boolean;
-        uploadUrl?: string;
-        uploadMethod?: 'PUT' | 'POST';
-        uploadHeaders?: Record<string, string>;
-    }>;
-    /**
-     * Complete a blob upload.
-     * Call this after uploading to the presigned URL.
-     */
-    completeUpload(hash: string): Promise<{
-        ok: boolean;
-        error?: string;
-    }>;
-    /**
-     * Get a presigned download URL.
-     */
-    getDownloadUrl(hash: string): Promise<{
-        url: string;
-        expiresAt: string;
-    }>;
-}
-/**
- * Options for signing an upload URL.
- */
-export interface BlobSignUploadOptions {
-    /** SHA-256 hash (for naming and checksum validation) */
-    hash: string;
-    /** Optional tenant/partition namespace for storage lookups */
-    partitionId?: string;
-    /** Content size in bytes */
-    size: number;
-    /** MIME type */
-    mimeType: string;
-    /** URL expiration in seconds */
-    expiresIn: number;
-}
-/**
- * Result of signing an upload URL.
- */
-export interface BlobSignedUpload {
-    /** The URL to upload to */
-    url: string;
-    /** HTTP method */
-    method: 'PUT' | 'POST';
-    /** Required headers */
-    headers?: Record<string, string>;
-}
-/**
- * Options for signing a download URL.
- */
-export interface BlobSignDownloadOptions {
-    /** SHA-256 hash */
-    hash: string;
-    /** Optional tenant/partition namespace for storage lookups */
-    partitionId?: string;
-    /** URL expiration in seconds */
-    expiresIn: number;
-}
-export interface BlobStoragePartitionOptions {
-    partitionId?: string;
-}
-/**
- * Adapter for blob storage backends (S3, R2, custom).
- * Implementations handle actual storage; the sync server orchestrates.
- */
-export interface BlobStorageAdapter {
-    /** Adapter name for logging/debugging */
-    readonly name: string;
-    /**
-     * Generate a presigned URL for uploading a blob.
-     * The URL should enforce checksum validation if the backend supports it.
-     */
-    signUpload(options: BlobSignUploadOptions): Promise<BlobSignedUpload>;
-    /**
-     * Generate a presigned URL for downloading a blob.
-     */
-    signDownload(options: BlobSignDownloadOptions): Promise<string>;
-    /**
-     * Check if a blob exists in storage.
-     */
-    exists(hash: string, options?: BlobStoragePartitionOptions): Promise<boolean>;
-    /**
-     * Delete a blob (for garbage collection).
-     */
-    delete(hash: string, options?: BlobStoragePartitionOptions): Promise<void>;
-    /**
-     * Get blob metadata from storage (optional).
-     * Used to verify uploads completed successfully.
-     */
-    getMetadata?(hash: string, options?: BlobStoragePartitionOptions): Promise<{
-        size: number;
-        mimeType?: string;
-    } | null>;
-    /**
-     * Store blob data directly (for adapters that support direct storage).
-     * Used for snapshot chunks and other internal data.
-     */
-    put?(hash: string, data: Uint8Array, metadata?: Record<string, unknown>, options?: BlobStoragePartitionOptions): Promise<void>;
-    /**
-     * Store blob data directly from a stream.
-     * Preferred for large payloads to avoid full buffering in memory.
-     */
-    putStream?(hash: string, stream: ReadableStream<Uint8Array>, metadata?: Record<string, unknown>, options?: BlobStoragePartitionOptions): Promise<void>;
-    /**
-     * Get blob data directly (for adapters that support direct retrieval).
-     */
-    get?(hash: string, options?: BlobStoragePartitionOptions): Promise<Uint8Array | null>;
-    /**
-     * Get blob data directly as a stream (for adapters that support stream retrieval).
-     */
-    getStream?(hash: string, options?: BlobStoragePartitionOptions): Promise<ReadableStream<Uint8Array> | null>;
-}
-/**
- * Create a BlobRef from upload metadata.
- */
-export declare function createBlobRef(args: {
-    hash: string;
-    size: number;
-    mimeType: string;
-    encrypted?: boolean;
-    keyId?: string;
-}): BlobRef;
-/**
- * Parse a blob hash, validating format.
- * @returns The hex hash without prefix, or null if invalid.
- */
-export declare function parseBlobHash(hash: string): string | null;
-/**
- * Create a blob hash string from hex.
- */
-export declare function createBlobHash(hexHash: string): string;
-//# sourceMappingURL=blobs.d.ts.map

package/dist/blobs.d.ts.map

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