@tungthedev/streams-server 0.2.0

package/src/store/append.ts

@@ -0,0 +1,50 @@
+import type { Result } from "better-result";
+
+export type AppendRow = {
+  routingKey: Uint8Array | null;
+  contentType: string | null;
+  payload: Uint8Array;
+};
+
+export type ProducerInfo = {
+  id: string;
+  epoch: number;
+  seq: number;
+};
+
+export type AppendSuccess = {
+  lastOffset: bigint;
+  appendedRows: number;
+  closed: boolean;
+  duplicate: boolean;
+  producer?: { epoch: number; seq: number };
+};
+
+export type StoreAppendError =
+  | { kind: "not_found" | "gone" | "content_type_mismatch" }
+  | { kind: "stream_seq"; expected: string; received: string }
+  | { kind: "closed"; lastOffset: bigint }
+  | { kind: "producer_stale_epoch"; producerEpoch: number }
+  | { kind: "producer_gap"; expected: number; received: number }
+  | { kind: "producer_epoch_seq" };
+
+export type StoreAppendResult = Result<AppendSuccess, StoreAppendError>;
+
+export type StoreAppendTask = {
+  stream: string;
+  baseAppendMs: bigint;
+  rows: AppendRow[];
+  contentType: string | null;
+  streamSeq: string | null;
+  producer: ProducerInfo | null;
+  close: boolean;
+};
+
+export type StoreAppendBatchResult = {
+  results: StoreAppendResult[];
+  walBytesCommitted: number;
+};
+
+export type StoreAppendBatchError = { kind: "retryable" };
+
+export type StoreAppendBatch = Result<StoreAppendBatchResult, StoreAppendBatchError>;

package/src/store/bootstrap_restore_store.ts

@@ -0,0 +1,71 @@
+import type {
+  IndexRunRow,
+  LexiconIndexRunRow,
+  SecondaryIndexRunRow,
+} from "./rows";
+import type { StreamReadRow } from "./segment_read_store";
+import type { ProfileTouchControlStore } from "./touch_store";
+import type { MaybePromise } from "./capabilities";
+
+export interface BootstrapRestoreStore {
+  readonly touch: ProfileTouchControlStore;
+  close(): MaybePromise<void>;
+  nowMs(): bigint;
+  beginRestoreStream?(stream: string): MaybePromise<void>;
+  commitRestoreStream?(stream: string): MaybePromise<void>;
+  rollbackRestoreStream?(stream: string): MaybePromise<void>;
+  restoreStreamRow(row: StreamReadRow): MaybePromise<void>;
+  upsertStreamProfile(stream: string, profileJson: string): MaybePromise<void>;
+  deleteStreamProfile(stream: string): MaybePromise<void>;
+  upsertSegmentMeta(stream: string, count: number, offsets: Uint8Array, blocks: Uint8Array, lastTs: Uint8Array): MaybePromise<void>;
+  upsertManifestRow(
+    stream: string,
+    generation: number,
+    uploadedGeneration: number,
+    uploadedAtMs: bigint | null,
+    etag: string | null,
+    sizeBytes: number | null
+  ): MaybePromise<void>;
+  createSegmentRow(row: {
+    segmentId: string;
+    stream: string;
+    segmentIndex: number;
+    startOffset: bigint;
+    endOffset: bigint;
+    blockCount: number;
+    lastAppendMs: bigint;
+    payloadBytes: bigint;
+    sizeBytes: number;
+    localPath: string;
+  }): MaybePromise<void>;
+  markSegmentUploaded(segmentId: string, etag: string, uploadedAtMs: bigint): MaybePromise<void>;
+  upsertIndexState(stream: string, indexSecret: Uint8Array, indexedThrough: number): MaybePromise<void>;
+  insertIndexRun(row: Omit<IndexRunRow, "retired_gen" | "retired_at_ms">): MaybePromise<void>;
+  retireIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): MaybePromise<void>;
+  upsertSecondaryIndexState(
+    stream: string,
+    indexName: string,
+    indexSecret: Uint8Array,
+    configHash: string,
+    indexedThrough: number
+  ): MaybePromise<void>;
+  insertSecondaryIndexRun(row: Omit<SecondaryIndexRunRow, "retired_gen" | "retired_at_ms">): MaybePromise<void>;
+  retireSecondaryIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): MaybePromise<void>;
+  upsertLexiconIndexState(stream: string, sourceKind: string, sourceName: string, indexedThrough: number): MaybePromise<void>;
+  insertLexiconIndexRun(row: Omit<LexiconIndexRunRow, "retired_gen" | "retired_at_ms">): MaybePromise<void>;
+  retireLexiconIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): MaybePromise<void>;
+  upsertSearchCompanionPlan(stream: string, generation: number, planHash: string, planJson: string): MaybePromise<void>;
+  upsertSearchSegmentCompanion(
+    stream: string,
+    segmentIndex: number,
+    objectKey: string,
+    planGeneration: number,
+    sectionsJson: string,
+    sectionSizesJson: string,
+    sizeBytes: number,
+    primaryTimestampMinMs: bigint | null,
+    primaryTimestampMaxMs: bigint | null
+  ): MaybePromise<void>;
+  upsertSchemaRegistry(stream: string, registryJson: string): MaybePromise<void>;
+  setSchemaUploadedSizeBytes(stream: string, sizeBytes: number): MaybePromise<void>;
+}

