@serve.zone/pallet-bundle 35.3.0

package/dist_ts_bundle/classes.controlprocess.d.ts

@@ -0,0 +1,71 @@
+import { type TPalletControlLifetimeMode, type TPalletControlOneshotMode } from './protocol.js';
+/** Why a supervised `pallet-control` process did not complete. */
+export type TPalletControlProcessFailure = 'invalid_input' | 'already_started'
+/** The executable is not the trusted one: unsafe path, other digest, or it could not start. */
+ | 'artifact_rejected' | 'cancelled' | 'startup_timeout' | 'operation_timeout' | 'owner_failed'
+/** Pallet refused the `DENO_TLS_CA_STORE` it was started with. */
+ | 'invalid_ca_store'
+/** Pallet's packet engine refused the running kernel. */
+ | 'unsupported_kernel' | 'protocol_invalid' | 'shutdown_failed';
+/** The operator's remedy for `unsupported_kernel`, from Pallet's host kernel requirements. */
+export declare const palletUnsupportedKernelRemedy: string;
+export declare class PalletControlProcessError extends Error {
+    readonly code: TPalletControlProcessFailure;
+    constructor(code: TPalletControlProcessFailure);
+}
+/**
+ * The failure a `failed` line's reason names, or `undefined` for a reason outside the protocol. A
+ * reason whose remedy lies on this host is named apart; every other reason is Pallet's own failure.
+ */
+export declare const palletControlFailure: (reasonArg: unknown) => "unsupported_kernel" | "invalid_ca_store" | "owner_failed" | undefined;
+export interface IPalletControlProcessOptions {
+    /** Trusted installed bundle identity (`IPalletControlBundle.executables.control`), never read from CLI or environment. */
+    binaryPath: string;
+    binarySha256: string;
+    /** Owning-code qualification only; production supervises as root. */
+    expectedUid?: number;
+    /** Where the child's standard-error lines go, bounded; defaults to this process's standard error. */
+    stderr?: (lineArg: string) => void;
+}
+export interface IPalletControlOneshotOptions extends IPalletControlProcessOptions {
+    operationTimeoutMs?: number;
+    shutdownTimeoutMs?: number;
+    terminationGraceMs?: number;
+}
+/**
+ * One null-stdin oneshot: `guard-recover`, `guard-commission`, `network-acquire`,
+ * `network-acquire-local` or `store-provision`. Success requires the complete protocol (`ready`,
+ * then `stopped`), drained pipes and a successful exit. Cancellation and the operation deadline
+ * signal the child and still wait for its actual exit.
+ */
+export declare class PalletControlOneshot {
+    private readonly options;
+    private used;
+    constructor(optionsArg: IPalletControlOneshotOptions);
+    run(modeArg: TPalletControlOneshotMode, signalArg: AbortSignal): Promise<void>;
+    private runOnce;
+}
+export interface IPalletControlLifetimeOptions extends IPalletControlProcessOptions {
+    mode: TPalletControlLifetimeMode;
+    startupTimeoutMs?: number;
+    /** How long a stop may take after stdin closes before the child is signalled. */
+    shutdownTimeoutMs?: number;
+    terminationGraceMs?: number;
+}
+/**
+ * One supervised child lifetime: `enrollment-serve`, `enrollment-provision` or `runtime-serve`. The
+ * child holds its stdin pipe for the lifetime; closing it is the graceful stop, and only a missed
+ * shutdown deadline signals. The operation runs while the child reports `ready`, and the lifetime
+ * never restarts a child.
+ */
+export declare class PalletControlLifetime {
+    private readonly options;
+    private readonly mode;
+    private used;
+    private available;
+    constructor(optionsArg: IPalletControlLifetimeOptions);
+    get running(): boolean;
+    /** The operation must drain its admitted work after cancellation; references must not escape. */
+    run<TResult>(signalArg: AbortSignal, operationArg: (signalArg: AbortSignal) => Promise<TResult>): Promise<TResult>;
+    private runOnce;
+}

package/dist_ts_bundle/classes.controlprocess.js

