target-supabase-sdk 0.2.12 → 0.2.14

package/dist/chunks/enable-log-persist-Dl55_mv2.js

@@ -1,1674 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve, dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { readFile, unlink, mkdir, writeFile, rename, readdir } from 'node:fs/promises';
-import { g as createLogger, c as LOG_PERSIST_LOADER_KEY, a as CategoryList, D as postLogListCreate, q as isCreateTargetAlreadyExistsError, d as LogLevel, W as registerLogPersistOffer } from './list.api-BzbTJBsM.js';
-import 'lodash-es';
-import { randomBytes, 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"];
-const PROD_ENV_FILES = [".env.prod"];
-const SERVICE_ENV_PROFILE_ENV_KEY = "SERVICE_ENV_PROFILE";
-const SERVICE_ENV_PROFILE_PROD = "prod";
-const CLI_PROD_FLAG = "--prod";
-/** Resolve active env profile from `SERVICE_ENV_PROFILE` or `--prod` on argv. */
-function envProfileFromProcess(options) {
-    const env = options?.env ?? process.env;
-    const argv = options?.argv ?? process.argv;
-    const fromEnv = env[SERVICE_ENV_PROFILE_ENV_KEY]?.trim();
-    if (fromEnv != null && fromEnv !== "") {
-        return fromEnv;
-    }
-    if (argv.includes(CLI_PROD_FLAG)) {
-        return SERVICE_ENV_PROFILE_PROD;
-    }
-    return undefined;
-}
-/** Default env file list for a profile (`prod` → `.env.prod`; otherwise `.env.local` → `.env`). */
-function resolveDefaultEnvFiles(profile) {
-    if (profile === SERVICE_ENV_PROFILE_PROD) {
-        return PROD_ENV_FILES;
-    }
-    return DEFAULT_ENV_FILES;
-}
-/** Pin `SERVICE_ENV_PROFILE=prod` when `--prod` is on argv (for child process inheritance). */
-function pinEnvProfileFromArgv(env = process.env, argv = process.argv) {
-    if (env[SERVICE_ENV_PROFILE_ENV_KEY]?.trim()) {
-        return;
-    }
-    if (argv.includes(CLI_PROD_FLAG)) {
-        env[SERVICE_ENV_PROFILE_ENV_KEY] = SERVICE_ENV_PROFILE_PROD;
-    }
-}
-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 files into `process.env` (or `options.env`).
- * Default files: `.env.local` → `.env`, or `.env.prod` when profile is `prod` / `--prod`.
- * Existing non-empty env values are not overwritten.
- */
-function loadEnvFiles(root, options) {
-    const env = options?.env ?? process.env;
-    const files = options?.files ?? resolveDefaultEnvFiles(envProfileFromProcess({ env }));
-    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}`);
-}
-
-/** Per-file write queue — serializes read-modify-write for a single JSON path within one process. */
-const writeChains = new Map();
-function withSerializedFileWrites(filePath, operation) {
-    const previous = writeChains.get(filePath) ?? Promise.resolve();
-    const next = previous.then(operation, operation);
-    writeChains.set(filePath, next.then(() => undefined, () => undefined));
-    return next;
-}
-
-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`;
-    JSON.parse(content);
-    const tempPath = `${filePath}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-    try {
-        await writeFile(tempPath, content, "utf8");
-        await rename(tempPath, filePath);
-    }
-    catch (error) {
-        await unlink(tempPath).catch(() => undefined);
-        throw error;
-    }
-}
-/** 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(),
-        };
-    }
-    async function readFromDisk() {
-        try {
-            const raw = await readFile(filePath, "utf8");
-            const parsed = JSON.parse(raw);
-            return mergeWithNested(defaultState, parsed, {}, nestedKeys);
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return mergeWithNested(defaultState, {}, {}, nestedKeys);
-            }
-            if (error instanceof SyntaxError) {
-                await unlink(filePath).catch(() => undefined);
-                return mergeWithNested(defaultState, {}, {}, nestedKeys);
-            }
-            throw error;
-        }
-    }
-    return {
-        read() {
-            return readFromDisk();
-        },
-        write(patch) {
-            return withSerializedFileWrites(filePath, async () => {
-                const current = await readFromDisk();
-                const next = touchUpdatedAt(mergeWithNested(defaultState, current, patch, nestedKeys));
-                await atomicWriteJson(filePath, next);
-                return next;
-            });
-        },
-        reset() {
-            return withSerializedFileWrites(filePath, async () => {
-                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 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,
-    laneRetryIntervalMs: 5_000,
-    errorLogRateLimitMs: 5_000,
-    circuitBreakerPermanentFailureThreshold: 3,
-};
-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,
-        laneRetryIntervalMs: partial?.laneRetryIntervalMs ?? defaults.laneRetryIntervalMs,
-        errorLogRateLimitMs: partial?.errorLogRateLimitMs ?? defaults.errorLogRateLimitMs,
-        circuitBreakerPermanentFailureThreshold: partial?.circuitBreakerPermanentFailureThreshold ?? defaults.circuitBreakerPermanentFailureThreshold,
-    };
-}
-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 }),
-        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 }),
-    });
-}
-
-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)}`;
-}
-
-const PERMANENT_LOG_PERSIST_ERROR_PATTERNS = [
-    /not initialized/i,
-    /call initialize\(\) first/i,
-    /missing required supabase environment/i,
-    /preload env incomplete/i,
-];
-function formatLogPersistError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-/** Errors that will not succeed on retry without fixing process configuration. */
-function isPermanentLogPersistError(error) {
-    const message = formatLogPersistError(error);
-    return PERMANENT_LOG_PERSIST_ERROR_PATTERNS.some((pattern) => pattern.test(message));
-}
-
-/** 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" });
-let errorLogRateLimitMs = 5_000;
-const lastLoggedAt = new Map();
-function configurePersistLoggerRateLimit(ms) {
-    errorLogRateLimitMs = Math.max(0, ms);
-}
-function isLogPersistInternalTopic(topic) {
-    return topic === LOG_PERSIST_INTERNAL_TOPIC;
-}
-function shouldEmit(level, message) {
-    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, message, data) {
-    if (!shouldEmit(level, message)) {
-        return;
-    }
-    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: {
-                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 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;
-    mediumRetryTimer = null;
-    slowRetryTimer = null;
-    heartbeatTimer = null;
-    lastHeartbeatAt = 0;
-    permanentFailureCount = 0;
-    circuitBreakerTripped = false;
-    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);
-        configurePersistLoggerRateLimit(this.config.errorLogRateLimitMs);
-        this.draining = false;
-        this.shutdownPromise = null;
-        this.consecutiveFailures = { fast: 0, medium: 0, slow: 0 };
-        this.permanentFailureCount = 0;
-        this.circuitBreakerTripped = false;
-        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.cancelLaneRetryTimers();
-        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,
-            circuitBreakerTripped: this.circuitBreakerTripped,
-            permanentFailureCount: this.permanentFailureCount,
-            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;
-        this.permanentFailureCount = 0;
-    }
-    handleLaneFlushFailure(lane, error, scheduleRetry, logMessage, context) {
-        this.recordLaneError(lane, error);
-        const message = this.lastError ?? formatLogPersistError(error);
-        if (isPermanentLogPersistError(error)) {
-            this.permanentFailureCount += 1;
-            if (this.permanentFailureCount >= this.config.circuitBreakerPermanentFailureThreshold) {
-                this.tripCircuitBreaker(message);
-                return;
-            }
-        }
-        persistLogger.error(logMessage, {
-            ...context,
-            error: message,
-            retryInMs: this.config.laneRetryIntervalMs,
-            permanentFailureCount: this.permanentFailureCount,
-        });
-        scheduleRetry();
-    }
-    tripCircuitBreaker(reason) {
-        if (this.circuitBreakerTripped) {
-            return;
-        }
-        this.circuitBreakerTripped = true;
-        this.cancelMediumDebounce();
-        this.cancelLaneRetryTimers();
-        this.stopHeartbeat();
-        const dropped = this.queueSnapshot();
-        this.fastQueue = [];
-        this.fastRetryQueue = [];
-        this.mediumQueue = [];
-        this.slowQueue = [];
-        this.slowQueueStartedAt = null;
-        this.enabled = false;
-        registerLogPersistOffer(null);
-        persistLogger.error("circuit breaker tripped — log persist disabled", {
-            reason,
-            permanentFailureCount: this.permanentFailureCount,
-            threshold: this.config.circuitBreakerPermanentFailureThreshold,
-            dropped,
-        });
-    }
-    cancelLaneRetryTimers() {
-        if (this.fastRetryTimer != null) {
-            clearTimeout(this.fastRetryTimer);
-            this.fastRetryTimer = null;
-        }
-        if (this.mediumRetryTimer != null) {
-            clearTimeout(this.mediumRetryTimer);
-            this.mediumRetryTimer = null;
-        }
-        if (this.slowRetryTimer != null) {
-            clearTimeout(this.slowRetryTimer);
-            this.slowRetryTimer = null;
-        }
-    }
-    scheduleLaneRetry(lane, flush) {
-        const retryMs = this.config.laneRetryIntervalMs;
-        const existing = lane === "fast" ? this.fastRetryTimer : lane === "medium" ? this.mediumRetryTimer : this.slowRetryTimer;
-        if (existing != null) {
-            return;
-        }
-        persistLogger.warn(`${lane} flush retry scheduled`, { retryInMs: retryMs });
-        const timer = setTimeout(() => {
-            if (lane === "fast") {
-                this.fastRetryTimer = null;
-            }
-            else if (lane === "medium") {
-                this.mediumRetryTimer = null;
-            }
-            else {
-                this.slowRetryTimer = null;
-            }
-            persistLogger.debug(`${lane} flush retry timer fired`);
-            flush();
-        }, retryMs);
-        timer.unref?.();
-        if (lane === "fast") {
-            this.fastRetryTimer = timer;
-        }
-        else if (lane === "medium") {
-            this.mediumRetryTimer = timer;
-        }
-        else {
-            this.slowRetryTimer = timer;
-        }
-    }
-    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() {
-        if (this.mediumRetryTimer != null) {
-            return;
-        }
-        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() {
-        if (this.slowRetryTimer != null) {
-            return;
-        }
-        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.fastRetryQueue.push(entry);
-                    this.handleLaneFlushFailure("fast", error, () => this.scheduleLaneRetry("fast", () => void this.flushFast()), "fast flush failed — queued for retry", {
-                        idempotencyKey,
-                        fastRetryQueue: this.fastRetryQueue.length,
-                    });
-                    break;
-                }
-            }
-        }
-        finally {
-            this.laneFlushing.fast = false;
-        }
-    }
-    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.handleLaneFlushFailure("medium", error, () => this.scheduleLaneRetry("medium", () => void this.flushMedium()), "medium flush failed — entries retained", {
-                        idempotencyKey,
-                        batchSize: batch.length,
-                        batchBytes,
-                        queueRemaining: this.mediumQueue.length,
-                    });
-                    break;
-                }
-            }
-        }
-        finally {
-            this.laneFlushing.medium = false;
-        }
-        if (this.mediumQueue.length > 0 && !this.laneFlushing.medium && this.mediumRetryTimer == null) {
-            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.handleLaneFlushFailure("slow", error, () => this.scheduleLaneRetry("slow", () => void this.flushSlow()), "slow flush failed — entries retained", {
-                        idempotencyKey,
-                        batchSize: batch.length,
-                        batchBytes,
-                        queueRemaining: this.slowQueue.length,
-                    });
-                    break;
-                }
-            }
-            if (this.slowQueue.length === 0) {
-                this.slowQueueStartedAt = null;
-            }
-        }
-        finally {
-            this.laneFlushing.slow = false;
-        }
-        if (this.slowQueue.length > 0 && !this.laneFlushing.slow && this.slowRetryTimer == null) {
-            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 { resolveProjectRootFromModule as A, CLI_PROD_FLAG as C, SERVICE_ENV_PROFILE_ENV_KEY as S, logPersistEnabledFromEnv as a, readEnv as b, requireEnv as c, createJsonFileStateStore as d, disableLogPersist as e, ensureLogPersistFromEnv as f, getLogPersistStats as g, SERVICE_ENV_PROFILE_PROD as h, enableLogPersist as i, envBool as j, envInt as k, loadEnvFiles as l, envMs as m, envNumber as n, envPort as o, pinEnvProfileFromArgv as p, envProfileFromProcess as q, resolveProjectRootByPackageName as r, snapshotLogPersistReady as s, parseEnvFile as t, parseEnvLine as u, validateLogPersistPreloadEnv as v, waitForLogPersistReady as w, pollUntil as x, resolveDefaultEnvFiles as y, resolveLogPersistRegistryPath as z };
-//# sourceMappingURL=enable-log-persist-Dl55_mv2.js.map