package/src/store/capabilities.ts

@@ -0,0 +1,86 @@
+import type { WalStore } from "./wal_store";
+import type { StreamReadStore } from "./segment_read_store";
+import type { SchemaStore } from "./schema_profile_store";
+import type { ProfileStore } from "./schema_profile_store";
+import { dsError } from "../util/ds_error";
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export type DurableStoreCapabilities = {
+  wal: true;
+  schemas: true;
+  profiles: true;
+  streamLifecycle: true;
+  segmentReads: boolean;
+  indexes: boolean;
+  manifests: boolean;
+  objectStoreAccounting: boolean;
+  storageStats: boolean;
+  schemaPublication: boolean;
+  builtinProfiles: boolean;
+  internalMetrics: boolean;
+  touch: boolean;
+};
+
+export interface StoreLifecycle {
+  readonly kind: "sqlite" | "postgres";
+  readonly capabilities: DurableStoreCapabilities;
+  close(): MaybePromise<void>;
+  nowMs(): bigint;
+}
+
+export interface StreamStore {
+  getStream(stream: string): MaybePromise<StreamReadStoreRow | null>;
+  ensureStream(stream: string, opts?: EnsureStreamOptions | null): MaybePromise<StreamReadStoreRow>;
+  listStreams(limit: number, offset: number): MaybePromise<StreamReadStoreRow[]>;
+  listExpiredStreams(limit: number): MaybePromise<string[]>;
+  deleteStream(stream: string): MaybePromise<boolean>;
+  hardDeleteStream(stream: string): MaybePromise<boolean>;
+  isDeleted(row: StreamReadStoreRow): boolean;
+}
+
+export type StreamReadStoreRow = Awaited<ReturnType<StreamReadStore["getStreamForRead"]>> extends infer Row ? NonNullable<Row> : never;
+
+export type EnsureStreamOptions = {
+  contentType?: string | null;
+  profile?: string | null;
+  streamSeq?: string | null;
+  closed?: boolean;
+  ttlSeconds?: number | null;
+  expiresAtMs?: bigint | null;
+  streamFlags?: number;
+};
+
+export interface WalControlPlaneStore extends StoreLifecycle, StreamStore, StreamReadStore, WalStore, SchemaStore, ProfileStore {}
+
+export function requireWalControlPlaneStore(store: StoreLifecycle): WalControlPlaneStore {
+  const candidate = store as Partial<WalControlPlaneStore>;
+  if (
+    store.capabilities.wal !== true ||
+    store.capabilities.streamLifecycle !== true ||
+    store.capabilities.schemas !== true ||
+    store.capabilities.profiles !== true ||
+    typeof candidate.getStream !== "function" ||
+    typeof candidate.ensureStream !== "function" ||
+    typeof candidate.listStreams !== "function" ||
+    typeof candidate.listExpiredStreams !== "function" ||
+    typeof candidate.deleteStream !== "function" ||
+    typeof candidate.hardDeleteStream !== "function" ||
+    typeof candidate.isDeleted !== "function" ||
+    typeof candidate.close !== "function" ||
+    typeof candidate.nowMs !== "function" ||
+    typeof candidate.appendBatch !== "function" ||
+    typeof candidate.readWalRange !== "function" ||
+    typeof candidate.readWalRangeDesc !== "function" ||
+    typeof candidate.getStreamForRead !== "function" ||
+    typeof candidate.nowMsForRead !== "function" ||
+    typeof candidate.getWalOldestTimestampMsForRead !== "function" ||
+    typeof candidate.getSchemaRegistryForRead !== "function" ||
+    typeof candidate.commitSchemaMetadataMutation !== "function" ||
+    typeof candidate.getStreamProfileForRead !== "function" ||
+    typeof candidate.commitProfileMetadataMutation !== "function"
+  ) {
+    throw dsError("store does not provide WAL/control-plane capabilities");
+  }
+  return candidate as WalControlPlaneStore;
+}

