/**
 * The oldest Node a seat entry runs on. `enableCompileCache()` arrived in v22.8.0 and
 * `flushCompileCache()` in v22.10.0, and the entry calls both, so v22.10.0 is the first Node that
 * has all of it. The published `engines.node` says the same thing.
 */
export declare const SEAT_NODE_FLOOR = "22.10.0";
/**
 * Where the seat keeps its compile cache: `compile-cache` under this OS user's own Cotal
 * directory, so it persists across restarts and upgrades and is never in a temp directory that a
 * reboot clears. Node keys a subdirectory inside it, so a Node upgrade pays one compile instead of
 * reading a stale entry.
 *
 * This repeats `userCotalDir()` from `@cotal-ai/workspace` because a connector peer-depends on
 * `@cotal-ai/core` alone and cannot import the workspace layer. `pnpm smoke:seat-compile-cache`
 * asserts the two agree, so they cannot drift apart.
 */
export declare function seatCompileCacheDir(): string;
/**
 * Refuse a runtime that cannot cache a seat's compile, before anything calls into the cache.
 *
 * Serving anyway without a cache is a silent downgrade of the one thing this entry exists for, so
 * an old runtime is refused rather than degraded. The version is checked first and the two
 * functions after it, so a runtime that reports the version without shipping the API gets this
 * sentence instead of a `TypeError` from the next line. `label` prefixes the line, matching the
 * seat's other stderr lines.
 */
export declare function assertSeatRuntime(label: string): void;
/**
 * Enable the compile cache for everything this process loads after the call.
 *
 * The directory is created the way the rest of `~/.cotal` is created, 0700 and owner-only, because
 * `enableCompileCache()` would otherwise create it at whatever the process umask allows and a
 * seat's compiled bundle belongs to one user. Node still creates its own version-keyed directory
 * inside it at the umask, and the 0700 above that is what keeps another user out.
 *
 * Neither step is allowed to end a seat. `enableCompileCache()` does not throw, it returns a
 * status, so a cache this process cannot open prints one line with the real reason and the seat
 * runs on without a cache. `label` prefixes that line.
 */
export declare function enableSeatCompileCache(label: string): void;
/**
 * Write the code cache this process has accumulated to disk now.
 *
 * Node flushes the cache when the instance is about to exit, and a seat is normally ended by a
 * signal, which runs no exit handler. Without this call the first seat on a new bundle would
 * compile it, die to a signal, and leave the next seat nothing to read. Node documents this call
 * for that case. It reports no errors by design: a cache write that fails must not disturb the
 * seat.
 */
export declare function flushSeatCompileCache(): void;
//# sourceMappingURL=seat-compile-cache.d.ts.map