target-supabase-sdk 0.2.12 → 0.2.13

package/src/shared/log/log-persist-coordinator.ts

@@ -1,107 +0,0 @@
-import {
-    disableLogPersist,
-    ensureLogPersistFromEnv,
-    getLogPersistStats,
-    logPersistEnabledFromEnv,
-    snapshotLogPersistReady,
-    waitForLogPersistReady,
-} from "./enable-log-persist";
-import type { LogPersistReadySnapshot, LogPersistStats } from "./log-persist.interface";
-
-export interface LogPersistCoordinatorOptions {
-    /** Service identity written into each registry shard (e.g. `log-service`). */
-    service: string;
-    /** Directory holding one JSON shard per process (`main.json`, `guard.json`, …). */
-    registryFilePath: string;
-    /** Process labels main waits for before accepting traffic (must match `LOG_PERSIST_PROCESS` per child). */
-    expectedProcesses: readonly string[];
-    /** Max wait for {@link LogPersistCoordinator.waitForAllProcessesReady} (default 60_000 ms). */
-    readyTimeoutMs?: number;
-}
-
-/** Service-bound facade over env-driven log-persist registration and readiness gates. */
-export interface LogPersistCoordinator {
-    /** Whether `LOG_PERSIST_ENABLED` is active in this process. */
-    isEnabled(): boolean;
-
-    /** Absolute path to the multi-process registry directory configured at construction. */
-    getRegistryFilePath(): string;
-
-    /**
-     * Enable log-persist for this process and write/update its registry shard.
-     * @param process Optional label; defaults to `LOG_PERSIST_PROCESS` env.
-     */
-    registerProcess(process?: string): Promise<boolean>;
-
-    /** Block until every {@link LogPersistCoordinatorOptions.expectedProcesses} entry is registered and fresh. */
-    waitForAllProcessesReady(): Promise<LogPersistReadySnapshot>;
-
-    /** Immediate readiness snapshot without blocking; `null` when log-persist is disabled. */
-    snapshotProcessesReady(): Promise<LogPersistReadySnapshot | null>;
-
-    /** Flush-queue stats for observability; `null` when log-persist is disabled. */
-    getPersistStats(): LogPersistStats | null;
-
-    /** Flush pending logs and tear down log-persist (call from process shutdown hooks). */
-    shutdownLogPersist(): Promise<void>;
-}
-
-/**
- * Bind service-specific log-persist registry settings (process list, paths, timeouts).
- * Each L3 service exports one instance from `src/startup/log-persist.ts`.
- */
-export function createLogPersistCoordinator(options: LogPersistCoordinatorOptions): LogPersistCoordinator {
-    const { service, registryFilePath, expectedProcesses, readyTimeoutMs } = options;
-
-    return {
-        isEnabled() {
-            return logPersistEnabledFromEnv();
-        },
-
-        getRegistryFilePath() {
-            return registryFilePath;
-        },
-
-        registerProcess(process?: string) {
-            return ensureLogPersistFromEnv({
-                process,
-                service,
-                registryFilePath,
-            });
-        },
-
-        waitForAllProcessesReady() {
-            return waitForLogPersistReady({
-                registryFilePath,
-                service,
-                expectedProcesses: [...expectedProcesses],
-                timeoutMs: readyTimeoutMs,
-            });
-        },
-
-        async snapshotProcessesReady() {
-            if (!logPersistEnabledFromEnv()) {
-                return null;
-            }
-            return snapshotLogPersistReady({
-                registryFilePath,
-                service,
-                expectedProcesses: [...expectedProcesses],
-            });
-        },
-
-        getPersistStats() {
-            if (!logPersistEnabledFromEnv()) {
-                return null;
-            }
-            return getLogPersistStats();
-        },
-
-        async shutdownLogPersist() {
-            if (!logPersistEnabledFromEnv()) {
-                return;
-            }
-            await disableLogPersist();
-        },
-    };
-}

package/src/shared/log/log-persist-errors.ts

@@ -1,16 +0,0 @@
-const PERMANENT_LOG_PERSIST_ERROR_PATTERNS = [
-    /not initialized/i,
-    /call initialize\(\) first/i,
-    /missing required supabase environment/i,
-    /preload env incomplete/i,
-];
-
-export function formatLogPersistError(error: unknown): string {
-    return error instanceof Error ? error.message : String(error);
-}
-
-/** Errors that will not succeed on retry without fixing process configuration. */
-export function isPermanentLogPersistError(error: unknown): boolean {
-    const message = formatLogPersistError(error);
-    return PERMANENT_LOG_PERSIST_ERROR_PATTERNS.some((pattern) => pattern.test(message));
-}