package/src/store/full_mode_details_store.ts

@@ -0,0 +1,71 @@
+import type { MaybePromise } from "./capabilities";
+import type {
+  IndexRunRow,
+  IndexStateRow,
+  LexiconIndexRunRow,
+  LexiconIndexStateRow,
+  SearchCompanionPlanRow,
+  SearchSegmentCompanionRow,
+  SecondaryIndexRunRow,
+  SecondaryIndexStateRow,
+} from "./rows";
+import type { ManifestRow } from "./segment_manifest_store";
+import type { SchemaRegistryRow } from "./schema_profile_store";
+
+export type IndexStorageSummary = {
+  object_count: number;
+  bytes: bigint;
+};
+
+export type SecondaryIndexStorageSummary = IndexStorageSummary & {
+  index_name: string;
+};
+
+export type LexiconIndexStorageSummary = IndexStorageSummary & {
+  source_kind: string;
+  source_name: string;
+};
+
+export type ExactIndexDetailSnapshot = {
+  indexName: string;
+  state: SecondaryIndexStateRow | null;
+  activeRuns: SecondaryIndexRunRow[];
+  retiredRuns: SecondaryIndexRunRow[];
+};
+
+export type FullModeDetailsSnapshot = {
+  segmentCount: number;
+  uploadedSegmentCount: number;
+  manifest: ManifestRow;
+  schemaRow: SchemaRegistryRow | null;
+  uploadedSegmentBytes: bigint;
+  pendingSealedSegmentBytes: bigint;
+  routingIndexStorage: IndexStorageSummary;
+  secondaryIndexStorage: SecondaryIndexStorageSummary[];
+  lexiconIndexStorage: LexiconIndexStorageSummary[];
+  bundledCompanionStorage: IndexStorageSummary;
+  routingState: IndexStateRow | null;
+  routingRuns: IndexRunRow[];
+  retiredRoutingRuns: IndexRunRow[];
+  exactIndexes: ExactIndexDetailSnapshot[];
+  routingLexiconState: LexiconIndexStateRow | null;
+  routingLexiconRuns: LexiconIndexRunRow[];
+  retiredRoutingLexiconRuns: LexiconIndexRunRow[];
+  companionPlan: SearchCompanionPlanRow | null;
+  companionRows: SearchSegmentCompanionRow[];
+};
+
+export type FullModeDetailsSnapshotRequest = {
+  stream: string;
+  exactIndexNames: string[];
+};
+
+export type FullModeLagSnapshotRequest = {
+  stream: string;
+  segmentIndexes: number[];
+};
+
+export interface FullModeDetailsStore {
+  getFullModeDetailsSnapshot(request: FullModeDetailsSnapshotRequest): MaybePromise<FullModeDetailsSnapshot>;
+  getFullModeLagSnapshot(request: FullModeLagSnapshotRequest): MaybePromise<Map<number, bigint>>;
+}

package/src/store/index_store.ts

