target-supabase-sdk 0.2.12 → 0.2.13

package/dist/chunks/enable-DqnfLPsQ.js

@@ -0,0 +1,874 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { g as createLogger, c as LOG_PERSIST_LOADER_KEY, a as CategoryList, D as postLogListCreate, q as isCreateTargetAlreadyExistsError, W as registerLogPersistOffer } from './list.api-BzbTJBsM.js';
+import { mkdir, writeFile, rename } from 'node:fs/promises';
+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"];
+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}`);
+}
+
+/** Master switch — env name kept for compatibility (`LOG_PERSIST_ENABLED`). */
+function logSpoolEnabledFromEnv(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;
+}
+/** `LOG_PERSIST_REGISTRY_DIR` or `RUNTIME_DATA_DIR`. */
+function runtimeDataDirFromEnv(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;
+}
+
+/** 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";
+function createPipelineLogger(module) {
+    const logger = createLogger({ module });
+    function write(level, message, data) {
+        logger[level](message, {
+            topic: LOG_PERSIST_INTERNAL_TOPIC,
+            ...(data != null ? { data } : {}),
+        });
+    }
+    return {
+        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),
+    };
+}
+/** Supabase upload path (`postLogBatch`). */
+const persistLogger = createPipelineLogger("log-upload");
+/** File spool writer + collector. */
+const spoolLogger = createPipelineLogger("log-spool");
+function isLogPersistInternalTopic(topic) {
+    return topic === LOG_PERSIST_INTERNAL_TOPIC;
+}
+
+const LOG_SPOOL_SERVICE_ID_ENV = "LOG_SPOOL_SERVICE_ID";
+const DEFAULT_LOG_SPOOL_CONFIG = {
+    writer: {
+        maxEntries: 2000,
+        maxBytes: 2 * 1024 * 1024,
+        flushDebounceMs: 3_000,
+        maxAgeMs: 60_000,
+        postTimeoutMs: 30_000,
+    },
+    gc: {
+        intervalMs: 24 * 60 * 60 * 1000,
+        syncedRetentionMs: 7 * 24 * 60 * 60 * 1000,
+        tmpRetentionMs: 7 * 24 * 60 * 60 * 1000,
+    },
+    collectIntervalMs: 60_000,
+};
+function resolveLogSpoolConfig(partial) {
+    const defaults = DEFAULT_LOG_SPOOL_CONFIG;
+    return {
+        writer: { ...defaults.writer, ...partial?.writer },
+        gc: { ...defaults.gc, ...partial?.gc },
+        collectIntervalMs: partial?.collectIntervalMs ?? defaults.collectIntervalMs,
+    };
+}
+function logSpoolConfigFromEnv(env = process.env) {
+    return resolveLogSpoolConfig({
+        writer: {
+            maxEntries: envInt("LOG_SPOOL_MAX_ENTRIES", DEFAULT_LOG_SPOOL_CONFIG.writer.maxEntries, { env, min: 1 }),
+            maxBytes: envInt("LOG_SPOOL_MAX_BYTES", DEFAULT_LOG_SPOOL_CONFIG.writer.maxBytes, { env, min: 1 }),
+            flushDebounceMs: envMs("LOG_SPOOL_FLUSH_DEBOUNCE_MS", DEFAULT_LOG_SPOOL_CONFIG.writer.flushDebounceMs, {
+                env,
+            }),
+            maxAgeMs: envMs("LOG_SPOOL_MAX_AGE_MS", DEFAULT_LOG_SPOOL_CONFIG.writer.maxAgeMs, { env }),
+            postTimeoutMs: envMs("LOG_PERSIST_POST_TIMEOUT_MS", DEFAULT_LOG_SPOOL_CONFIG.writer.postTimeoutMs, { env }),
+        },
+        gc: {
+            intervalMs: envMs("LOG_SPOOL_GC_INTERVAL_MS", DEFAULT_LOG_SPOOL_CONFIG.gc.intervalMs, { env }),
+            syncedRetentionMs: envMs("LOG_SPOOL_SYNCED_RETENTION_MS", DEFAULT_LOG_SPOOL_CONFIG.gc.syncedRetentionMs, {
+                env,
+            }),
+            tmpRetentionMs: envMs("LOG_SPOOL_TMP_RETENTION_MS", DEFAULT_LOG_SPOOL_CONFIG.gc.tmpRetentionMs, { env }),
+        },
+        collectIntervalMs: envMs("LOG_SPOOL_COLLECT_INTERVAL_MS", DEFAULT_LOG_SPOOL_CONFIG.collectIntervalMs, { env }),
+    });
+}
+function logSpoolServiceIdFromEnv(env = process.env) {
+    const raw = env[LOG_SPOOL_SERVICE_ID_ENV]?.trim();
+    return raw != null && raw !== "" ? raw : undefined;
+}
+
+const LOG_SPOOL_DIR_NAME = "log-spool";
+function resolveLogSpoolRoot(explicit) {
+    if (explicit != null && explicit.trim() !== "") {
+        return explicit;
+    }
+    const configured = process.env.LOG_SPOOL_DIR?.trim();
+    if (configured != null && configured !== "") {
+        return configured;
+    }
+    const runtimeDir = runtimeDataDirFromEnv();
+    if (runtimeDir == null) {
+        throw new Error("[LogSpool] spool root required: set LOG_SPOOL_DIR or LOG_PERSIST_REGISTRY_DIR / RUNTIME_DATA_DIR");
+    }
+    return join(runtimeDir, LOG_SPOOL_DIR_NAME);
+}
+function logSpoolProcessDir(spoolRoot, serviceId, processRole) {
+    return join(spoolRoot, serviceId, processRole);
+}
+
+/** Four-process L3 blueprint roles — always scanned by collect-log. */
+const LOG_SPOOL_CORE_PROCESS_ROLES = ["main", "guard", "scheduler", "worker"];
+const LOG_SPOOL_EXTRA_PROCESS_ROLES_ENV = "LOG_SPOOL_EXTRA_PROCESS_ROLES";
+const EXTRA_ROLE_PATTERN = /^[a-z][a-z0-9-]*$/;
+function parseRoleList(raw) {
+    if (raw == null || raw.trim() === "") {
+        return [];
+    }
+    return raw
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part !== "");
+}
+/** Parse comma-separated extra roles from env (e.g. `chrome-sidecar`). */
+function logSpoolExtraProcessRolesFromEnv(env = process.env) {
+    return parseRoleList(env[LOG_SPOOL_EXTRA_PROCESS_ROLES_ENV]);
+}
+/** Core + extras, deduped, stable order (core first). */
+function resolveAllLogSpoolProcessRoles(env = process.env) {
+    const extras = logSpoolExtraProcessRolesFromEnv(env);
+    const seen = new Set(LOG_SPOOL_CORE_PROCESS_ROLES);
+    const all = [...LOG_SPOOL_CORE_PROCESS_ROLES];
+    for (const role of extras) {
+        if (!seen.has(role)) {
+            seen.add(role);
+            all.push(role);
+        }
+    }
+    return all;
+}
+function isLogSpoolCoreProcessRole(value) {
+    return LOG_SPOOL_CORE_PROCESS_ROLES.includes(value);
+}
+/** Whether `value` is a known spool role (core or configured extra). */
+function isKnownLogSpoolProcessRole(value, env = process.env) {
+    if (isLogSpoolCoreProcessRole(value)) {
+        return true;
+    }
+    return logSpoolExtraProcessRolesFromEnv(env).includes(value);
+}
+/** Validate extra role token — lowercase alphanumeric + hyphen, not a duplicate core name. */
+function assertValidLogSpoolExtraProcessRole(role) {
+    if (role === "" || !EXTRA_ROLE_PATTERN.test(role)) {
+        throw new Error(`[LogSpool] invalid extra process role "${role}" — use lowercase letters, digits, hyphen (e.g. chrome-sidecar)`);
+    }
+    if (isLogSpoolCoreProcessRole(role)) {
+        throw new Error(`[LogSpool] extra process role "${role}" duplicates a core role`);
+    }
+}
+function mergeLogSpoolExtraProcessRolesEnv(env, extraRoles) {
+    if (extraRoles.length === 0) {
+        return;
+    }
+    for (const role of extraRoles) {
+        assertValidLogSpoolExtraProcessRole(role);
+    }
+    const merged = new Set([...logSpoolExtraProcessRolesFromEnv(env), ...extraRoles]);
+    env[LOG_SPOOL_EXTRA_PROCESS_ROLES_ENV] = [...merged].join(",");
+}
+
+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;
+    // TODO: `lane` is legacy transport metadata — scheduled for removal; callers still pass a fixed value for decode compatibility.
+    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 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)}`;
+}
+
+/** `role.timestamp.hash.tmp|json` — role is lowercase alphanumeric + hyphen. */
+const BATCH_FILE_PATTERN = /^([a-z][a-z0-9-]*)\.(\d{14})\.([a-f0-9]{8})\.(tmp|json)$/;
+function formatLogSpoolBatchTimestamp(ms) {
+    const d = new Date(ms);
+    const pad = (n) => String(n).padStart(2, "0");
+    return (`${d.getFullYear()}` +
+        `${pad(d.getMonth() + 1)}` +
+        `${pad(d.getDate())}` +
+        `${pad(d.getHours())}` +
+        `${pad(d.getMinutes())}` +
+        `${pad(d.getSeconds())}`);
+}
+function computeLogSpoolShortHash(input) {
+    const processKey = `${input.serviceId}:${input.processRole}`;
+    const idempotencyKey = computeLogBatchIdempotencyKey({
+        service: input.serviceValue,
+        process: processKey,
+        lane: "slow",
+        entries: input.entries,
+    });
+    return idempotencyKey.slice(0, 8);
+}
+function buildLogSpoolBatchBaseName(input) {
+    const ts = formatLogSpoolBatchTimestamp(input.firstEntryTimestamp);
+    return `${input.processRole}.${ts}.${input.shortHash}`;
+}
+function parseLogSpoolBatchFilename(filename) {
+    const match = BATCH_FILE_PATTERN.exec(filename);
+    if (match == null) {
+        return null;
+    }
+    const processRole = match[1];
+    const tsRaw = match[2];
+    const shortHash = match[3];
+    const extension = match[4];
+    const year = Number(tsRaw.slice(0, 4));
+    const month = Number(tsRaw.slice(4, 6));
+    const day = Number(tsRaw.slice(6, 8));
+    const hour = Number(tsRaw.slice(8, 10));
+    const minute = Number(tsRaw.slice(10, 12));
+    const second = Number(tsRaw.slice(12, 14));
+    const timestampMs = Date.UTC(year, month - 1, day, hour, minute, second);
+    if (!Number.isFinite(timestampMs)) {
+        return null;
+    }
+    return { processRole, timestampMs, shortHash, extension };
+}
+
+class LogSpoolWriter {
+    static instance = null;
+    enabled = false;
+    buffer = [];
+    flushInProgress = false;
+    debounceTimer = null;
+    ageTimer = null;
+    serviceId = null;
+    processRole = null;
+    serviceValue = null;
+    spoolRoot = null;
+    config = DEFAULT_LOG_SPOOL_CONFIG.writer;
+    static getInstance() {
+        LogSpoolWriter.instance ??= new LogSpoolWriter();
+        return LogSpoolWriter.instance;
+    }
+    async enable(options) {
+        if (this.enabled) {
+            spoolLogger.warn("log spool writer already enabled", {
+                serviceId: this.serviceId,
+                processRole: this.processRole,
+            });
+            return;
+        }
+        this.serviceId = options.serviceId;
+        this.processRole = options.processRole;
+        this.serviceValue = options.serviceValue;
+        this.spoolRoot = options.spoolRoot ?? resolveLogSpoolRoot();
+        this.config = resolveLogSpoolConfig(options.config).writer;
+        this.enabled = true;
+        registerLogPersistOffer((entry) => this.offer(entry));
+        spoolLogger.info("log spool writer enabled", {
+            serviceId: options.serviceId,
+            processRole: options.processRole,
+            serviceValue: options.serviceValue,
+            spoolRoot: this.spoolRoot,
+            config: this.config,
+        });
+    }
+    async shutdown() {
+        this.cancelDebounce();
+        this.cancelAgeFlush();
+        registerLogPersistOffer(null);
+        this.enabled = false;
+        while (this.buffer.length > 0) {
+            await this.flushChunk({ reason: "shutdown" });
+        }
+        spoolLogger.info("log spool writer shutdown complete", {
+            serviceId: this.serviceId,
+            processRole: this.processRole,
+        });
+    }
+    getStats() {
+        return {
+            enabled: this.enabled,
+            bufferedEntries: this.buffer.length,
+            bufferedBytes: estimateEntriesBytes(this.buffer),
+            flushInProgress: this.flushInProgress,
+            debouncePending: this.debounceTimer != null,
+            ageFlushPending: this.ageTimer != null,
+            serviceId: this.serviceId,
+            processRole: this.processRole,
+        };
+    }
+    offer(entry) {
+        if (isLogPersistInternalTopic(entry.topic)) {
+            return;
+        }
+        if (!this.enabled) {
+            return;
+        }
+        if (this.buffer.length === 0) {
+            this.scheduleAgeFlush();
+        }
+        this.buffer.push(entry);
+        if (this.shouldScheduleDebouncedFlush()) {
+            this.scheduleDebouncedFlush();
+        }
+    }
+    shouldScheduleDebouncedFlush() {
+        return (this.buffer.length >= this.config.maxEntries || estimateEntriesBytes(this.buffer) >= this.config.maxBytes);
+    }
+    scheduleDebouncedFlush() {
+        if (this.debounceTimer != null) {
+            return;
+        }
+        spoolLogger.debug("log spool flush debounce scheduled", {
+            debounceMs: this.config.flushDebounceMs,
+            bufferedEntries: this.buffer.length,
+        });
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            void this.flushChunk({ reason: "debounce" });
+        }, this.config.flushDebounceMs);
+        this.debounceTimer.unref?.();
+    }
+    scheduleAgeFlush() {
+        if (this.ageTimer != null) {
+            return;
+        }
+        spoolLogger.debug("log spool age flush scheduled", {
+            maxAgeMs: this.config.maxAgeMs,
+        });
+        this.ageTimer = setTimeout(() => {
+            this.ageTimer = null;
+            void this.flushChunk({ reason: "maxAge" });
+        }, this.config.maxAgeMs);
+        this.ageTimer.unref?.();
+    }
+    cancelDebounce() {
+        if (this.debounceTimer != null) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+    }
+    cancelAgeFlush() {
+        if (this.ageTimer != null) {
+            clearTimeout(this.ageTimer);
+            this.ageTimer = null;
+        }
+    }
+    async flushChunk(input) {
+        if (this.flushInProgress || this.buffer.length === 0) {
+            return;
+        }
+        if (this.serviceId == null || this.processRole == null || this.serviceValue == null || this.spoolRoot == null) {
+            return;
+        }
+        this.cancelDebounce();
+        this.cancelAgeFlush();
+        this.flushInProgress = true;
+        try {
+            const byCount = this.buffer.slice(0, this.config.maxEntries);
+            const entries = takeEntriesWithinBytes(byCount, this.config.maxBytes);
+            this.buffer = this.buffer.slice(entries.length);
+            if (entries.length === 0) {
+                if (this.buffer.length > 0) {
+                    this.scheduleAgeFlush();
+                }
+                else {
+                    this.cancelAgeFlush();
+                }
+                return;
+            }
+            const batchFile = await this.writeBatchTmp({
+                entries,
+                serviceId: this.serviceId,
+                processRole: this.processRole,
+                serviceValue: this.serviceValue,
+                spoolRoot: this.spoolRoot,
+            });
+            spoolLogger.info("log spool flushed to tmp", {
+                reason: input.reason,
+                fileName: batchFile.fileName,
+                entryCount: entries.length,
+                remainingBuffered: this.buffer.length,
+            });
+            if (this.buffer.length > 0) {
+                this.scheduleAgeFlush();
+                if (this.shouldScheduleDebouncedFlush()) {
+                    this.scheduleDebouncedFlush();
+                }
+            }
+            else {
+                this.cancelAgeFlush();
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            spoolLogger.error("log spool flush failed", { reason: input.reason, error: message });
+            if (this.buffer.length > 0) {
+                this.scheduleAgeFlush();
+            }
+        }
+        finally {
+            this.flushInProgress = false;
+        }
+    }
+    async writeBatchTmp(input) {
+        const first = input.entries[0];
+        const shortHash = computeLogSpoolShortHash({
+            serviceValue: input.serviceValue,
+            serviceId: input.serviceId,
+            processRole: input.processRole,
+            entries: input.entries,
+        });
+        const baseName = buildLogSpoolBatchBaseName({
+            processRole: input.processRole,
+            firstEntryTimestamp: first.timestamp,
+            shortHash,
+        });
+        const fileName = `${baseName}.tmp`;
+        const processDir = logSpoolProcessDir(input.spoolRoot, input.serviceId, input.processRole);
+        await mkdir(processDir, { recursive: true });
+        const tmpPath = join(processDir, fileName);
+        const partPath = `${tmpPath}.part`;
+        const payload = {
+            entries: input.entries,
+            meta: {
+                serviceId: input.serviceId,
+                processRole: input.processRole,
+                serviceValue: input.serviceValue,
+            },
+        };
+        const content = `${JSON.stringify(payload)}\n`;
+        await writeFile(partPath, content, "utf8");
+        await rename(partPath, tmpPath);
+        return { fileName, tmpPath };
+    }
+}
+async function enableLogSpoolWriter(options) {
+    await LogSpoolWriter.getInstance().enable(options);
+}
+async function shutdownLogSpoolWriter() {
+    await LogSpoolWriter.getInstance().shutdown();
+}
+function getLogSpoolWriterStats() {
+    return LogSpoolWriter.getInstance().getStats();
+}
+
+function resolveLogSpoolProcessRole(explicit) {
+    const raw = explicit ?? logPersistProcessFromEnv();
+    if (raw == null || raw === "") {
+        throw new Error("[LogSpool] LOG_PERSIST_PROCESS is required when LOG_PERSIST_ENABLED=true");
+    }
+    if (!isKnownLogSpoolProcessRole(raw)) {
+        throw new Error(`[LogSpool] invalid LOG_PERSIST_PROCESS: ${raw} (not a core role and not listed in ${LOG_SPOOL_EXTRA_PROCESS_ROLES_ENV})`);
+    }
+    return raw;
+}
+/**
+ * Env vars for child spawn after main claims registry slot.
+ * Optional when using {@link ManagedChildProcesses.spawn} — auto-injected from parent env.
+ */
+function buildLogSpoolSpawnEnv(input) {
+    return {
+        [LOG_SPOOL_SERVICE_ID_ENV]: input.serviceId,
+        LOG_PERSIST_PROCESS: input.processRole,
+    };
+}
+/**
+ * When persistence is enabled and parent has `LOG_SPOOL_SERVICE_ID`, map spawn `label`
+ * to spool env when `label` is a known core or extra process role.
+ */
+function resolveLogSpoolSpawnEnvForLabel(label, env = process.env) {
+    if (!logSpoolEnabledFromEnv(env)) {
+        return {};
+    }
+    const serviceId = env[LOG_SPOOL_SERVICE_ID_ENV]?.trim();
+    if (serviceId == null || serviceId === "") {
+        return {};
+    }
+    if (!isKnownLogSpoolProcessRole(label, env)) {
+        return {};
+    }
+    return buildLogSpoolSpawnEnv({ serviceId, processRole: label });
+}
+async function ensureLogSpoolFromEnv(options = {}) {
+    if (!logSpoolEnabledFromEnv()) {
+        registerLogPersistOffer(null);
+        return false;
+    }
+    const serviceId = options.serviceId ?? logSpoolServiceIdFromEnv();
+    const serviceValue = options.serviceValue ?? logPersistServiceFromEnv();
+    const processRole = resolveLogSpoolProcessRole(options.processRole);
+    if (serviceId == null || serviceId === "") {
+        throw new Error("[LogSpool] LOG_SPOOL_SERVICE_ID is required when LOG_PERSIST_ENABLED=true (set after registry claim or pass serviceId)");
+    }
+    if (serviceValue == null || serviceValue === "") {
+        throw new Error("[LogSpool] LOG_PERSIST_SERVICE is required when LOG_PERSIST_ENABLED=true");
+    }
+    const spoolRoot = options.spoolRoot ?? resolveLogSpoolRoot();
+    await enableLogSpoolWriter({
+        serviceId,
+        processRole,
+        serviceValue,
+        spoolRoot,
+        config: options.config ?? logSpoolConfigFromEnv(),
+    });
+    const lifecycleLogger = createLogger({ module: "log-spool" });
+    lifecycleLogger.info("log spool enabled from env", {
+        topic: LOG_PERSIST_TOPIC,
+        data: { serviceId, processRole, serviceValue, spoolRoot },
+    });
+    return true;
+}
+async function shutdownLogSpoolFromEnv() {
+    await shutdownLogSpoolWriter();
+}
+function getLogSpoolStats() {
+    return getLogSpoolWriterStats();
+}
+function validateLogSpoolPreloadEnv(env = process.env) {
+    if (!logSpoolEnabledFromEnv(env)) {
+        return;
+    }
+    const missing = [];
+    if (env.LOG_PERSIST_SERVICE?.trim() == null || env.LOG_PERSIST_SERVICE.trim() === "") {
+        missing.push("LOG_PERSIST_SERVICE");
+    }
+    const runtimeDir = env.LOG_PERSIST_REGISTRY_DIR?.trim() || env.RUNTIME_DATA_DIR?.trim();
+    if (runtimeDir == null || runtimeDir === "") {
+        missing.push("LOG_PERSIST_REGISTRY_DIR or RUNTIME_DATA_DIR");
+    }
+    if (missing.length > 0) {
+        throw new Error(`[LogSpool] preload env incomplete: ${missing.join(", ")}`);
+    }
+    for (const role of env[LOG_SPOOL_EXTRA_PROCESS_ROLES_ENV]?.split(",") ?? []) {
+        const trimmed = role.trim();
+        if (trimmed === "") {
+            continue;
+        }
+        assertValidLogSpoolExtraProcessRole(trimmed);
+    }
+}
+
+export { envMs as A, envNumber as B, CLI_PROD_FLAG as C, envPort as D, envProfileFromProcess as E, parseEnvFile as F, parseEnvLine as G, resolveDefaultEnvFiles as H, resolveProjectRootFromModule as I, LOG_SPOOL_SERVICE_ID_ENV as L, SERVICE_ENV_PROFILE_ENV_KEY as S, logSpoolEnabledFromEnv as a, readEnv as b, requireEnv as c, resolveLogSpoolSpawnEnvForLabel as d, resolveLogSpoolConfig as e, resolveLogSpoolRoot as f, resolveAllLogSpoolProcessRoles as g, logSpoolProcessDir as h, parseLogSpoolBatchFilename as i, computeLogBatchIdempotencyKey as j, buildLogListDraft as k, loadEnvFiles as l, mergeLogSpoolExtraProcessRolesEnv as m, postLogBatch as n, logSpoolConfigFromEnv as o, pinEnvProfileFromArgv as p, ensureLogSpoolFromEnv as q, resolveProjectRootByPackageName as r, spoolLogger as s, shutdownLogSpoolFromEnv as t, getLogSpoolStats as u, validateLogSpoolPreloadEnv as v, SERVICE_ENV_PROFILE_PROD as w, buildLogSpoolSpawnEnv as x, envBool as y, envInt as z };
+//# sourceMappingURL=enable-DqnfLPsQ.js.map