target-supabase-sdk 0.2.0 → 0.2.2

package/dist/chunks/enable-log-persist-BH-tbKEj.js

@@ -0,0 +1,1481 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFile, mkdir, writeFile, rename, readdir } from 'node:fs/promises';
+import { d as createLogger, a as CategoryList, w as postLogListCreate, m as isCreateTargetAlreadyExistsError, L as LogLevel, F as registerLogPersistOffer } from './create-logger-DyH3mZ8p.js';
+import 'lodash-es';
+import { createHash } from 'node:crypto';
+
+function readEnv(name, env = process.env) {
+    const value = env[name]?.trim();
+    if (value == null || value === "") {
+        return undefined;
+    }
+    return value;
+}
+function requireEnv(name, env = process.env) {
+    const value = readEnv(name, env);
+    if (value == null) {
+        throw new Error(`Missing required environment variable: ${name}`);
+    }
+    return value;
+}
+
+function envInt(name, defaultValue, options) {
+    const env = options?.env ?? process.env;
+    const raw = readEnv(name, env);
+    if (raw == null) {
+        return defaultValue;
+    }
+    const value = Number(raw);
+    if (!Number.isInteger(value)) {
+        throw new Error(`Invalid ${name}: ${raw}`);
+    }
+    const min = options?.min;
+    if (min != null && value < min) {
+        throw new Error(`Invalid ${name}: ${raw}`);
+    }
+    const max = options?.max;
+    if (max != null && value > max) {
+        throw new Error(`Invalid ${name}: ${raw}`);
+    }
+    return value;
+}
+function envMs(name, defaultMs, options) {
+    return envInt(name, defaultMs, { ...options, min: options?.min ?? 1 });
+}
+function envPort(defaultPort = 3100, options) {
+    const envKey = options?.envKey ?? "PORT";
+    return envInt(envKey, defaultPort, { ...options, min: 1, max: 65535 });
+}
+function envNumber(name, defaultValue, options) {
+    const env = options?.env ?? process.env;
+    const raw = readEnv(name, env);
+    if (raw == null) {
+        return defaultValue;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        throw new Error(`Invalid ${name}: ${raw}`);
+    }
+    const min = options?.min;
+    const resolved = options?.floor === true ? Math.floor(value) : value;
+    if (min != null && resolved < min) {
+        throw new Error(`Invalid ${name}: ${raw}`);
+    }
+    return resolved;
+}
+function envBool(name, defaultValue = false, env = process.env) {
+    const raw = readEnv(name, env)?.toLowerCase();
+    if (raw == null) {
+        return defaultValue;
+    }
+    return raw === "1" || raw === "true" || raw === "yes";
+}
+
+const DEFAULT_ENV_FILES = [".env.local", ".env"];
+function stripQuotes(value) {
+    return value.replace(/^["']|["']$/g, "");
+}
+/** Parse one KEY=VALUE line; returns null if line should be skipped. */
+function parseEnvLine(line) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+        return null;
+    }
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) {
+        return null;
+    }
+    const key = trimmed.slice(0, eq).trim();
+    const raw = trimmed.slice(eq + 1).trim();
+    return { key, value: stripQuotes(raw) };
+}
+function parseEnvFileContent(content, env) {
+    for (const line of content.split("\n")) {
+        const parsed = parseEnvLine(line);
+        if (parsed == null) {
+            continue;
+        }
+        if (env[parsed.key] == null || env[parsed.key] === "") {
+            env[parsed.key] = parsed.value;
+        }
+    }
+}
+function parseEnvFile(filePath, env) {
+    if (!existsSync(filePath)) {
+        return;
+    }
+    parseEnvFileContent(readFileSync(filePath, "utf8"), env);
+}
+/**
+ * Load `.env.local` then `.env` into `process.env` (or `options.env`).
+ * Existing non-empty env values are not overwritten.
+ */
+function loadEnvFiles(root, options) {
+    const env = options?.env ?? process.env;
+    const files = options?.files ?? DEFAULT_ENV_FILES;
+    for (const name of files) {
+        parseEnvFile(resolve(root, name), env);
+    }
+    options?.afterLoad?.();
+}
+
+/**
+ * Resolve project root from a module URL (typically `import.meta.url`).
+ * @param relativePath Path relative to the module file (default `".."` = parent directory).
+ */
+function resolveProjectRootFromModule(importMetaUrl, relativePath = "..") {
+    return resolve(fileURLToPath(new URL(relativePath, importMetaUrl)));
+}
+/**
+ * Walk upward from `importMetaUrl` until a `package.json` with matching `name` is found.
+ * Use for esbuild bundles under `dist/` where a single `..` hop lands in `dist/`, not repo root.
+ */
+function resolveProjectRootByPackageName(importMetaUrl, packageName) {
+    let dir = dirname(fileURLToPath(importMetaUrl));
+    for (;;) {
+        const packageJsonPath = resolve(dir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+            if (pkg.name === packageName) {
+                return dir;
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    throw new Error(`Could not find package root for "${packageName}" from ${importMetaUrl}`);
+}
+
+function mergeWithNested(defaults, current, patch, nestedKeys) {
+    const merged = {
+        ...defaults,
+        ...current,
+        ...patch,
+    };
+    for (const key of nestedKeys) {
+        const defaultNested = defaults[key];
+        if (defaultNested != null && typeof defaultNested === "object") {
+            merged[key] = {
+                ...defaultNested,
+                ...current?.[key],
+                ...patch[key],
+            };
+        }
+    }
+    return merged;
+}
+async function atomicWriteJson(filePath, data) {
+    await mkdir(dirname(filePath), { recursive: true });
+    const content = `${JSON.stringify(data, null, 2)}\n`;
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    await writeFile(tempPath, content, "utf8");
+    await rename(tempPath, filePath);
+}
+/** JSON file-backed state with optional nested key merge and atomic writes. */
+function createJsonFileStateStore(options) {
+    const { filePath, defaultState, nestedKeys = [], updatedAtKey } = options;
+    function touchUpdatedAt(state) {
+        if (updatedAtKey == null) {
+            return state;
+        }
+        return {
+            ...state,
+            [updatedAtKey]: new Date().toISOString(),
+        };
+    }
+    return {
+        async read() {
+            try {
+                const raw = await readFile(filePath, "utf8");
+                const parsed = JSON.parse(raw);
+                return mergeWithNested(defaultState, parsed, {}, nestedKeys);
+            }
+            catch {
+                return { ...defaultState };
+            }
+        },
+        async write(patch) {
+            const current = await this.read();
+            const next = touchUpdatedAt(mergeWithNested(defaultState, current, patch, nestedKeys));
+            await atomicWriteJson(filePath, next);
+            return next;
+        },
+        async reset() {
+            const next = touchUpdatedAt({ ...defaultState });
+            await atomicWriteJson(filePath, next);
+            return next;
+        },
+    };
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Poll `until()` until it returns true or `timeoutMs` elapses.
+ * @throws Error on timeout
+ */
+async function pollUntil(options) {
+    const intervalMs = options.intervalMs ?? 500;
+    const deadline = Date.now() + options.timeoutMs;
+    while (Date.now() < deadline) {
+        if (await options.until()) {
+            return;
+        }
+        await sleep(intervalMs);
+    }
+    throw new Error(`pollUntil timeout after ${options.timeoutMs}ms`);
+}
+
+const LOG_PERSIST_LOADER_KEY = "LogBatch.0";
+const DEFAULT_LOG_PERSIST_CONFIG = {
+    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,
+};
+function resolveLogPersistConfig(partial) {
+    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,
+    };
+}
+function logPersistEnabledFromEnv(env = process.env) {
+    return envBool("LOG_PERSIST_ENABLED", false, env);
+}
+function logPersistServiceFromEnv(env = process.env) {
+    const raw = env.LOG_PERSIST_SERVICE?.trim();
+    return raw != null && raw !== "" ? raw : undefined;
+}
+function logPersistProcessFromEnv(env = process.env) {
+    const raw = env.LOG_PERSIST_PROCESS?.trim();
+    return raw != null && raw !== "" ? raw : undefined;
+}
+function logPersistRegistryDirFromEnv(env = process.env) {
+    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;
+}
+function logPersistConfigFromEnv(env = process.env) {
+    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 }),
+    });
+}
+
+const BATCH_ID_VERSION = 1;
+/** Stable subset of LogEntry for idempotency hashing (same batch → same key). */
+function canonicalLogEntry(entry) {
+    return {
+        timestamp: entry.timestamp,
+        level: entry.level,
+        message: entry.message,
+        topic: entry.topic,
+        module: entry.module,
+        traceId: entry.traceId,
+        traceParentId: entry.traceParentId ?? null,
+        extra: entry.extra ?? null,
+        data: entry.data ?? null,
+        labels: entry.labels ?? null,
+    };
+}
+/**
+ * Deterministic List.value for a log batch — retries after timeout map to the same row key.
+ * SHA-256 over canonical JSON (service + process + lane + entries in order).
+ */
+function computeLogBatchIdempotencyKey(input) {
+    const payload = {
+        v: BATCH_ID_VERSION,
+        service: input.service,
+        process: input.process,
+        lane: input.lane,
+        entries: input.entries.map(canonicalLogEntry),
+    };
+    const hash = createHash("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
+    return `${hash.slice(0, 32)}`;
+}
+
+/** User-facing / lifecycle logs — may be persisted like normal app logs. */
+const LOG_PERSIST_TOPIC = "log-persist";
+/** Operational logs from the persist pipeline — never re-offered to avoid feedback loops. */
+const LOG_PERSIST_INTERNAL_TOPIC = "log-persist-internal";
+const logger = createLogger({ module: "log-persist" });
+function isLogPersistInternalTopic(topic) {
+    return topic === LOG_PERSIST_INTERNAL_TOPIC;
+}
+function write(level, message, data) {
+    logger[level](message, {
+        topic: LOG_PERSIST_INTERNAL_TOPIC,
+        ...(data != null ? { data } : {}),
+    });
+}
+const persistLogger = {
+    debug: (message, data) => write("debug", message, data),
+    info: (message, data) => write("info", message, data),
+    warn: (message, data) => write("warn", message, data),
+    error: (message, data) => write("error", message, data),
+};
+function patchPersistLoggerScope(labels) {
+    logger.resetScope({ labels });
+}
+
+function estimateEntriesBytes(entries) {
+    if (entries.length === 0) {
+        return 0;
+    }
+    try {
+        return Buffer.byteLength(JSON.stringify(entries), "utf8");
+    }
+    catch {
+        return entries.length * 512;
+    }
+}
+function buildLogListDraft(input) {
+    const { service, process, lane, idempotencyKey, entries } = input;
+    const first = entries[0];
+    const last = entries[entries.length - 1];
+    return {
+        name: `log-batch:${service}:${process}:${lane}`,
+        value: idempotencyKey,
+        category: CategoryList.LIST,
+        tagList: ["log", lane, service],
+        details: {
+            manifestVersion: 0,
+            loaderKey: LOG_PERSIST_LOADER_KEY,
+            meta: JSON.stringify({
+                service,
+                process,
+                pid: globalThis.process.pid,
+                lane,
+                count: entries.length,
+                from: first?.timestamp ?? null,
+                to: last?.timestamp ?? null,
+                flushedAt: Date.now(),
+                idempotencyKey,
+            }),
+            preview: first?.message ?? "",
+            items: entries,
+        },
+    };
+}
+async function withTimeout(promise, timeoutMs, label) {
+    let timer = null;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer != null) {
+            clearTimeout(timer);
+        }
+    }
+}
+async function postLogBatch(draft, postTimeoutMs) {
+    try {
+        const result = await withTimeout(postLogListCreate({
+            name: draft.name,
+            value: draft.value,
+            category: draft.category,
+            details: draft.details,
+        }), postTimeoutMs, "postLogListCreate");
+        if (!result.success) {
+            const message = result.error?.message ?? "postLogListCreate failed";
+            persistLogger.error("post log batch failed", {
+                idempotencyKey: draft.value,
+                name: draft.name,
+                error: message,
+            });
+            throw new Error(message);
+        }
+    }
+    catch (error) {
+        if (isCreateTargetAlreadyExistsError(error)) {
+            persistLogger.error("post log batch idempotent duplicate — treating as success", {
+                idempotencyKey: draft.value,
+                name: draft.name,
+            });
+            return;
+        }
+        throw error;
+    }
+}
+/** Take a prefix of entries that fits within maxBytes. */
+function takeEntriesWithinBytes(entries, maxBytes) {
+    if (entries.length === 0) {
+        return [];
+    }
+    const taken = [];
+    for (const entry of entries) {
+        const candidate = [...taken, entry];
+        if (taken.length > 0 && estimateEntriesBytes(candidate) > maxBytes) {
+            break;
+        }
+        taken.push(entry);
+    }
+    const result = taken.length > 0 ? taken : [entries[0]];
+    if (result.length < entries.length) {
+        persistLogger.warn("trimmed batch to maxBytes", {
+            requested: entries.length,
+            taken: result.length,
+            maxBytes,
+            takenBytes: estimateEntriesBytes(result),
+        });
+    }
+    return result;
+}
+
+const DEFAULT_REGISTRY = {
+    updatedAt: new Date(0).toISOString(),
+    service: "",
+    processes: {},
+};
+const DEFAULT_SHARD = {
+    service: "",
+    updatedAt: new Date(0).toISOString(),
+    pid: 0,
+    enabledAt: new Date(0).toISOString(),
+    lastHeartbeatAt: new Date(0).toISOString(),
+};
+const legacyStores = new Map();
+const shardStores = new Map();
+function isLegacyRegistryFile(registryPath) {
+    return registryPath.endsWith(".json");
+}
+function legacyStoreFor(filePath) {
+    let store = legacyStores.get(filePath);
+    if (store == null) {
+        store = createJsonFileStateStore({
+            filePath,
+            defaultState: DEFAULT_REGISTRY,
+            nestedKeys: ["processes"],
+            updatedAtKey: "updatedAt",
+        });
+        legacyStores.set(filePath, store);
+    }
+    return store;
+}
+function shardStoreFor(shardFilePath) {
+    let store = shardStores.get(shardFilePath);
+    if (store == null) {
+        store = createJsonFileStateStore({
+            filePath: shardFilePath,
+            defaultState: DEFAULT_SHARD,
+            updatedAtKey: "updatedAt",
+        });
+        shardStores.set(shardFilePath, store);
+    }
+    return store;
+}
+function shardFilePath(registryDir, process) {
+    return join(registryDir, `${process}.json`);
+}
+/** Registry root directory — one shard file per process under this path. */
+function defaultLogPersistRegistryPath(registryDir) {
+    return join(registryDir, "log-persist-registry");
+}
+async function readShardedLogPersistRegistry(registryDir) {
+    await mkdir(registryDir, { recursive: true });
+    let entries;
+    try {
+        entries = await readdir(registryDir);
+    }
+    catch {
+        return { ...DEFAULT_REGISTRY };
+    }
+    const processes = {};
+    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);
+            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 };
+}
+async function registerLogPersistProcess(input) {
+    const now = new Date().toISOString();
+    const record = {
+        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,
+    });
+}
+async function heartbeatLogPersistProcess(input) {
+    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(),
+    });
+}
+async function unregisterLogPersistProcess(input) {
+    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,
+    });
+}
+async function readLogPersistRegistry(registryFilePath) {
+    if (isLegacyRegistryFile(registryFilePath)) {
+        return legacyStoreFor(registryFilePath).read();
+    }
+    return readShardedLogPersistRegistry(registryFilePath);
+}
+
+var logPersistRegistry = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    defaultLogPersistRegistryPath: defaultLogPersistRegistryPath,
+    heartbeatLogPersistProcess: heartbeatLogPersistProcess,
+    readLogPersistRegistry: readLogPersistRegistry,
+    registerLogPersistProcess: registerLogPersistProcess,
+    unregisterLogPersistProcess: unregisterLogPersistProcess
+});
+
+const FAST_RETRY_INTERVAL_MS = 5_000;
+const HEARTBEAT_INTERVAL_MS = 30_000;
+function routeLane(level) {
+    if (level === LogLevel.CRITICAL) {
+        return "fast";
+    }
+    if (level === LogLevel.ERROR || level === LogLevel.SUCCESS) {
+        return "medium";
+    }
+    return "slow";
+}
+class LogPersist {
+    static instance = null;
+    enabled = false;
+    draining = false;
+    service = null;
+    processName = null;
+    registryFilePath = null;
+    config = DEFAULT_LOG_PERSIST_CONFIG;
+    fastQueue = [];
+    fastRetryQueue = [];
+    mediumQueue = [];
+    slowQueue = [];
+    mediumDebounceTimer = null;
+    slowQueueStartedAt = null;
+    fastRetryTimer = null;
+    heartbeatTimer = null;
+    lastHeartbeatAt = 0;
+    laneFlushing = {
+        fast: false,
+        medium: false,
+        slow: false,
+    };
+    consecutiveFailures = {
+        fast: 0,
+        medium: 0,
+        slow: 0,
+    };
+    lastFlushAt = {
+        fast: null,
+        medium: null,
+        slow: null,
+    };
+    lastError = null;
+    lastErrorAt = null;
+    shutdownHookInstalled = false;
+    shutdownPromise = null;
+    static getInstance() {
+        LogPersist.instance ??= new LogPersist();
+        return LogPersist.instance;
+    }
+    async enable(options) {
+        if (this.enabled) {
+            persistLogger.warn("log persist core enable skipped — already enabled", {
+                service: this.service,
+                process: this.processName,
+            });
+            return;
+        }
+        this.service = options.service;
+        this.processName = options.process;
+        this.registryFilePath = options.registryFilePath ?? null;
+        this.config = resolveLogPersistConfig(options.config);
+        this.draining = false;
+        this.shutdownPromise = null;
+        this.consecutiveFailures = { fast: 0, medium: 0, slow: 0 };
+        this.lastError = null;
+        this.lastErrorAt = null;
+        this.enabled = true;
+        patchPersistLoggerScope({
+            service: options.service,
+            process: options.process,
+        });
+        persistLogger.info("log persist core enabled", {
+            service: options.service,
+            process: options.process,
+            registryFilePath: this.registryFilePath,
+            config: this.config,
+            pid: process.pid,
+        });
+        registerLogPersistOffer((entry) => {
+            this.offer(entry);
+        });
+        if (this.registryFilePath != null) {
+            const { registerLogPersistProcess } = await Promise.resolve().then(function () { return logPersistRegistry; });
+            await registerLogPersistProcess({
+                registryFilePath: this.registryFilePath,
+                service: options.service,
+                process: options.process,
+            });
+            this.startHeartbeat();
+        }
+        this.installShutdownHook();
+    }
+    async disable() {
+        if (!this.enabled && !this.draining) {
+            persistLogger.debug("disable skipped — not enabled");
+            return;
+        }
+        persistLogger.info("log persist core disabling", this.queueSnapshot());
+        this.cancelMediumDebounce();
+        this.stopHeartbeat();
+        await this.shutdown();
+        persistLogger.info("log persist core disabled");
+    }
+    offer(entry) {
+        if (isLogPersistInternalTopic(entry.topic)) {
+            return;
+        }
+        if (!this.enabled || this.draining || this.service == null || this.processName == null) {
+            return;
+        }
+        void this.touchRegistryHeartbeat();
+        const lane = routeLane(entry.level);
+        if (lane === "fast") {
+            this.fastQueue.push(entry);
+            this.evictFastOverflow();
+            void this.flushFast();
+            return;
+        }
+        if (lane === "medium") {
+            this.mediumQueue.push(entry);
+            this.evictMediumOverflow();
+            this.scheduleMediumFlush();
+            return;
+        }
+        this.slowQueue.push(entry);
+        if (this.slowQueueStartedAt == null) {
+            this.slowQueueStartedAt = Date.now();
+        }
+        this.evictSlowOverflow();
+        this.scheduleSlowFlush();
+    }
+    getStats() {
+        return {
+            enabled: this.enabled,
+            draining: this.draining,
+            service: this.service,
+            process: this.processName,
+            queues: {
+                fast: this.fastQueue.length,
+                fastRetry: this.fastRetryQueue.length,
+                medium: this.mediumQueue.length,
+                slow: this.slowQueue.length,
+            },
+            queueBytes: {
+                fast: estimateEntriesBytes(this.fastQueue),
+                fastRetry: estimateEntriesBytes(this.fastRetryQueue),
+                medium: estimateEntriesBytes(this.mediumQueue),
+                slow: estimateEntriesBytes(this.slowQueue),
+            },
+            mediumDebouncePending: this.mediumDebounceTimer != null,
+            laneFlushing: { ...this.laneFlushing },
+            consecutiveFailures: { ...this.consecutiveFailures },
+            config: this.config,
+            lastFlushAt: { ...this.lastFlushAt },
+            lastError: this.lastError,
+            lastErrorAt: this.lastErrorAt,
+        };
+    }
+    async shutdown() {
+        if (this.shutdownPromise != null) {
+            return this.shutdownPromise;
+        }
+        this.shutdownPromise = this.shutdownInner();
+        return this.shutdownPromise;
+    }
+    async shutdownInner() {
+        if (this.draining) {
+            return;
+        }
+        this.draining = true;
+        this.enabled = false;
+        registerLogPersistOffer(null);
+        persistLogger.info("shutdown flush started", this.queueSnapshot());
+        this.cancelMediumDebounce();
+        await this.drainQueues(this.config.shutdownDrainTimeoutMs);
+        if (this.registryFilePath != null && this.processName != null) {
+            const { unregisterLogPersistProcess } = await Promise.resolve().then(function () { return logPersistRegistry; });
+            await unregisterLogPersistProcess({
+                registryFilePath: this.registryFilePath,
+                process: this.processName,
+            });
+        }
+        if (this.hasQueued()) {
+            persistLogger.warn("shutdown drain incomplete — queued logs dropped", {
+                ...this.queueSnapshot(),
+                shutdownDrainTimeoutMs: this.config.shutdownDrainTimeoutMs,
+            });
+            this.fastQueue = [];
+            this.fastRetryQueue = [];
+            this.mediumQueue = [];
+            this.slowQueue = [];
+            this.slowQueueStartedAt = null;
+        }
+        persistLogger.info("shutdown flush completed", this.queueSnapshot());
+    }
+    hasQueued() {
+        return (this.fastQueue.length > 0 ||
+            this.fastRetryQueue.length > 0 ||
+            this.mediumQueue.length > 0 ||
+            this.slowQueue.length > 0);
+    }
+    async drainQueues(timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (this.hasQueued() && Date.now() < deadline) {
+            await this.flushFast();
+            await this.flushMedium();
+            await this.flushSlow();
+        }
+    }
+    recordLaneError(lane, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.lastError = message;
+        this.lastErrorAt = new Date().toISOString();
+        this.consecutiveFailures[lane] += 1;
+    }
+    recordLaneSuccess(lane) {
+        this.lastError = null;
+        this.consecutiveFailures[lane] = 0;
+    }
+    queueSnapshot() {
+        return {
+            queues: {
+                fast: this.fastQueue.length,
+                fastRetry: this.fastRetryQueue.length,
+                medium: this.mediumQueue.length,
+                slow: this.slowQueue.length,
+            },
+            queueBytes: {
+                fast: estimateEntriesBytes(this.fastQueue),
+                fastRetry: estimateEntriesBytes(this.fastRetryQueue),
+                medium: estimateEntriesBytes(this.mediumQueue),
+                slow: estimateEntriesBytes(this.slowQueue),
+            },
+            laneFlushing: { ...this.laneFlushing },
+            consecutiveFailures: { ...this.consecutiveFailures },
+            lastError: this.lastError,
+        };
+    }
+    installShutdownHook() {
+        if (this.shutdownHookInstalled) {
+            return;
+        }
+        this.shutdownHookInstalled = true;
+        const handler = (signal) => {
+            persistLogger.info("shutdown signal received", { signal });
+            void this.shutdown();
+        };
+        process.once("SIGTERM", handler);
+        process.once("SIGINT", handler);
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            void this.touchRegistryHeartbeat(true);
+        }, HEARTBEAT_INTERVAL_MS);
+        this.heartbeatTimer.unref?.();
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer != null) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    async touchRegistryHeartbeat(force = false) {
+        if (this.registryFilePath == null || this.processName == null) {
+            return;
+        }
+        const now = Date.now();
+        if (!force && now - this.lastHeartbeatAt < HEARTBEAT_INTERVAL_MS) {
+            return;
+        }
+        this.lastHeartbeatAt = now;
+        await heartbeatLogPersistProcess({
+            registryFilePath: this.registryFilePath,
+            process: this.processName,
+        });
+    }
+    scheduleMediumFlush() {
+        const { debounceMs, maxEntries, maxBytes } = this.config.medium;
+        const queueBytes = estimateEntriesBytes(this.mediumQueue);
+        if (this.mediumQueue.length >= maxEntries || queueBytes >= maxBytes) {
+            persistLogger.warn("medium flush scheduled — threshold", {
+                reason: this.mediumQueue.length >= maxEntries ? "maxEntries" : "maxBytes",
+                queueLength: this.mediumQueue.length,
+                maxEntries,
+                queueBytes,
+                maxBytes,
+            });
+            this.cancelMediumDebounce();
+            void this.flushMedium();
+            return;
+        }
+        if (this.mediumDebounceTimer == null && this.mediumQueue.length > 0) {
+            persistLogger.debug("medium flush debounce scheduled", {
+                debounceMs,
+                queueLength: this.mediumQueue.length,
+                queueBytes,
+            });
+            this.mediumDebounceTimer = setTimeout(() => {
+                this.mediumDebounceTimer = null;
+                persistLogger.debug("medium flush debounce fired");
+                void this.flushMedium();
+            }, debounceMs);
+            this.mediumDebounceTimer.unref?.();
+        }
+    }
+    cancelMediumDebounce() {
+        if (this.mediumDebounceTimer != null) {
+            clearTimeout(this.mediumDebounceTimer);
+            this.mediumDebounceTimer = null;
+            persistLogger.debug("medium flush debounce cancelled");
+        }
+    }
+    scheduleSlowFlush() {
+        const { maxEntries, maxBytes, maxAgeMs } = this.config.slow;
+        const queueBytes = estimateEntriesBytes(this.slowQueue);
+        const ageMs = this.slowQueueStartedAt != null ? Date.now() - this.slowQueueStartedAt : 0;
+        if (this.slowQueue.length >= maxEntries || queueBytes >= maxBytes || ageMs >= maxAgeMs) {
+            persistLogger.debug("slow flush scheduled — threshold", {
+                reason: this.slowQueue.length >= maxEntries
+                    ? "maxEntries"
+                    : queueBytes >= maxBytes
+                        ? "maxBytes"
+                        : "maxAgeMs",
+                queueLength: this.slowQueue.length,
+                maxEntries,
+                queueBytes,
+                maxBytes,
+                ageMs,
+                maxAgeMs,
+            });
+            void this.flushSlow();
+        }
+    }
+    evictFastOverflow() {
+        const { maxBufferEntries } = this.config.fast;
+        let evicted = 0;
+        while (this.fastQueue.length + this.fastRetryQueue.length > maxBufferEntries) {
+            const removed = this.fastQueue.length > 0 ? this.fastQueue.shift() : this.fastRetryQueue.shift();
+            evicted += 1;
+            persistLogger.warn("fast queue overflow — evicted entry", {
+                evictedLevel: removed?.level,
+                evictedTopic: removed?.topic,
+                fromRetryQueue: this.fastQueue.length === 0,
+                maxBufferEntries,
+            });
+        }
+        if (evicted > 0) {
+            persistLogger.warn("fast queue overflow summary", { evicted, maxBufferEntries });
+        }
+    }
+    evictMediumOverflow() {
+        const { maxBufferEntries } = this.config.medium;
+        let evicted = 0;
+        while (this.mediumQueue.length > maxBufferEntries) {
+            const successIndex = this.mediumQueue.findIndex((entry) => entry.level === LogLevel.SUCCESS);
+            const removed = successIndex >= 0 ? this.mediumQueue.splice(successIndex, 1)[0] : this.mediumQueue.shift();
+            evicted += 1;
+            persistLogger.warn("medium queue overflow — evicted entry", {
+                evictedLevel: removed?.level,
+                evictedTopic: removed?.topic,
+                queueLength: this.mediumQueue.length,
+                maxBufferEntries,
+            });
+        }
+        if (evicted > 0) {
+            persistLogger.warn("medium queue overflow summary", {
+                evicted,
+                queueLength: this.mediumQueue.length,
+                maxBufferEntries,
+            });
+        }
+    }
+    evictSlowOverflow() {
+        const { maxBufferEntries } = this.config.slow;
+        let evicted = 0;
+        while (this.slowQueue.length > maxBufferEntries) {
+            const debugIndex = this.slowQueue.findIndex((entry) => entry.level === LogLevel.DEBUG);
+            const removed = debugIndex >= 0 ? this.slowQueue.splice(debugIndex, 1)[0] : this.slowQueue.shift();
+            evicted += 1;
+            persistLogger.warn("slow queue overflow — evicted entry", {
+                evictedLevel: removed?.level,
+                evictedTopic: removed?.topic,
+                queueLength: this.slowQueue.length,
+                maxBufferEntries,
+            });
+        }
+        if (evicted > 0) {
+            persistLogger.warn("slow queue overflow summary", {
+                evicted,
+                queueLength: this.slowQueue.length,
+                maxBufferEntries,
+            });
+        }
+        if (this.slowQueue.length === 0) {
+            this.slowQueueStartedAt = null;
+        }
+    }
+    async flushFast() {
+        if (this.laneFlushing.fast) {
+            persistLogger.debug("fast flush skipped — already flushing");
+            return;
+        }
+        if (this.service == null || this.processName == null) {
+            return;
+        }
+        this.laneFlushing.fast = true;
+        try {
+            while (this.fastQueue.length > 0 || this.fastRetryQueue.length > 0) {
+                const fromRetry = this.fastQueue.length === 0;
+                const entry = this.fastQueue.shift() ?? this.fastRetryQueue.shift();
+                if (entry == null) {
+                    break;
+                }
+                const idempotencyKey = computeLogBatchIdempotencyKey({
+                    service: this.service,
+                    process: this.processName,
+                    lane: "fast",
+                    entries: [entry],
+                });
+                try {
+                    const draft = buildLogListDraft({
+                        service: this.service,
+                        process: this.processName,
+                        lane: "fast",
+                        idempotencyKey,
+                        entries: [entry],
+                    });
+                    persistLogger.debug("fast flush posting batch", {
+                        idempotencyKey,
+                        fromRetry,
+                        level: entry.level,
+                        topic: entry.topic,
+                    });
+                    await postLogBatch(draft, this.config.postTimeoutMs);
+                    this.lastFlushAt.fast = new Date().toISOString();
+                    this.recordLaneSuccess("fast");
+                    persistLogger.info("fast lane flushed", {
+                        idempotencyKey,
+                        level: entry.level,
+                        topic: entry.topic,
+                        fastRetryRemaining: this.fastRetryQueue.length,
+                    });
+                }
+                catch (error) {
+                    this.recordLaneError("fast", error);
+                    this.fastRetryQueue.push(entry);
+                    persistLogger.error("fast flush failed — queued for retry", {
+                        idempotencyKey,
+                        error: this.lastError,
+                        retryInMs: FAST_RETRY_INTERVAL_MS,
+                        fastRetryQueue: this.fastRetryQueue.length,
+                    });
+                    this.scheduleFastRetry();
+                    break;
+                }
+            }
+        }
+        finally {
+            this.laneFlushing.fast = false;
+        }
+    }
+    scheduleFastRetry() {
+        if (this.fastRetryTimer != null) {
+            return;
+        }
+        persistLogger.warn("fast flush retry scheduled", { retryInMs: FAST_RETRY_INTERVAL_MS });
+        this.fastRetryTimer = setTimeout(() => {
+            this.fastRetryTimer = null;
+            persistLogger.debug("fast flush retry timer fired");
+            void this.flushFast();
+        }, FAST_RETRY_INTERVAL_MS);
+        this.fastRetryTimer.unref?.();
+    }
+    async flushMedium() {
+        if (this.laneFlushing.medium) {
+            persistLogger.debug("medium flush skipped — already flushing");
+            return;
+        }
+        if (this.mediumQueue.length === 0) {
+            return;
+        }
+        if (this.service == null || this.processName == null) {
+            return;
+        }
+        this.laneFlushing.medium = true;
+        try {
+            while (this.mediumQueue.length > 0) {
+                const batch = takeEntriesWithinBytes(this.mediumQueue, this.config.medium.maxBytes);
+                if (batch.length === 0) {
+                    break;
+                }
+                const idempotencyKey = computeLogBatchIdempotencyKey({
+                    service: this.service,
+                    process: this.processName,
+                    lane: "medium",
+                    entries: batch,
+                });
+                const batchBytes = estimateEntriesBytes(batch);
+                try {
+                    persistLogger.debug("medium flush posting batch", {
+                        idempotencyKey,
+                        batchSize: batch.length,
+                        batchBytes,
+                        queueRemaining: this.mediumQueue.length,
+                    });
+                    const draft = buildLogListDraft({
+                        service: this.service,
+                        process: this.processName,
+                        lane: "medium",
+                        idempotencyKey,
+                        entries: batch,
+                    });
+                    await postLogBatch(draft, this.config.postTimeoutMs);
+                    this.mediumQueue.splice(0, batch.length);
+                    this.lastFlushAt.medium = new Date().toISOString();
+                    this.recordLaneSuccess("medium");
+                    persistLogger.info("medium lane flushed", {
+                        idempotencyKey,
+                        batchSize: batch.length,
+                        batchBytes,
+                        queueRemaining: this.mediumQueue.length,
+                    });
+                }
+                catch (error) {
+                    this.recordLaneError("medium", error);
+                    persistLogger.error("medium flush failed — entries retained", {
+                        idempotencyKey,
+                        batchSize: batch.length,
+                        batchBytes,
+                        error: this.lastError,
+                        queueRemaining: this.mediumQueue.length,
+                    });
+                    this.scheduleMediumFlush();
+                    break;
+                }
+            }
+        }
+        finally {
+            this.laneFlushing.medium = false;
+        }
+        if (this.mediumQueue.length > 0 && !this.laneFlushing.medium) {
+            this.scheduleMediumFlush();
+        }
+    }
+    async flushSlow() {
+        if (this.laneFlushing.slow) {
+            persistLogger.debug("slow flush skipped — already flushing");
+            return;
+        }
+        if (this.slowQueue.length === 0) {
+            return;
+        }
+        if (this.service == null || this.processName == null) {
+            return;
+        }
+        this.laneFlushing.slow = true;
+        try {
+            while (this.slowQueue.length > 0) {
+                const batch = takeEntriesWithinBytes(this.slowQueue, this.config.slow.maxBytes);
+                if (batch.length === 0) {
+                    break;
+                }
+                const idempotencyKey = computeLogBatchIdempotencyKey({
+                    service: this.service,
+                    process: this.processName,
+                    lane: "slow",
+                    entries: batch,
+                });
+                const batchBytes = estimateEntriesBytes(batch);
+                try {
+                    persistLogger.debug("slow flush posting batch", {
+                        idempotencyKey,
+                        batchSize: batch.length,
+                        batchBytes,
+                        queueRemaining: this.slowQueue.length,
+                    });
+                    const draft = buildLogListDraft({
+                        service: this.service,
+                        process: this.processName,
+                        lane: "slow",
+                        idempotencyKey,
+                        entries: batch,
+                    });
+                    await postLogBatch(draft, this.config.postTimeoutMs);
+                    this.slowQueue.splice(0, batch.length);
+                    this.lastFlushAt.slow = new Date().toISOString();
+                    this.recordLaneSuccess("slow");
+                    persistLogger.info("slow lane flushed", {
+                        idempotencyKey,
+                        batchSize: batch.length,
+                        batchBytes,
+                        queueRemaining: this.slowQueue.length,
+                    });
+                }
+                catch (error) {
+                    this.recordLaneError("slow", error);
+                    persistLogger.error("slow flush failed — entries retained", {
+                        idempotencyKey,
+                        batchSize: batch.length,
+                        batchBytes,
+                        error: this.lastError,
+                        queueRemaining: this.slowQueue.length,
+                    });
+                    this.scheduleSlowFlush();
+                    break;
+                }
+            }
+            if (this.slowQueue.length === 0) {
+                this.slowQueueStartedAt = null;
+            }
+        }
+        finally {
+            this.laneFlushing.slow = false;
+        }
+        if (this.slowQueue.length > 0 && !this.laneFlushing.slow) {
+            this.scheduleSlowFlush();
+        }
+    }
+}
+
+function resolveRegistryFilePath(explicit) {
+    const dir = logPersistRegistryDirFromEnv();
+    if (dir == null) {
+        throw new Error("[LogPersist] registry path required: set registryFilePath option or LOG_PERSIST_REGISTRY_DIR / RUNTIME_DATA_DIR");
+    }
+    return defaultLogPersistRegistryPath(resolve(dir));
+}
+async function enableLogPersist(options) {
+    const registryFilePath = options.registryFilePath != null ? resolve(options.registryFilePath) : undefined;
+    const resolvedRegistry = registryFilePath ?? resolveRegistryFilePath();
+    const envConfig = logPersistConfigFromEnv();
+    await LogPersist.getInstance().enable({
+        ...options,
+        registryFilePath: resolvedRegistry,
+        config: resolveLogPersistConfig({
+            fast: { ...envConfig.fast, ...options.config?.fast },
+            medium: { ...envConfig.medium, ...options.config?.medium },
+            slow: { ...envConfig.slow, ...options.config?.slow },
+            postTimeoutMs: options.config?.postTimeoutMs ?? envConfig.postTimeoutMs,
+            shutdownDrainTimeoutMs: options.config?.shutdownDrainTimeoutMs ?? envConfig.shutdownDrainTimeoutMs,
+        }),
+    });
+}
+async function disableLogPersist() {
+    await LogPersist.getInstance().disable();
+}
+function getLogPersistStats() {
+    return LogPersist.getInstance().getStats();
+}
+/**
+ * Enable log persistence when LOG_PERSIST_ENABLED=true.
+ * `process` / `service` can be passed explicitly or via LOG_PERSIST_PROCESS / LOG_PERSIST_SERVICE.
+ */
+async function ensureLogPersistFromEnv(options = {}) {
+    if (!logPersistEnabledFromEnv()) {
+        registerLogPersistOffer(null);
+        return false;
+    }
+    const service = options.service ?? logPersistServiceFromEnv();
+    const processName = options.process ?? logPersistProcessFromEnv();
+    if (service == null || service === "") {
+        throw new Error("[LogPersist] LOG_PERSIST_SERVICE is required when LOG_PERSIST_ENABLED=true");
+    }
+    if (processName == null || processName === "") {
+        throw new Error("[LogPersist] LOG_PERSIST_PROCESS is required when LOG_PERSIST_ENABLED=true (or pass process option)");
+    }
+    const registryFilePath = options.registryFilePath != null ? resolve(options.registryFilePath) : resolveRegistryFilePath();
+    await enableLogPersist({
+        service,
+        process: processName,
+        registryFilePath,
+        config: options.config,
+    });
+    const lifecycleLogger = createLogger({ module: "log-persist" });
+    lifecycleLogger.info("log persist enabled from env", {
+        topic: LOG_PERSIST_TOPIC,
+        data: { service, process: processName, registryFilePath },
+    });
+    return true;
+}
+/**
+ * Preload guard: when persistence is enabled, required env must be present before app code runs.
+ */
+function validateLogPersistPreloadEnv(env = process.env) {
+    if (!envBool("LOG_PERSIST_ENABLED", false, env)) {
+        return;
+    }
+    const missing = [];
+    if (readEnv("LOG_PERSIST_SERVICE", env) == null) {
+        missing.push("LOG_PERSIST_SERVICE");
+    }
+    const registryDir = logPersistRegistryDirFromEnv(env);
+    if (registryDir == null) {
+        missing.push("LOG_PERSIST_REGISTRY_DIR or RUNTIME_DATA_DIR");
+    }
+    if (missing.length > 0) {
+        throw new Error(`[LogPersist] preload env incomplete: ${missing.join(", ")}`);
+    }
+}
+function evaluateLogPersistReady(state, expectedProcesses, staleMs, now) {
+    const missing = [];
+    const stale = [];
+    const registered = [];
+    for (const processName of expectedProcesses) {
+        const record = state.processes[processName];
+        if (record == null) {
+            missing.push(processName);
+            continue;
+        }
+        const heartbeatAt = Date.parse(record.lastHeartbeatAt);
+        if (!Number.isFinite(heartbeatAt) || now - heartbeatAt > staleMs) {
+            stale.push(processName);
+            continue;
+        }
+        registered.push(processName);
+    }
+    return {
+        ok: missing.length === 0 && stale.length === 0,
+        missing,
+        stale,
+        registered,
+    };
+}
+/**
+ * Wait until every expected process has registered in the shared registry with a fresh heartbeat.
+ * Call from the service main process after spawning children.
+ */
+async function waitForLogPersistReady(options) {
+    const timeoutMs = options.timeoutMs ?? 60_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 500;
+    const staleMs = options.staleMs ?? 90_000;
+    let last = {
+        ok: false,
+        missing: [...options.expectedProcesses],
+        stale: [],
+        registered: [],
+    };
+    try {
+        await pollUntil({
+            intervalMs: pollIntervalMs,
+            timeoutMs,
+            until: async () => {
+                const state = await readLogPersistRegistry(options.registryFilePath);
+                if (state.service !== options.service) {
+                    last = {
+                        ok: false,
+                        missing: options.expectedProcesses,
+                        stale: [],
+                        registered: [],
+                    };
+                    return false;
+                }
+                last = evaluateLogPersistReady(state, options.expectedProcesses, staleMs, Date.now());
+                return last.ok;
+            },
+        });
+    }
+    catch {
+        persistLogger.warn("waitForLogPersistReady timed out", {
+            timeoutMs,
+            expectedProcesses: options.expectedProcesses,
+            ...last,
+        });
+    }
+    return last;
+}
+async function snapshotLogPersistReady(options) {
+    const state = await readLogPersistRegistry(options.registryFilePath);
+    return evaluateLogPersistReady(state, options.expectedProcesses, options.staleMs ?? 90_000, Date.now());
+}
+function resolveLogPersistRegistryPath(registryDir) {
+    const dir = registryDir ?? logPersistRegistryDirFromEnv();
+    if (dir == null) {
+        requireEnv("LOG_PERSIST_REGISTRY_DIR");
+    }
+    return defaultLogPersistRegistryPath(resolve(dir ?? ""));
+}
+
+export { logPersistEnabledFromEnv as a, readEnv as b, requireEnv as c, createJsonFileStateStore as d, disableLogPersist as e, enableLogPersist as f, ensureLogPersistFromEnv as g, envBool as h, envInt as i, envMs as j, envNumber as k, loadEnvFiles as l, envPort as m, getLogPersistStats as n, parseEnvLine as o, parseEnvFile as p, pollUntil as q, resolveProjectRootByPackageName as r, resolveLogPersistRegistryPath as s, resolveProjectRootFromModule as t, snapshotLogPersistReady as u, validateLogPersistPreloadEnv as v, waitForLogPersistReady as w };
+//# sourceMappingURL=enable-log-persist-BH-tbKEj.js.map