@@ -0,0 +1,104 @@
+import type {
+  IndexRunRow,
+  IndexStateRow,
+  LexiconIndexRunRow,
+  LexiconIndexStateRow,
+  SearchCompanionPlanRow,
+  SearchSegmentCompanionRow,
+  SecondaryIndexRunRow,
+  SecondaryIndexStateRow,
+  SegmentRow,
+  StreamRow,
+} from "./rows";
+import type { MaybePromise } from "./capabilities";
+import type { WalReadRow } from "./wal_store";
+
+export type ManifestGenerationRow = {
+  generation: number;
+};
+
+export interface IndexSharedReadStore {
+  nowMs(): bigint;
+  getStream(stream: string): MaybePromise<StreamRow | null>;
+  getSegmentByIndex(stream: string, segmentIndex: number): MaybePromise<SegmentRow | null>;
+  countUploadedSegments(stream: string): MaybePromise<number>;
+  getManifestRow(stream: string): MaybePromise<ManifestGenerationRow>;
+}
+
+export interface RoutingIndexStore extends IndexSharedReadStore {
+  getIndexState(stream: string): MaybePromise<IndexStateRow | null>;
+  upsertIndexState(stream: string, indexSecret: Uint8Array, indexedThrough: number): MaybePromise<void>;
+  updateIndexedThrough(stream: string, indexedThrough: number): MaybePromise<void>;
+  listIndexRuns(stream: string): MaybePromise<IndexRunRow[]>;
+  listIndexRunsAll(stream: string): MaybePromise<IndexRunRow[]>;
+  listRetiredIndexRuns(stream: string): MaybePromise<IndexRunRow[]>;
+  insertIndexRun(row: Omit<IndexRunRow, "retired_gen" | "retired_at_ms">): MaybePromise<void>;
+  retireIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): MaybePromise<void>;
+  deleteIndexRuns(runIds: string[]): MaybePromise<void>;
+  deleteIndex(stream: string): MaybePromise<void>;
+}
+
+export interface SecondaryIndexStore extends IndexSharedReadStore {
+  countSegmentsForStream(stream: string): MaybePromise<number>;
+  getSecondaryIndexState(stream: string, indexName: string): MaybePromise<SecondaryIndexStateRow | null>;
+  listSecondaryIndexStates(stream: string): MaybePromise<SecondaryIndexStateRow[]>;
+  upsertSecondaryIndexState(
+    stream: string,
+    indexName: string,
+    indexSecret: Uint8Array,
+    configHash: string,
+    indexedThrough: number
+  ): MaybePromise<void>;
+  updateSecondaryIndexedThrough(stream: string, indexName: string, indexedThrough: number): MaybePromise<void>;
+  listSecondaryIndexRuns(stream: string, indexName: string): MaybePromise<SecondaryIndexRunRow[]>;
+  listRetiredSecondaryIndexRuns(stream: string, indexName: string): MaybePromise<SecondaryIndexRunRow[]>;
+  insertSecondaryIndexRun(row: Omit<SecondaryIndexRunRow, "retired_gen" | "retired_at_ms">): MaybePromise<void>;
+  retireSecondaryIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): MaybePromise<void>;
+  deleteSecondaryIndexRuns(runIds: string[]): MaybePromise<void>;
+  deleteSecondaryIndex(stream: string, indexName: string): MaybePromise<void>;
+}
+
+export interface LexiconIndexStore extends IndexSharedReadStore {
+  countSegmentsForStream(stream: string): MaybePromise<number>;
+  readWalRange(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array): AsyncIterable<WalReadRow>;
+  getLexiconIndexState(stream: string, sourceKind: string, sourceName: string): MaybePromise<LexiconIndexStateRow | null>;
+  upsertLexiconIndexState(stream: string, sourceKind: string, sourceName: string, indexedThrough: number): MaybePromise<void>;
+  updateLexiconIndexedThrough(stream: string, sourceKind: string, sourceName: string, indexedThrough: number): MaybePromise<void>;
+  listLexiconIndexRuns(stream: string, sourceKind: string, sourceName: string): MaybePromise<LexiconIndexRunRow[]>;
+  listLexiconIndexRunsAll(stream: string, sourceKind: string, sourceName: string): MaybePromise<LexiconIndexRunRow[]>;
+  listRetiredLexiconIndexRuns(stream: string, sourceKind: string, sourceName: string): MaybePromise<LexiconIndexRunRow[]>;
+  insertLexiconIndexRun(row: Omit<LexiconIndexRunRow, "retired_gen" | "retired_at_ms">): MaybePromise<void>;
+  retireLexiconIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): MaybePromise<void>;
+  deleteLexiconIndexRuns(runIds: string[]): MaybePromise<void>;
+  deleteLexiconIndexSource(stream: string, sourceKind: string, sourceName: string): MaybePromise<void>;
+}
+
+export interface CompanionProgressStore {
+  countUploadedSegments(stream: string): MaybePromise<number>;
+  getSearchCompanionPlan(stream: string): MaybePromise<SearchCompanionPlanRow | null>;
+  getSearchSegmentCompanion(stream: string, segmentIndex: number): MaybePromise<SearchSegmentCompanionRow | null>;
+  listSearchSegmentCompanions(stream: string): MaybePromise<SearchSegmentCompanionRow[]>;
+}
+
+export interface SearchCompanionIndexStore {
+  getSegmentByIndex(stream: string, segmentIndex: number): MaybePromise<SegmentRow | null>;
+  countUploadedSegments(stream: string): MaybePromise<number>;
+  getSearchCompanionPlan(stream: string): MaybePromise<SearchCompanionPlanRow | null>;
+  listSearchCompanionPlanStreams(): MaybePromise<string[]>;
+  upsertSearchCompanionPlan(stream: string, generation: number, planHash: string, planJson: string): MaybePromise<void>;
+  deleteSearchCompanionPlan(stream: string): MaybePromise<void>;
+  getSearchSegmentCompanion(stream: string, segmentIndex: number): MaybePromise<SearchSegmentCompanionRow | null>;
+  listSearchSegmentCompanions(stream: string): MaybePromise<SearchSegmentCompanionRow[]>;
+  upsertSearchSegmentCompanion(
+    stream: string,
+    segmentIndex: number,
+    objectKey: string,
+    planGeneration: number,
+    sectionsJson: string,
+    sectionSizesJson: string,
+    sizeBytes: number,
+    primaryTimestampMinMs: bigint | null,
+    primaryTimestampMaxMs: bigint | null
+  ): MaybePromise<void>;
+  deleteSearchSegmentCompanions(stream: string): MaybePromise<void>;
+}