@@ -0,0 +1,441 @@
+import * as plugins from './plugins.js';
+import { canonicalPath, verifyExecutable } from './paths.js';
+import { PalletControlStderr } from './classes.controlstderr.js';
+import { palletControlLifetimeModes, palletControlLinePrefix, palletControlOneshotModes, } from './protocol.js';
+/** The operator's remedy for `unsupported_kernel`, from Pallet's host kernel requirements. */
+export const palletUnsupportedKernelRemedy = "Pallet's packet engine refused this host's kernel: boot Linux 6.9 or newer with the nftables filter and NAT " +
+    'modules (nf_tables, nft_nat, nft_chain_nat, nf_nat and the reject modules) available; see Pallet\'s readme, ' +
+    '"Host kernel requirements".';
+export class PalletControlProcessError extends Error {
+    code;
+    constructor(code) {
+        super(`Pallet control process failed: ${code}.${code === 'unsupported_kernel' ? ` ${palletUnsupportedKernelRemedy}` : ''}`);
+        this.code = code;
+        this.name = 'PalletControlProcessError';
+    }
+}
+const failures = new Map([
+    ['invalid_arguments', 'owner_failed'],
+    ['invalid_ca_store', 'invalid_ca_store'],
+    ['invalid_stdin', 'owner_failed'],
+    ['owner_failed', 'owner_failed'],
+    ['unsupported_kernel', 'unsupported_kernel'],
+]);
+/**
+ * The failure a `failed` line's reason names, or `undefined` for a reason outside the protocol. A
+ * reason whose remedy lies on this host is named apart; every other reason is Pallet's own failure.
+ */
+export const palletControlFailure = (reasonArg) => typeof reasonArg === 'string' ? failures.get(reasonArg) : undefined;
+/**
+ * Starts the verified executable in one mode with a clean environment and reads its protocol.
+ * `onLine` receives each complete stdout line and throws on a protocol violation; `onInvalid` is
+ * told once when either pipe violates the protocol or its bounds.
+ */
+function spawnControl(optionsArg) {
+    const child = plugins.childProcess.spawn(optionsArg.binaryPath, [optionsArg.mode], {
+        cwd: '/', env: { PATH: '/usr/bin:/bin' }, stdio: [optionsArg.stdin, 'pipe', 'pipe'],
+    });
+    let exited = false;
+    let outputDone = false;
+    let outputBytes = 0;
+    child.stdin?.on('error', () => undefined);
+    const exit = new Promise((resolve) => {
+        child.once('exit', (code, signal) => { exited = true; resolve({ code, signal, spawned: true }); });
+        child.on('error', () => {
+            if (child.pid === undefined) {
+                exited = true;
+                resolve({ code: null, signal: null, spawned: false });
+            }
+        });
+    });
+    const read = async (streamArg, stdoutArg) => {
+        const decoder = new TextDecoder('utf-8', { fatal: true });
+        const diagnostics = stdoutArg ? undefined : new PalletControlStderr(optionsArg.mode, optionsArg.stderr);
+        let pending = '';
+        try {
+            for await (const chunk of streamArg) {
+                // No encoding is set on the pipes, so every chunk is bytes.
+                if (typeof chunk === 'string')
+                    throw new Error('Unexpected text chunk.');
+                if (chunk.length > 1024 * 1024)
+                    throw new Error('Oversized chunk.');
+                outputBytes += chunk.length;
+                if (optionsArg.maximumOutputBytes !== null && outputBytes > optionsArg.maximumOutputBytes) {
+                    throw new Error('Output exceeds its bound.');
+                }
+                if (diagnostics) {
+                    diagnostics.accept(chunk);
+                    continue;
+                }
+                pending += decoder.decode(chunk, { stream: true });
+                for (let index; (index = pending.indexOf('\n')) !== -1;) {
+                    const line = pending.slice(0, index);
+                    pending = pending.slice(index + 1);
+                    if (line.length > 4096)
+                        throw new Error('Oversized line.');
+                    optionsArg.onLine(line);
+                }
+                if (pending.length > 4096)
+                    throw new Error('Oversized line.');
+            }
+            if (stdoutArg && (decoder.decode().length !== 0 || pending.length !== 0))
+                throw new Error('Unterminated line.');
+        }
+        catch {
+            optionsArg.onInvalid();
+            streamArg.destroy();
+        }
+        finally {
+            diagnostics?.close();
+        }
+    };
+    const output = Promise.all([read(child.stdout, true), read(child.stderr, false)]).then(() => { outputDone = true; });
+    // Safety net only: a descendant holding the pipes must not keep this lifetime open.
+    void exit.then(() => {
+        const timer = setTimeout(() => {
+            if (outputDone)
+                return;
+            optionsArg.onDrainExpired();
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+        }, optionsArg.terminationGraceMs);
+        void output.then(() => clearTimeout(timer));
+    });
+    return {
+        process: child, exit, output, exited: () => exited,
+        send: (signalArg) => !exited && child.kill(signalArg),
+    };
+}
+const validated = (optionsArg, allowedArg, timeoutsArg) => {
+    try {
+        const allowed = ['binaryPath', 'binarySha256', 'expectedUid', 'stderr', ...allowedArg, ...timeoutsArg.map(([key]) => key)];
+        if (!optionsArg || typeof optionsArg !== 'object' || plugins.nodeUtil.types.isProxy(optionsArg) ||
+            Object.getPrototypeOf(optionsArg) !== Object.prototype || Object.keys(optionsArg).some((key) => !allowed.includes(key))) {
+            throw new Error();
+        }
+        const options = optionsArg;
+        const expectedUid = options.expectedUid ?? 0;
+        if (typeof options.binarySha256 !== 'string' || !/^[0-9a-f]{64}$/.test(options.binarySha256) ||
+            !Number.isSafeInteger(expectedUid) || expectedUid < 0 || process.platform !== 'linux' || process.getuid?.() !== expectedUid ||
+            (options.stderr !== undefined && typeof options.stderr !== 'function'))
+            throw new Error();
+        const timeouts = {};
+        for (const [key, fallback, maximum] of timeoutsArg) {
+            const value = options[key] ?? fallback;
+            if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1 || value > maximum)
+                throw new Error();
+            timeouts[key] = value;
+        }
+        return {
+            binaryPath: canonicalPath(options.binaryPath), binarySha256: options.binarySha256, expectedUid,
+            stderr: options.stderr ?? ((lineArg) => console.error(lineArg)), timeouts,
+        };
+    }
+    catch {
+        throw new PalletControlProcessError('invalid_input');
+    }
+};
+/**
+ * One null-stdin oneshot: `guard-recover`, `guard-commission`, `network-acquire`,
+ * `network-acquire-local` or `store-provision`. Success requires the complete protocol (`ready`,
+ * then `stopped`), drained pipes and a successful exit. Cancellation and the operation deadline
+ * signal the child and still wait for its actual exit.
+ */
+export class PalletControlOneshot {
+    options;
+    used = false;
+    constructor(optionsArg) {
+        this.options = validated(optionsArg, [], [
+            ['operationTimeoutMs', 360_000, 600_000], ['shutdownTimeoutMs', 330_000, 600_000], ['terminationGraceMs', 1_000, 60_000],
+        ]);
+    }
+    run(modeArg, signalArg) {
+        if (!(signalArg instanceof AbortSignal) || !Object.hasOwn(palletControlOneshotModes, modeArg)) {
+            return Promise.reject(new PalletControlProcessError('invalid_input'));
+        }
+        if (this.used)
+            return Promise.reject(new PalletControlProcessError('already_started'));
+        this.used = true;
+        return this.runOnce(modeArg, signalArg);
+    }
+    async runOnce(modeArg, signalArg) {
+        const protocol = palletControlOneshotModes[modeArg];
+        const { timeouts } = this.options;
+        const abort = new AbortController();
+        let child;
+        // Classification is decided only once the exit and both drained pipes are joined: the child's
+        // own protocol evidence is read after its exit whenever the scheduler says so.
+        let evidence;
+        let failure;
+        let shutdownFailed = false;
+        let drainExpired = false;
+        let stopping = false;
+        // Written by the protocol reader, read after the child and its pipes are joined.
+        const progress = { phase: 'initial' };
+        let killTimer;
+        let status;
+        const stop = (reasonArg) => {
+            if (reasonArg && (!failure || failure === 'cancelled'))
+                failure = reasonArg;
+            abort.abort();
+            if (stopping)
+                return;
+            stopping = true;
+            if (child && !child.exited()) {
+                // Null stdin is normal for this protocol. Signals request joined Pallet cleanup.
+                child.send('SIGTERM');
+                killTimer = setTimeout(() => { if (child.send('SIGKILL'))
+                    shutdownFailed = true; }, timeouts.shutdownTimeoutMs);
+            }
+        };
+        const reject = (reasonArg) => {
+            // Reads cut short by the drain deadline carry no evidence about the child.
+            if (!drainExpired)
+                evidence ??= reasonArg;
+            stop();
+        };
+        const onAbort = () => stop('cancelled');
+        signalArg.addEventListener('abort', onAbort, { once: true });
+        const timer = setTimeout(() => stop('operation_timeout'), timeouts.operationTimeoutMs);
+        const line = (lineArg) => {
+            if (!lineArg.startsWith(palletControlLinePrefix))
+                return;
+            const value = JSON.parse(lineArg.slice(palletControlLinePrefix.length));
+            if (!value || typeof value !== 'object' || Array.isArray(value) || value.protocol !== protocol ||
+                progress.phase === 'stopped' || progress.phase === 'failed')
+                throw new Error('Unexpected protocol line.');
+            const keys = Object.keys(value).sort().join(',');
+            const named = palletControlFailure(value.reason);
+            if (value.event === 'ready' && keys === 'event,protocol' && progress.phase === 'initial')
+                progress.phase = 'ready';
+            else if (value.event === 'stopped' && keys === 'event,protocol' && progress.phase === 'ready')
+                progress.phase = 'stopped';
+            else if (value.event === 'failed' && keys === 'event,protocol,reason' && named !== undefined) {
+                progress.phase = 'failed';
+                reject(named);
+            }
+            else
+                throw new Error('Unexpected protocol event.');
+        };
+        try {
+            if (signalArg.aborted)
+                onAbort();
+            await verifyExecutable(this.options.binaryPath, this.options.binarySha256, this.options.expectedUid, abort.signal);
+            abort.signal.throwIfAborted();
+            child = spawnControl({
+                binaryPath: this.options.binaryPath, mode: modeArg, stdin: 'ignore', stderr: this.options.stderr,
+                maximumOutputBytes: 1024 * 1024, terminationGraceMs: timeouts.terminationGraceMs, onLine: line,
+                onInvalid: () => reject('protocol_invalid'),
+                onDrainExpired: () => { drainExpired = true; shutdownFailed = true; },
+            });
+            status = await child.exit;
+            await child.output;
+        }
+        catch {
+            stop(failure ?? (child ? 'owner_failed' : 'artifact_rejected'));
+        }
+        finally {
+            // Never release this lifetime on a timeout alone: wait for the actual child and pipes.
+            if (child) {
+                status = await child.exit;
+                await child.output;
+            }
+            signalArg.removeEventListener('abort', onAbort);
+            clearTimeout(timer);
+            clearTimeout(killTimer);
+        }
+        const code = evidence ?? (shutdownFailed ? 'shutdown_failed' : failure) ??
+            (status && !status.spawned ? 'artifact_rejected' : undefined) ??
+            (status && status.code !== 0 ? 'owner_failed' : undefined) ??
+            (progress.phase !== 'stopped' ? 'protocol_invalid' : undefined);
+        if (code)
+            throw new PalletControlProcessError(code);
+    }
+}
+/**
+ * One supervised child lifetime: `enrollment-serve`, `enrollment-provision` or `runtime-serve`. The
+ * child holds its stdin pipe for the lifetime; closing it is the graceful stop, and only a missed
+ * shutdown deadline signals. The operation runs while the child reports `ready`, and the lifetime
+ * never restarts a child.
+ */
+export class PalletControlLifetime {
+    options;
+    mode;
+    used = false;
+    available = false;
+    constructor(optionsArg) {
+        const mode = optionsArg?.mode;
+        if (typeof mode !== 'string' || !Object.hasOwn(palletControlLifetimeModes, mode)) {
+            throw new PalletControlProcessError('invalid_input');
+        }
+        const runtime = mode === 'runtime-serve';
+        this.mode = mode;
+        // The runtime may join a five-minute native operation, then database cleanup.
+        this.options = validated(optionsArg, ['mode'], [
+            ['startupTimeoutMs', 15_000, 60_000], ['shutdownTimeoutMs', runtime ? 330_000 : 15_000, runtime ? 600_000 : 60_000],
+            ['terminationGraceMs', 1_000, 60_000],
+        ]);
+    }
+    get running() {
+        return this.available;
+    }
+    /** The operation must drain its admitted work after cancellation; references must not escape. */
+    run(signalArg, operationArg) {
+        if (!(signalArg instanceof AbortSignal) || typeof operationArg !== 'function') {
+            return Promise.reject(new PalletControlProcessError('invalid_input'));
+        }
+        if (this.used)
+            return Promise.reject(new PalletControlProcessError('already_started'));
+        this.used = true;
+        return this.runOnce(signalArg, operationArg);
+    }
+    async runOnce(signalArg, operationArg) {
+        const protocol = palletControlLifetimeModes[this.mode];
+        const { timeouts } = this.options;
+        const abort = new AbortController();
+        let child;
+        let evidence;
+        let failure;
+        let shutdownFailed = false;
+        let drainExpired = false;
+        let exitFailed = false;
+        let stopping = false;
+        let readySeen = false;
+        let stoppedSeen = false;
+        let terminalSeen = false;
+        let termTimer;
+        let killTimer;
+        let resolveReady;
+        let rejectReady;
+        const ready = new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; });
+        void ready.catch(() => undefined);
+        const send = (signalArg) => {
+            // Only a missed shutdown deadline signals: a delivered signal proves forced cleanup.
+            if (child?.send(signalArg))
+                shutdownFailed = true;
+        };
+        const stop = (reasonArg) => {
+            // Cancellation is only graceful if the child subsequently proves clean shutdown.
+            if (reasonArg && (!failure || failure === 'cancelled'))
+                failure = reasonArg;
+            this.available = false;
+            abort.abort();
+            rejectReady(new PalletControlProcessError(failure ?? 'cancelled'));
+            if (stopping)
+                return;
+            stopping = true;
+            if (child && !child.exited()) {
+                // EOF is the graceful parent-lifetime signal. No configuration or bearer is written.
+                child.process.stdin?.end();
+                termTimer = setTimeout(() => {
+                    send('SIGTERM');
+                    killTimer = setTimeout(() => send('SIGKILL'), timeouts.terminationGraceMs);
+                }, timeouts.shutdownTimeoutMs);
+            }
+        };
+        const reject = (reasonArg) => {
+            if (!drainExpired)
+                evidence ??= reasonArg;
+            stop();
+        };
+        const onAbort = () => stop('cancelled');
+        signalArg.addEventListener('abort', onAbort, { once: true });
+        const startupTimer = setTimeout(() => stop('startup_timeout'), timeouts.startupTimeoutMs);
+        const line = (lineArg) => {
+            if (!lineArg.startsWith(palletControlLinePrefix))
+                return;
+            const value = JSON.parse(lineArg.slice(palletControlLinePrefix.length));
+            if (!value || typeof value !== 'object' || Array.isArray(value) || terminalSeen || value.protocol !== protocol) {
+                throw new Error('Unexpected protocol line.');
+            }
+            const keys = Object.keys(value).sort().join(',');
+            const named = palletControlFailure(value.reason);
+            if (value.event === 'ready' && keys === 'event,protocol' && !readySeen) {
+                readySeen = true;
+                if (!stopping && !child?.exited()) {
+                    this.available = true;
+                    resolveReady();
+                }
+            }
+            else if (value.event === 'stopped' && keys === 'event,protocol') {
+                stoppedSeen = true;
+                terminalSeen = true;
+                if (!stopping)
+                    reject('owner_failed');
+            }
+            else if (value.event === 'failed' && keys === 'event,protocol,reason' && named !== undefined) {
+                terminalSeen = true;
+                reject(named);
+            }
+            else
+                throw new Error('Unexpected protocol event.');
+        };
+        let outcome;
+        let operationFailed = false;
+        let operationError;
+        try {
+            if (signalArg.aborted)
+                onAbort();
+            await verifyExecutable(this.options.binaryPath, this.options.binarySha256, this.options.expectedUid, abort.signal);
+            abort.signal.throwIfAborted();
+            child = spawnControl({
+                binaryPath: this.options.binaryPath, mode: this.mode, stdin: 'pipe', stderr: this.options.stderr,
+                // The runtime reports for its whole lifetime; only the enrollment owner's output is bounded in total.
+                maximumOutputBytes: this.mode === 'runtime-serve' ? null : 1024 * 1024,
+                terminationGraceMs: timeouts.terminationGraceMs, onLine: line, onInvalid: () => reject('protocol_invalid'),
+                onDrainExpired: () => { drainExpired = true; shutdownFailed = true; },
+            });
+            void child.exit.then((status) => {
+                this.available = false;
+                // An exit nobody requested, or an unsuccessful one, is a Pallet failure.
+                if (!status.spawned)
+                    failure ??= 'artifact_rejected';
+                else if (!stopping || status.code !== 0)
+                    exitFailed = true;
+                stop();
+            });
+            await ready;
+            clearTimeout(startupTimer);
+            if (abort.signal.aborted || !this.available)
+                throw new PalletControlProcessError(failure ?? 'owner_failed');
+            try {
+                outcome = { value: await operationArg(abort.signal) };
+            }
+            catch (error) {
+                operationFailed = true;
+                operationError = error;
+            }
+        }
+        catch (error) {
+            // Own rejections only report that the lifetime ended; the joined facts below classify it.
+            if (!(error instanceof PalletControlProcessError))
+                failure ??= 'artifact_rejected';
+        }
+        finally {
+            clearTimeout(startupTimer);
+            stop();
+            // Escalation is bounded; an unconfirmed OS exit keeps this owner and its promise alive.
+            if (child) {
+                await child.exit;
+                await child.output;
+            }
+            signalArg.removeEventListener('abort', onAbort);
+            clearTimeout(termTimer);
+            clearTimeout(killTimer);
+        }
+        const spawned = child !== undefined && (await child.exit).spawned;
+        const code = evidence ?? (shutdownFailed ? 'shutdown_failed' : undefined) ??
+            (failure !== 'cancelled' ? failure : undefined) ?? (exitFailed ? 'owner_failed' : undefined) ??
+            // Cancellation is only graceful if the child confirmed its stop.
+            (spawned && !stoppedSeen ? 'shutdown_failed' : failure);
+        if (code)
+            throw new PalletControlProcessError(code);
+        if (operationFailed)
+            throw operationError;
+        // Unreachable: a lifetime that never ran its operation always names a failure above.
+        if (!outcome)
+            throw new PalletControlProcessError('owner_failed');
+        return outcome.value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.controlprocess.js","sourceRoot":"","sources":["../ts_bundle/classes.controlprocess.ts"],"names":[],"mappings":"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"}