package/src/shared/log/log-persist-logger.ts

@@ -1,61 +0,0 @@
-import { createLogger } from "./create-logger";
-
-/** User-facing / lifecycle logs — may be persisted like normal app logs. */
-export const LOG_PERSIST_TOPIC = "log-persist";
-
-/** Operational logs from the persist pipeline — never re-offered to avoid feedback loops. */
-export const LOG_PERSIST_INTERNAL_TOPIC = "log-persist-internal";
-
-const logger = createLogger({ module: "log-persist" });
-
-let errorLogRateLimitMs = 5_000;
-const lastLoggedAt = new Map<string, number>();
-
-export function configurePersistLoggerRateLimit(ms: number): void {
-    errorLogRateLimitMs = Math.max(0, ms);
-}
-
-export function isLogPersistInternalTopic(topic: string | undefined): boolean {
-    return topic === LOG_PERSIST_INTERNAL_TOPIC;
-}
-
-type PersistLogData = Record<string, unknown>;
-
-function shouldEmit(level: "debug" | "info" | "warn" | "error", message: string): boolean {
-    if (level !== "error" && level !== "warn") {
-        return true;
-    }
-    if (errorLogRateLimitMs <= 0) {
-        return true;
-    }
-
-    const key = `${level}:${message}`;
-    const now = Date.now();
-    const last = lastLoggedAt.get(key);
-    if (last != null && now - last < errorLogRateLimitMs) {
-        return false;
-    }
-    lastLoggedAt.set(key, now);
-    return true;
-}
-
-function write(level: "debug" | "info" | "warn" | "error", message: string, data?: PersistLogData): void {
-    if (!shouldEmit(level, message)) {
-        return;
-    }
-    logger[level](message, {
-        topic: LOG_PERSIST_INTERNAL_TOPIC,
-        ...(data != null ? { data } : {}),
-    });
-}
-
-export const persistLogger = {
-    debug: (message: string, data?: PersistLogData) => write("debug", message, data),
-    info: (message: string, data?: PersistLogData) => write("info", message, data),
-    warn: (message: string, data?: PersistLogData) => write("warn", message, data),
-    error: (message: string, data?: PersistLogData) => write("error", message, data),
-};
-
-export function patchPersistLoggerScope(labels: Record<string, string>): void {
-    logger.resetScope({ labels });
-}

package/src/shared/log/log-persist-registry.ts