package/src/store/profile_touch_store.ts

@@ -0,0 +1 @@
+export type ProfileTouchStatePlan = "preserve" | "ensure" | "delete";

package/src/store/rows.ts

@@ -0,0 +1,144 @@
+export const STREAM_FLAG_DELETED = 1 << 0;
+export const STREAM_FLAG_TOUCH = 1 << 1;
+
+export type StreamRow = {
+  stream: string;
+  created_at_ms: bigint;
+  updated_at_ms: bigint;
+  content_type: string;
+  profile: string | null;
+  stream_seq: string | null;
+  closed: number;
+  closed_producer_id: string | null;
+  closed_producer_epoch: number | null;
+  closed_producer_seq: number | null;
+  ttl_seconds: number | null;
+  epoch: number;
+  next_offset: bigint;
+  sealed_through: bigint;
+  uploaded_through: bigint;
+  uploaded_segment_count: number;
+  pending_rows: bigint;
+  pending_bytes: bigint;
+  logical_size_bytes: bigint;
+  wal_rows: bigint;
+  wal_bytes: bigint;
+  last_append_ms: bigint;
+  last_segment_cut_ms: bigint;
+  segment_in_progress: number;
+  expires_at_ms: bigint | null;
+  stream_flags: number;
+};
+
+export type SegmentRow = {
+  segment_id: string;
+  stream: string;
+  segment_index: number;
+  start_offset: bigint;
+  end_offset: bigint;
+  block_count: number;
+  last_append_ms: bigint;
+  payload_bytes: bigint;
+  size_bytes: number;
+  local_path: string;
+  created_at_ms: bigint;
+  uploaded_at_ms: bigint | null;
+  r2_etag: string | null;
+};
+
+export type SegmentMetaRow = {
+  stream: string;
+  segment_count: number;
+  segment_offsets: Uint8Array;
+  segment_blocks: Uint8Array;
+  segment_last_ts: Uint8Array;
+};
+
+export type IndexStateRow = {
+  stream: string;
+  index_secret: Uint8Array;
+  indexed_through: number;
+  updated_at_ms: bigint;
+};
+
+export type IndexRunRow = {
+  run_id: string;
+  stream: string;
+  level: number;
+  start_segment: number;
+  end_segment: number;
+  object_key: string;
+  size_bytes: number;
+  filter_len: number;
+  record_count: number;
+  retired_gen: number | null;
+  retired_at_ms: bigint | null;
+};
+
+export type SecondaryIndexStateRow = {
+  stream: string;
+  index_name: string;
+  index_secret: Uint8Array;
+  config_hash: string;
+  indexed_through: number;
+  updated_at_ms: bigint;
+};
+
+export type SecondaryIndexRunRow = {
+  run_id: string;
+  stream: string;
+  index_name: string;
+  level: number;
+  start_segment: number;
+  end_segment: number;
+  object_key: string;
+  size_bytes: number;
+  filter_len: number;
+  record_count: number;
+  retired_gen: number | null;
+  retired_at_ms: bigint | null;
+};
+
+export type LexiconIndexStateRow = {
+  stream: string;
+  source_kind: string;
+  source_name: string;
+  indexed_through: number;
+  updated_at_ms: bigint;
+};
+
+export type LexiconIndexRunRow = {
+  run_id: string;
+  stream: string;
+  source_kind: string;
+  source_name: string;
+  level: number;
+  start_segment: number;
+  end_segment: number;
+  object_key: string;
+  size_bytes: number;
+  record_count: number;
+  retired_gen: number | null;
+  retired_at_ms: bigint | null;
+};
+
+export type SearchCompanionPlanRow = {
+  stream: string;
+  generation: number;
+  plan_hash: string;
+  plan_json: string;
+  updated_at_ms: bigint;
+};
+
+export type SearchSegmentCompanionRow = {
+  stream: string;
+  segment_index: number;
+  object_key: string;
+  plan_generation: number;
+  sections_json: string;
+  section_sizes_json: string;
+  size_bytes: number;
+  primary_timestamp_min_ms: bigint | null;
+  primary_timestamp_max_ms: bigint | null;
+  updated_at_ms: bigint;
+};