package/dist_ts_bundle/classes.controlstderr.d.ts

@@ -0,0 +1,36 @@
+/** The longest forwarded line, in characters after escaping; the rest of the line is cut. */
+export declare const palletControlStderrLineLength = 512;
+/** The most lines forwarded per window; the lines beyond it are counted, not written. */
+export declare const palletControlStderrWindowLines = 64;
+/** The length of one forwarding window. */
+export declare const palletControlStderrWindowMs = 60000;
+/**
+ * Forwards a `pallet-control` child's standard error, one line per line as
+ * `Pallet <mode> stderr: <line>`.
+ *
+ * Pallet writes no diagnostics of its own there except the one line naming the owner behind an
+ * `owner_failed` failure; its native owners' output stays inside Pallet and its errors are
+ * value-free codes. What else reaches this stream is the Deno runtime's report of an error Pallet
+ * did not handle. Every line is bounded: control characters are escaped, a line is cut at
+ * {@link palletControlStderrLineLength} characters, and at most {@link palletControlStderrWindowLines}
+ * lines are written per window; a later line or the end of the stream states how many were not.
+ */
+export declare class PalletControlStderr {
+    private readonly mode;
+    private readonly write;
+    private readonly now;
+    private readonly decoder;
+    private pending;
+    private cut;
+    private windowStart;
+    private windowLines;
+    private suppressed;
+    private closed;
+    constructor(mode: string, write?: (lineArg: string) => void, now?: () => number);
+    /** Accepts one chunk as read from the pipe. */
+    accept(chunkArg: Uint8Array): void;
+    /** Ends the stream: writes an unterminated last line and the count of lines not written. */
+    close(): void;
+    private line;
+    private flushSuppressed;
+}