@@ -1,252 +0,0 @@
-import { mkdir, readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { createJsonFileStateStore } from "../../node/fs/json-state-store";
-import type { LogPersistProcessRecord, LogPersistRegistryState } from "./log-persist.interface";
-import { persistLogger } from "./log-persist-logger";
-
-const DEFAULT_REGISTRY: LogPersistRegistryState = {
-    updatedAt: new Date(0).toISOString(),
-    service: "",
-    processes: {},
-};
-
-/** Per-process shard — each process owns one file; no cross-process RMW. */
-interface LogPersistProcessShard extends LogPersistProcessRecord {
-    service: string;
-    updatedAt: string;
-}
-
-const DEFAULT_SHARD: LogPersistProcessShard = {
-    service: "",
-    updatedAt: new Date(0).toISOString(),
-    pid: 0,
-    enabledAt: new Date(0).toISOString(),
-    lastHeartbeatAt: new Date(0).toISOString(),
-};
-
-const legacyStores = new Map<
-    string,
-    ReturnType<typeof createJsonFileStateStore<LogPersistRegistryState, "processes">>
->();
-
-const shardStores = new Map<string, ReturnType<typeof createJsonFileStateStore<LogPersistProcessShard>>>();
-
-function isLegacyRegistryFile(registryPath: string): boolean {
-    return registryPath.endsWith(".json");
-}
-
-function legacyStoreFor(filePath: string) {
-    let store = legacyStores.get(filePath);
-    if (store == null) {
-        store = createJsonFileStateStore<LogPersistRegistryState, "processes">({
-            filePath,
-            defaultState: DEFAULT_REGISTRY,
-            nestedKeys: ["processes"],
-            updatedAtKey: "updatedAt",
-        });
-        legacyStores.set(filePath, store);
-    }
-    return store;
-}
-
-function shardStoreFor(shardFilePath: string) {
-    let store = shardStores.get(shardFilePath);
-    if (store == null) {
-        store = createJsonFileStateStore<LogPersistProcessShard>({
-            filePath: shardFilePath,
-            defaultState: DEFAULT_SHARD,
-            updatedAtKey: "updatedAt",
-        });
-        shardStores.set(shardFilePath, store);
-    }
-    return store;
-}
-
-function shardFilePath(registryDir: string, process: string): string {
-    return join(registryDir, `${process}.json`);
-}
-
-/** Registry root directory — one shard file per process under this path. */
-export function defaultLogPersistRegistryPath(registryDir: string): string {
-    return join(registryDir, "log-persist-registry");
-}
-
-async function readShardedLogPersistRegistry(registryDir: string): Promise<LogPersistRegistryState> {
-    await mkdir(registryDir, { recursive: true });
-
-    let entries: string[];
-    try {
-        entries = await readdir(registryDir);
-    } catch {
-        return { ...DEFAULT_REGISTRY };
-    }
-
-    const processes: Record<string, LogPersistProcessRecord> = {};
-    let service = "";
-    let updatedAt = new Date(0).toISOString();
-
-    for (const name of entries) {
-        if (!name.endsWith(".json")) {
-            continue;
-        }
-
-        const processName = name.slice(0, -".json".length);
-        if (processName === "" || processName.startsWith("_")) {
-            continue;
-        }
-
-        try {
-            const raw = await readFile(join(registryDir, name), "utf8");
-            const shard = JSON.parse(raw) as Partial<LogPersistProcessShard>;
-            if (shard.service != null && shard.service !== "") {
-                service = shard.service;
-            }
-            if (shard.updatedAt != null && shard.updatedAt > updatedAt) {
-                updatedAt = shard.updatedAt;
-            }
-            processes[processName] = {
-                pid: shard.pid ?? 0,
-                enabledAt: shard.enabledAt ?? new Date(0).toISOString(),
-                lastHeartbeatAt: shard.lastHeartbeatAt ?? new Date(0).toISOString(),
-            };
-        } catch {
-            persistLogger.warn("registry shard read skipped — corrupt or missing", {
-                registryDir,
-                shard: name,
-            });
-        }
-    }
-
-    return { updatedAt, service, processes };
-}
-
-export async function registerLogPersistProcess(input: {
-    registryFilePath: string;
-    service: string;
-    process: string;
-}): Promise<void> {
-    const now = new Date().toISOString();
-    const record: LogPersistProcessRecord = {
-        pid: process.pid,
-        enabledAt: now,
-        lastHeartbeatAt: now,
-    };
-
-    if (isLegacyRegistryFile(input.registryFilePath)) {
-        await legacyStoreFor(input.registryFilePath).write({
-            service: input.service,
-            processes: {
-                [input.process]: record,
-            },
-        });
-    } else {
-        await shardStoreFor(shardFilePath(input.registryFilePath, input.process)).write({
-            service: input.service,
-            pid: record.pid,
-            enabledAt: record.enabledAt,
-            lastHeartbeatAt: record.lastHeartbeatAt,
-        });
-    }
-
-    persistLogger.info("registry process registered", {
-        registryFilePath: input.registryFilePath,
-        service: input.service,
-        process: input.process,
-        pid: record.pid,
-    });
-}
-
-export async function heartbeatLogPersistProcess(input: { registryFilePath: string; process: string }): Promise<void> {
-    if (isLegacyRegistryFile(input.registryFilePath)) {
-        const current = await legacyStoreFor(input.registryFilePath).read();
-        const existing = current.processes[input.process];
-        if (existing == null) {
-            persistLogger.warn("registry heartbeat skipped — process not registered", {
-                registryFilePath: input.registryFilePath,
-                process: input.process,
-            });
-            return;
-        }
-
-        await legacyStoreFor(input.registryFilePath).write({
-            processes: {
-                [input.process]: {
-                    ...existing,
-                    lastHeartbeatAt: new Date().toISOString(),
-                },
-            },
-        });
-        return;
-    }
-
-    const store = shardStoreFor(shardFilePath(input.registryFilePath, input.process));
-    const current = await store.read();
-    if (current.pid === 0) {
-        persistLogger.warn("registry heartbeat skipped — process not registered", {
-            registryFilePath: input.registryFilePath,
-            process: input.process,
-        });
-        return;
-    }
-
-    await store.write({
-        lastHeartbeatAt: new Date().toISOString(),
-    });
-}
-
-export async function unregisterLogPersistProcess(input: { registryFilePath: string; process: string }): Promise<void> {
-    if (isLegacyRegistryFile(input.registryFilePath)) {
-        const current = await legacyStoreFor(input.registryFilePath).read();
-        const existing = current.processes[input.process];
-        if (existing == null) {
-            persistLogger.warn("registry unregister skipped — process not found", {
-                registryFilePath: input.registryFilePath,
-                process: input.process,
-            });
-            return;
-        }
-
-        await legacyStoreFor(input.registryFilePath).write({
-            processes: {
-                [input.process]: {
-                    ...existing,
-                    pid: 0,
-                    lastHeartbeatAt: new Date(0).toISOString(),
-                },
-            },
-        });
-
-        persistLogger.info("registry process unregistered", {
-            registryFilePath: input.registryFilePath,
-            process: input.process,
-        });
-        return;
-    }
-
-    const store = shardStoreFor(shardFilePath(input.registryFilePath, input.process));
-    const current = await store.read();
-    if (current.pid === 0) {
-        persistLogger.warn("registry unregister skipped — process not found", {
-            registryFilePath: input.registryFilePath,
-            process: input.process,
-        });
-        return;
-    }
-
-    await store.write({
-        pid: 0,
-        lastHeartbeatAt: new Date(0).toISOString(),
-    });
-
-    persistLogger.info("registry process unregistered", {
-        registryFilePath: input.registryFilePath,
-        process: input.process,
-    });
-}
-
-export async function readLogPersistRegistry(registryFilePath: string): Promise<LogPersistRegistryState> {
-    if (isLegacyRegistryFile(registryFilePath)) {
-        return legacyStoreFor(registryFilePath).read();
-    }
-    return readShardedLogPersistRegistry(registryFilePath);
-}

package/src/shared/log/log-persist.config.ts

@@ -1,115 +0,0 @@
-import { envBool, envInt, envMs } from "../../node/env/env-parsers";
-import type { LogPersistConfig } from "./log-persist.interface";
-
-export const DEFAULT_LOG_PERSIST_CONFIG: LogPersistConfig = {
-    fast: {
-        maxBufferEntries: 500,
-    },
-    medium: {
-        debounceMs: 5_000,
-        maxEntries: 20,
-        maxBytes: 512 * 1024,
-        maxBufferEntries: 1_000,
-    },
-    slow: {
-        maxEntries: 400,
-        maxBytes: 512 * 1024,
-        maxAgeMs: 120_000,
-        maxBufferEntries: 2_000,
-    },
-    postTimeoutMs: 30_000,
-    shutdownDrainTimeoutMs: 15_000,
-    laneRetryIntervalMs: 5_000,
-    errorLogRateLimitMs: 5_000,
-    circuitBreakerPermanentFailureThreshold: 3,
-};
-
-export function resolveLogPersistConfig(partial?: Partial<LogPersistConfig>): LogPersistConfig {
-    const defaults = DEFAULT_LOG_PERSIST_CONFIG;
-    return {
-        fast: { ...defaults.fast, ...partial?.fast },
-        medium: { ...defaults.medium, ...partial?.medium },
-        slow: { ...defaults.slow, ...partial?.slow },
-        postTimeoutMs: partial?.postTimeoutMs ?? defaults.postTimeoutMs,
-        shutdownDrainTimeoutMs: partial?.shutdownDrainTimeoutMs ?? defaults.shutdownDrainTimeoutMs,
-        laneRetryIntervalMs: partial?.laneRetryIntervalMs ?? defaults.laneRetryIntervalMs,
-        errorLogRateLimitMs: partial?.errorLogRateLimitMs ?? defaults.errorLogRateLimitMs,
-        circuitBreakerPermanentFailureThreshold:
-            partial?.circuitBreakerPermanentFailureThreshold ?? defaults.circuitBreakerPermanentFailureThreshold,
-    };
-}
-
-export function logPersistEnabledFromEnv(env: NodeJS.ProcessEnv = process.env): boolean {
-    return envBool("LOG_PERSIST_ENABLED", false, env);
-}
-
-export function logPersistServiceFromEnv(env: NodeJS.ProcessEnv = process.env): string | undefined {
-    const raw = env.LOG_PERSIST_SERVICE?.trim();
-    return raw != null && raw !== "" ? raw : undefined;
-}
-
-export function logPersistProcessFromEnv(env: NodeJS.ProcessEnv = process.env): string | undefined {
-    const raw = env.LOG_PERSIST_PROCESS?.trim();
-    return raw != null && raw !== "" ? raw : undefined;
-}
-
-export function logPersistRegistryDirFromEnv(env: NodeJS.ProcessEnv = process.env): string | undefined {
-    const configured = env.LOG_PERSIST_REGISTRY_DIR?.trim();
-    if (configured != null && configured !== "") {
-        return configured;
-    }
-    const runtime = env.RUNTIME_DATA_DIR?.trim();
-    return runtime != null && runtime !== "" ? runtime : undefined;
-}
-
-export function logPersistConfigFromEnv(env: NodeJS.ProcessEnv = process.env): LogPersistConfig {
-    return resolveLogPersistConfig({
-        fast: {
-            maxBufferEntries: envInt("LOG_FAST_MAX_BUFFER_ENTRIES", DEFAULT_LOG_PERSIST_CONFIG.fast.maxBufferEntries, {
-                env,
-                min: 1,
-            }),
-        },
-        medium: {
-            debounceMs: envMs("LOG_MEDIUM_DEBOUNCE_MS", DEFAULT_LOG_PERSIST_CONFIG.medium.debounceMs, { env }),
-            maxEntries: envInt("LOG_MEDIUM_MAX_ENTRIES", DEFAULT_LOG_PERSIST_CONFIG.medium.maxEntries, {
-                env,
-                min: 1,
-            }),
-            maxBytes: envInt("LOG_MEDIUM_MAX_BYTES", DEFAULT_LOG_PERSIST_CONFIG.medium.maxBytes, { env, min: 1 }),
-            maxBufferEntries: envInt(
-                "LOG_MEDIUM_MAX_BUFFER_ENTRIES",
-                DEFAULT_LOG_PERSIST_CONFIG.medium.maxBufferEntries,
-                { env, min: 1 },
-            ),
-        },
-        slow: {
-            maxEntries: envInt("LOG_SLOW_MAX_ENTRIES", DEFAULT_LOG_PERSIST_CONFIG.slow.maxEntries, { env, min: 1 }),
-            maxBytes: envInt("LOG_SLOW_MAX_BYTES", DEFAULT_LOG_PERSIST_CONFIG.slow.maxBytes, { env, min: 1 }),
-            maxAgeMs: envMs("LOG_SLOW_MAX_AGE_MS", DEFAULT_LOG_PERSIST_CONFIG.slow.maxAgeMs, { env }),
-            maxBufferEntries: envInt("LOG_SLOW_MAX_BUFFER_ENTRIES", DEFAULT_LOG_PERSIST_CONFIG.slow.maxBufferEntries, {
-                env,
-                min: 1,
-            }),
-        },
-        postTimeoutMs: envMs("LOG_PERSIST_POST_TIMEOUT_MS", DEFAULT_LOG_PERSIST_CONFIG.postTimeoutMs, { env }),
-        shutdownDrainTimeoutMs: envMs(
-            "LOG_PERSIST_SHUTDOWN_DRAIN_MS",
-            DEFAULT_LOG_PERSIST_CONFIG.shutdownDrainTimeoutMs,
-            { env },
-        ),
-        laneRetryIntervalMs: envMs("LOG_PERSIST_LANE_RETRY_MS", DEFAULT_LOG_PERSIST_CONFIG.laneRetryIntervalMs, {
-            env,
-        }),
-        errorLogRateLimitMs: envMs(
-            "LOG_PERSIST_ERROR_LOG_RATE_LIMIT_MS",
-            DEFAULT_LOG_PERSIST_CONFIG.errorLogRateLimitMs,
-            { env },
-        ),
-        circuitBreakerPermanentFailureThreshold: envInt(
-            "LOG_PERSIST_CIRCUIT_BREAKER_THRESHOLD",
-            DEFAULT_LOG_PERSIST_CONFIG.circuitBreakerPermanentFailureThreshold,
-            { env, min: 1 },
-        ),
-    });
-}

package/src/shared/log/log-persist.interface.ts

@@ -1,150 +0,0 @@
-import type { TargetDraft } from "../../core.interface";
-import type { List } from "../../list/list.interface";
-import type { LogEntry } from "./log-manager";
-
-/**
- * `ListDetails.loaderKey` stamped on every persisted log batch (write + read side).
- * Business type: **LogBatch** (transport flush). Pairs with log-service **LogTrace**
- * (`LogTrace.0`) after rekeying by `traceId`.
- */
-export const LOG_PERSIST_LOADER_KEY = "LogBatch.0";
-
-/** Alias for {@link LOG_PERSIST_LOADER_KEY} — preferred when contrasting with LogTrace. */
-export const LOG_BATCH_LOADER_KEY = LOG_PERSIST_LOADER_KEY;
-
-/** Persistence lane — maps to List tagList and flush policy. */
-export type LogPersistLane = "fast" | "medium" | "slow";
-
-export interface LogPersistFastConfig {
-    maxBufferEntries: number;
-}
-
-export interface LogPersistMediumConfig {
-    debounceMs: number;
-    maxEntries: number;
-    maxBytes: number;
-    maxBufferEntries: number;
-}
-
-export interface LogPersistSlowConfig {
-    maxEntries: number;
-    maxBytes: number;
-    maxAgeMs: number;
-    maxBufferEntries: number;
-}
-
-export interface LogPersistConfig {
-    fast: LogPersistFastConfig;
-    medium: LogPersistMediumConfig;
-    slow: LogPersistSlowConfig;
-    /** postListCreate / network ceiling per batch */
-    postTimeoutMs: number;
-    /** Graceful shutdown drain ceiling */
-    shutdownDrainTimeoutMs: number;
-    /** Delay before medium/slow lane flush retries after failure (fast lane uses the same interval). */
-    laneRetryIntervalMs: number;
-    /** Suppress duplicate persistLogger warn/error lines with the same message within this window. */
-    errorLogRateLimitMs: number;
-    /** Disable log-persist after this many consecutive permanent flush errors. */
-    circuitBreakerPermanentFailureThreshold: number;
-}
-
-export interface EnableLogPersistOptions {
-    service: string;
-    process: string;
-    /** Shared registry root directory — all processes use the same path; each writes its own shard file. */
-    registryFilePath?: string;
-    config?: Partial<LogPersistConfig>;
-}
-
-export interface EnsureLogPersistFromEnvOptions {
-    /** Overrides LOG_PERSIST_PROCESS when set. */
-    process?: string;
-    /** Overrides LOG_PERSIST_SERVICE when set. */
-    service?: string;
-    registryFilePath?: string;
-    config?: Partial<LogPersistConfig>;
-}
-
-export interface LogPersistProcessRecord {
-    pid: number;
-    enabledAt: string;
-    lastHeartbeatAt: string;
-}
-
-export interface LogPersistRegistryState {
-    updatedAt: string;
-    service: string;
-    processes: Record<string, LogPersistProcessRecord>;
-}
-
-export interface LogPersistQueueStats {
-    fast: number;
-    fastRetry: number;
-    medium: number;
-    slow: number;
-}
-
-export interface LogPersistQueueBytesStats {
-    fast: number;
-    fastRetry: number;
-    medium: number;
-    slow: number;
-}
-
-export interface LogPersistStats {
-    enabled: boolean;
-    draining: boolean;
-    circuitBreakerTripped: boolean;
-    permanentFailureCount: number;
-    service: string | null;
-    process: string | null;
-    queues: LogPersistQueueStats;
-    queueBytes: LogPersistQueueBytesStats;
-    mediumDebouncePending: boolean;
-    laneFlushing: Record<LogPersistLane, boolean>;
-    consecutiveFailures: Record<LogPersistLane, number>;
-    config: LogPersistConfig;
-    lastFlushAt: Record<LogPersistLane, string | null>;
-    lastError: string | null;
-    lastErrorAt: string | null;
-}
-
-export interface WaitForLogPersistReadyOptions {
-    registryFilePath: string;
-    service: string;
-    expectedProcesses: string[];
-    timeoutMs?: number;
-    pollIntervalMs?: number;
-    /** Process heartbeat older than this is treated as missing. */
-    staleMs?: number;
-}
-
-export interface LogPersistReadySnapshot {
-    ok: boolean;
-    missing: string[];
-    stale: string[];
-    registered: string[];
-}
-
-export interface LogBatchMeta {
-    service: string;
-    process: string;
-    pid: number;
-    lane: LogPersistLane;
-    count: number;
-    from: number | null;
-    to: number | null;
-    flushedAt: number;
-    idempotencyKey: string;
-}
-
-export interface BuildLogListDraftInput {
-    service: string;
-    process: string;
-    lane: LogPersistLane;
-    idempotencyKey: string;
-    entries: LogEntry[];
-}
-
-export type LogListDraft = TargetDraft<List>;