package/src/store/schema_profile_store.ts

@@ -0,0 +1,73 @@
+import type { Result } from "better-result";
+import type { StreamReadRow } from "./segment_read_store";
+import type { SchemaRegistry } from "../schema/registry";
+import type { ProfileTouchStatePlan } from "./profile_touch_store";
+
+export type SchemaRegistryRow = {
+  stream: string;
+  registry_json: string;
+  updated_at_ms: bigint;
+  uploaded_size_bytes: bigint;
+};
+
+export type StoredProfileRow = {
+  stream: string;
+  profile_json: string;
+  updated_at_ms: bigint;
+};
+
+export type SchemaMetadataMutationContext = {
+  streamRow: StreamReadRow | null;
+  registryRow: SchemaRegistryRow | null;
+};
+
+export type SchemaMetadataMutationPlan<T> = {
+  registry: SchemaRegistry;
+  registryJson: string;
+  value: T;
+};
+
+export type SchemaMetadataCommit<T> = {
+  registry: SchemaRegistry;
+  updatedAtMs: bigint;
+  value: T;
+};
+
+export interface SchemaStore {
+  getSchemaRegistryForRead(stream: string): Promise<SchemaRegistryRow | null>;
+  commitSchemaMetadataMutation<T, E>(
+    stream: string,
+    mutation: (ctx: SchemaMetadataMutationContext) => Result<SchemaMetadataMutationPlan<T>, E>
+  ): Promise<Result<SchemaMetadataCommit<T>, E>>;
+}
+
+export type ProfileMetadataMutationContext = {
+  streamRow: StreamReadRow | null;
+  profileRow: StoredProfileRow | null;
+};
+
+export type ProfileMetadataPlan = {
+  streamProfile: string | null;
+  profileJson: string | null;
+  schemaRegistry: SchemaRegistry | null;
+  touchState?: ProfileTouchStatePlan;
+};
+
+export type ProfileMetadataMutationPlan<T> = {
+  metadata: ProfileMetadataPlan;
+  value: T;
+};
+
+export type ProfileMetadataCommit<T> = {
+  schemaRegistry: SchemaRegistry | null;
+  profileUpdatedAtMs: bigint;
+  value: T;
+};
+
+export interface ProfileStore {
+  getStreamProfileForRead(stream: string): Promise<StoredProfileRow | null>;
+  commitProfileMetadataMutation<T, E>(
+    stream: string,
+    mutation: (ctx: ProfileMetadataMutationContext) => Result<ProfileMetadataMutationPlan<T>, E>
+  ): Promise<Result<ProfileMetadataCommit<T>, E>>;
+}

package/src/store/schema_publication.ts

@@ -0,0 +1,6 @@
+import type { SchemaRegistry } from "../schema/registry";
+
+export interface SchemaPublicationStore {
+  uploadSchemaRegistry(stream: string, registry: SchemaRegistry): Promise<void>;
+  publishProfileSchemaRegistry(stream: string, registry: SchemaRegistry): Promise<void>;
+}