@akira-tl/forgerelay 0.8.8 → 0.8.10

package/dist/activity/history/bash-output-store.js

@@ -0,0 +1,250 @@
+import { randomUUID } from "node:crypto";
+import { openDatabase } from "../../runtime/state/db/client.js";
+import { SegmentedLogStore } from "../storage/segmented-log.js";
+import { bashOutputLogPrefix, bashOutputMetadataPrefix, stateRelativePath } from "../storage/paths.js";
+const DEFAULT_FLUSH_BYTES = 256 * 1024;
+const DEFAULT_FLUSH_INTERVAL_MS = 500;
+export class BashOutputStore {
+    database;
+    now;
+    nextOutputId;
+    stateDir;
+    logs;
+    pending = new Map();
+    flushBytes;
+    flushTimer;
+    constructor(stateDir, options = {}) {
+        this.database = openDatabase(stateDir);
+        this.now = options.now ?? (() => new Date());
+        this.nextOutputId = options.outputId ?? (() => `out_${randomUUID().replaceAll("-", "")}`);
+        this.stateDir = stateDir;
+        this.logs = new SegmentedLogStore(stateDir);
+        this.flushBytes = positiveInteger(options.flushBytes, DEFAULT_FLUSH_BYTES, "Bash output flushBytes");
+        const flushIntervalMs = positiveInteger(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS, "Bash output flushIntervalMs");
+        this.migrateLegacyStreams();
+        this.migrateLegacyMetadata();
+        this.flushTimer = setInterval(() => this.flushPending(), flushIntervalMs);
+        this.flushTimer.unref();
+    }
+    begin(input) {
+        const outputId = this.nextOutputId();
+        const startedAt = this.now().toISOString();
+        const workspace = { id: input.workspaceId, root: input.workspaceRoot, mode: "checkout" };
+        const logPrefix = stateRelativePath(this.stateDir, bashOutputLogPrefix(this.stateDir, workspace, outputId));
+        const commandRef = this.logs.append(bashOutputMetadataPrefix(this.stateDir, workspace, outputId, "command"), Buffer.from(input.command, "utf8"));
+        this.database.sqlite.prepare(`insert into bash_output_streams (
+        id, activity_id, turn_id, conversation_scope_id, process_id,
+        workspace_id, workspace_root, command, tty, status, timed_out, started_at,
+        log_file, output_bytes, command_file, command_offset, command_length
+      ) values (?, ?, ?, ?, ?, ?, ?, '', ?, 'running', 0, ?, ?, 0, ?, ?, ?)`).run(outputId, input.activityId, input.turnId, input.conversationScopeId ?? null, input.processId, input.workspaceId, input.workspaceRoot, input.tty ? 1 : 0, startedAt, logPrefix, commandRef.prefix, commandRef.offset, commandRef.length);
+        return outputId;
+    }
+    append(outputId, _channel, data) {
+        const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+        if (bytes.length === 0)
+            return;
+        const pending = this.pending.get(outputId) ?? { buffers: [], bytes: 0 };
+        pending.buffers.push(bytes);
+        pending.bytes += bytes.length;
+        this.pending.set(outputId, pending);
+        if (pending.bytes >= this.flushBytes)
+            this.flushOutput(outputId);
+    }
+    markReturned(outputId) {
+        this.flushOutput(outputId);
+        this.database.sqlite.prepare("update bash_output_streams set returned = 1 where id = ?").run(outputId);
+    }
+    claimCompletion(outputId) {
+        this.flushOutput(outputId);
+        const claimedAt = this.now().toISOString();
+        const claimed = this.database.sqlite.prepare(`update bash_output_streams
+       set completion_claimed_at = ?
+       where id = ? and returned = 1 and status != 'running' and completion_claimed_at is null`).run(claimedAt, outputId);
+        return claimed.changes === 1 ? this.readMetadata(outputId) : undefined;
+    }
+    finish(outputId, input) {
+        this.flushOutput(outputId);
+        const row = this.requireStream(outputId);
+        const status = input.error || input.timedOut || input.signal || (input.exitCode !== undefined && input.exitCode !== 0)
+            ? "failed"
+            : "done";
+        const errorRef = input.error
+            ? this.logs.append(bashOutputMetadataPrefix(this.stateDir, { id: row.workspace_id, root: row.workspace_root, mode: "checkout" }, outputId, "error"), Buffer.from(input.error, "utf8"))
+            : undefined;
+        this.database.sqlite.prepare(`update bash_output_streams
+       set status = ?, exit_code = ?, signal = ?, timed_out = ?, error = null, finished_at = ?,
+           error_file = ?, error_offset = ?, error_length = ?
+       where id = ?`).run(status, input.exitCode ?? null, input.signal ?? null, input.timedOut ? 1 : 0, this.now().toISOString(), errorRef?.prefix ?? null, errorRef?.offset ?? null, errorRef?.length ?? null, outputId);
+    }
+    read(outputId) {
+        const metadata = this.readMetadata(outputId);
+        if (!metadata)
+            return undefined;
+        const row = this.requireStream(outputId);
+        const prefix = this.ensureFileBacked(row);
+        const output = this.logs.readRange(prefix, 0, metadata.outputBytes).toString("utf8");
+        return { ...metadata, output };
+    }
+    readSince(outputId, cursor = 0) {
+        const metadata = this.readMetadata(outputId);
+        if (!metadata)
+            return undefined;
+        if (!Number.isSafeInteger(cursor) || cursor < 0) {
+            throw new Error(`Bash output cursor must be a non-negative integer: ${cursor}.`);
+        }
+        const start = Math.min(cursor, metadata.outputBytes);
+        const row = this.requireStream(outputId);
+        const prefix = this.ensureFileBacked(row);
+        const output = this.logs.readRange(prefix, start, metadata.outputBytes).toString("utf8");
+        return { ...metadata, output, cursor: metadata.outputBytes };
+    }
+    readMetadata(outputId) {
+        this.flushOutput(outputId);
+        const row = this.readStream(outputId);
+        if (!row)
+            return undefined;
+        this.ensureFileBacked(row);
+        const refreshed = this.requireStream(outputId);
+        return this.rowToMetadata(refreshed);
+    }
+    deleteWorkspace(workspaceId) {
+        const rows = this.database.sqlite.prepare("select id from bash_output_streams where workspace_id = ?").all(workspaceId);
+        for (const row of rows) {
+            this.flushOutput(row.id);
+            this.pending.delete(row.id);
+        }
+        this.database.sqlite.prepare("delete from bash_output_streams where workspace_id = ?").run(workspaceId);
+    }
+    close() {
+        clearInterval(this.flushTimer);
+        this.flushPending();
+        this.database.close();
+    }
+    flushPending() {
+        for (const outputId of [...this.pending.keys()])
+            this.flushOutput(outputId);
+    }
+    flushOutput(outputId) {
+        const pending = this.pending.get(outputId);
+        if (!pending || pending.bytes === 0)
+            return;
+        const row = this.requireStream(outputId);
+        const prefix = this.ensureFileBacked(row);
+        const onDiskBytes = this.logs.logicalLength(prefix);
+        if (onDiskBytes < row.output_bytes) {
+            throw new Error(`Bash output ${outputId} metadata references ${row.output_bytes} bytes but only ${onDiskBytes} are on disk.`);
+        }
+        const data = Buffer.concat(pending.buffers, pending.bytes);
+        // File first, index second. If SQLite updating fails after the write, the
+        // next access reconciles output_bytes from the append-only log rather than
+        // re-emitting the already-written payload.
+        this.logs.appendAt(prefix, onDiskBytes, data);
+        this.pending.delete(outputId);
+        this.database.sqlite.prepare("update bash_output_streams set output_bytes = ? where id = ?").run(onDiskBytes + data.length, outputId);
+    }
+    ensureFileBacked(row) {
+        let prefix = row.log_file;
+        if (!prefix) {
+            prefix = stateRelativePath(this.stateDir, bashOutputLogPrefix(this.stateDir, { id: row.workspace_id, root: row.workspace_root, mode: "checkout" }, row.id));
+            let logicalOffset = this.logs.logicalLength(prefix);
+            const legacyRows = this.database.sqlite.prepare(`select data from bash_output_chunks
+         where output_id = ?
+         order by sequence asc`);
+            for (const legacy of legacyRows.iterate(row.id)) {
+                this.logs.appendAt(prefix, logicalOffset, legacy.data);
+                logicalOffset += legacy.data.length;
+            }
+            this.database.sqlite.transaction(() => {
+                this.database.sqlite.prepare("update bash_output_streams set log_file = ?, output_bytes = ? where id = ?").run(prefix, logicalOffset, row.id);
+                this.database.sqlite.prepare("delete from bash_output_chunks where output_id = ?").run(row.id);
+            }).immediate();
+            row.log_file = prefix;
+            row.output_bytes = logicalOffset;
+            return prefix;
+        }
+        const onDiskBytes = this.logs.logicalLength(prefix);
+        if (onDiskBytes < row.output_bytes) {
+            throw new Error(`Bash output ${row.id} index is ahead of its segmented log (${row.output_bytes} > ${onDiskBytes}).`);
+        }
+        if (onDiskBytes > row.output_bytes) {
+            this.database.sqlite.prepare("update bash_output_streams set output_bytes = ? where id = ?").run(onDiskBytes, row.id);
+            row.output_bytes = onDiskBytes;
+        }
+        return prefix;
+    }
+    migrateLegacyStreams() {
+        const rows = this.database.sqlite.prepare("select * from bash_output_streams where log_file is null order by started_at asc");
+        for (const row of rows.iterate()) {
+            this.ensureFileBacked(row);
+        }
+    }
+    migrateLegacyMetadata() {
+        const rows = this.database.sqlite.prepare(`select * from bash_output_streams
+       where command_file is null or (error is not null and error_file is null)
+       order by started_at asc`);
+        const update = this.database.sqlite.prepare(`update bash_output_streams
+       set command = '', error = null,
+           command_file = ?, command_offset = ?, command_length = ?,
+           error_file = ?, error_offset = ?, error_length = ?
+       where id = ?`);
+        for (const row of rows.iterate()) {
+            const workspace = { id: row.workspace_id, root: row.workspace_root, mode: "checkout" };
+            const commandRef = row.command_file
+                ? undefined
+                : this.logs.append(bashOutputMetadataPrefix(this.stateDir, workspace, row.id, "command"), Buffer.from(row.command, "utf8"));
+            const errorRef = row.error && !row.error_file
+                ? this.logs.append(bashOutputMetadataPrefix(this.stateDir, workspace, row.id, "error"), Buffer.from(row.error, "utf8"))
+                : undefined;
+            update.run(commandRef?.prefix ?? row.command_file, commandRef?.offset ?? row.command_offset, commandRef?.length ?? row.command_length, errorRef?.prefix ?? row.error_file, errorRef?.offset ?? row.error_offset, errorRef?.length ?? row.error_length, row.id);
+        }
+    }
+    rowToMetadata(stream) {
+        const command = this.readMetadataField(stream.command_file, stream.command_offset, stream.command_length, stream.command);
+        const error = this.readMetadataField(stream.error_file, stream.error_offset, stream.error_length, stream.error ?? undefined);
+        return {
+            outputId: stream.id,
+            activityId: stream.activity_id,
+            turnId: stream.turn_id,
+            ...(stream.conversation_scope_id ? { conversationScopeId: stream.conversation_scope_id } : {}),
+            processId: stream.process_id,
+            workspaceId: stream.workspace_id,
+            workspaceRoot: stream.workspace_root,
+            command,
+            tty: stream.tty === 1,
+            status: isBashOutputStatus(stream.status) ? stream.status : "failed",
+            ...(stream.exit_code !== null ? { exitCode: stream.exit_code } : {}),
+            ...(stream.signal ? { signal: stream.signal } : {}),
+            timedOut: stream.timed_out === 1,
+            ...(error ? { error } : {}),
+            returned: stream.returned === 1,
+            outputBytes: stream.output_bytes,
+            startedAt: stream.started_at,
+            ...(stream.finished_at ? { finishedAt: stream.finished_at } : {}),
+        };
+    }
+    readMetadataField(file, offset, length, fallback) {
+        if (file !== null && offset !== null && length !== null) {
+            return this.logs.read({ prefix: file, offset, length }).toString("utf8");
+        }
+        return fallback ?? "";
+    }
+    readStream(outputId) {
+        return this.database.sqlite.prepare("select * from bash_output_streams where id = ?").get(outputId);
+    }
+    requireStream(outputId) {
+        const row = this.readStream(outputId);
+        if (!row)
+            throw new Error(`Unknown Bash output: ${outputId}.`);
+        return row;
+    }
+}
+function isBashOutputStatus(value) {
+    return value === "running" || value === "done" || value === "failed";
+}
+function positiveInteger(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return resolved;
+}

package/dist/activity/{host-turn-store.js → history/host-turn-store.js}

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { openDatabase } from "../db/client.js";
+import { openDatabase } from "../../runtime/state/db/client.js";
 export class HostTurnStore {
     database;
     now;
@@ -34,6 +34,9 @@ export class HostTurnStore {
        limit 1`).get(conversationScopeId, workspaceId);
         return row ? rowToTurn(row) : undefined;
     }
+    deleteWorkspace(workspaceId) {
+        this.database.sqlite.prepare("delete from activity_host_turns where workspace_id = ?").run(workspaceId);
+    }
     close() {
         this.database.close();
     }

package/dist/activity/{query-service.js → history/query-service.js}

@@ -1,3 +1,4 @@
+import { deleteWorkspaceActivityHistory } from "../storage/history.js";
 export class ActivityQueryService {
     turns;
     audit;
@@ -7,6 +8,15 @@ export class ActivityQueryService {
         this.audit = audit;
         this.outputs = outputs;
     }
+    deleteWorkspaceHistory(stateDir, workspaceId) {
+        deleteWorkspaceActivityHistory({
+            stateDir,
+            workspaceId,
+            audit: this.audit,
+            outputs: this.outputs,
+            turns: this.turns,
+        });
+    }
     beginTurn(conversationScopeId, workspaceId) {
         const turn = this.turns.begin(conversationScopeId, workspaceId);
         return this.state(turn.turnId);
@@ -73,7 +83,7 @@ export class ActivityQueryService {
     }
     bashOutput(turnId, outputId, cursor = 0) {
         this.requireTurn(turnId);
-        const output = this.outputs.read(outputId);
+        const output = this.outputs.readSince(outputId, cursor);
         if (!output)
             throw new Error(`Unknown Bash output: ${outputId}.`);
         const activities = this.audit.listActivitiesByTurn(turnId);
@@ -81,17 +91,13 @@ export class ActivityQueryService {
         if (!visible) {
             throw new Error(`Bash output ${outputId} is not part of Host Turn ${turnId}.`);
         }
-        const latestCursor = output.chunks.at(-1)?.sequence ?? 0;
         return {
             outputId: output.outputId,
             activityId: output.activityId,
             processId: output.processId,
             command: output.command,
-            output: output.chunks
-                .filter((chunk) => chunk.sequence > cursor)
-                .map((chunk) => chunk.data)
-                .join(""),
-            cursor: latestCursor,
+            output: output.output,
+            cursor: output.cursor,
             status: output.status,
             ...(output.exitCode !== undefined ? { exitCode: output.exitCode } : {}),
             ...(output.signal !== undefined ? { signal: output.signal } : {}),

package/dist/activity/{lifecycle.js → runtime/lifecycle.js}

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { HookExecutionError } from "../hooks.js";
+import { HookExecutionError } from "../../mcp/hooks/hooks.js";
 export class ActivityLifecycle {
     auditStore;
     activityId;

package/dist/activity/{mcp-query-tools.js → runtime/mcp-query-tools.js}

@@ -1,8 +1,8 @@
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import * as z from "zod/v4";
-import { logEvent, transportSessionIdPrefix } from "../logger.js";
-import { hostConversationScopeId } from "../request-meta.js";
-import { ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY, ACTIVITY_PANEL_WORKSPACE_META_KEY, } from "./ui/contract.js";
+import { logEvent, transportSessionIdPrefix } from "../../runtime/logging/logger.js";
+import { hostConversationScopeId } from "../../mcp/request-meta.js";
+import { ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY, ACTIVITY_PANEL_WORKSPACE_META_KEY, } from "../ui/contract.js";
 const READ_ONLY_ANNOTATIONS = {
     readOnlyHint: true,
     destructiveHint: false,

package/dist/activity/storage/history.js

@@ -0,0 +1,12 @@
+import { removeWorkspaceActivityStorage } from "./paths.js";
+/**
+ * User-requested Workspace deletion is the retention boundary for durable
+ * Activity history by default. Index rows are removed before the backing files
+ * so a crash cannot leave SQLite pointing at already-deleted payload shards.
+ */
+export function deleteWorkspaceActivityHistory(input) {
+    input.outputs.deleteWorkspace(input.workspaceId);
+    input.audit.deleteWorkspace(input.workspaceId);
+    input.turns.deleteWorkspace(input.workspaceId);
+    removeWorkspaceActivityStorage(input.stateDir, input.workspaceId);
+}

package/dist/activity/storage/paths.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, rmSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+const SAFE_WORKSPACE_ID = /^(?:ws|rws|cws)_[a-z0-9]+$/i;
+export function activityWorkspaceStorageKey(workspace) {
+    if (workspace.id && SAFE_WORKSPACE_ID.test(workspace.id))
+        return workspace.id;
+    return `root_${createHash("sha256").update(`${workspace.mode}\0${resolve(workspace.root)}`).digest("hex").slice(0, 20)}`;
+}
+export function activityWorkspaceDirectory(stateDir, workspace) {
+    return join(stateDir, "workspaces", activityWorkspaceStorageKey(workspace), "activity");
+}
+export function activityEventLogPrefix(stateDir, workspace) {
+    return join(activityWorkspaceDirectory(stateDir, workspace), "events");
+}
+export function bashOutputDirectory(stateDir, workspace) {
+    return join(activityWorkspaceDirectory(stateDir, workspace), "bash");
+}
+export function bashOutputLogPrefix(stateDir, workspace, outputId) {
+    return join(bashOutputDirectory(stateDir, workspace), outputId);
+}
+export function bashOutputMetadataPrefix(stateDir, workspace, outputId, field) {
+    return join(bashOutputDirectory(stateDir, workspace), `${outputId}-${field}`);
+}
+export function removeWorkspaceActivityStorage(stateDir, workspaceId) {
+    if (!SAFE_WORKSPACE_ID.test(workspaceId)) {
+        throw new Error(`Invalid Workspace id for Activity storage cleanup: ${workspaceId}`);
+    }
+    rmSync(join(stateDir, "workspaces", workspaceId, "activity"), {
+        recursive: true,
+        force: true,
+    });
+}
+export function ensurePrivateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+}
+export function stateRelativePath(stateDir, path) {
+    const relationship = relative(resolve(stateDir), resolve(path));
+    if (relationship === "" ||
+        relationship === ".." ||
+        relationship.startsWith(`..${sep}`)) {
+        throw new Error(`Activity log path is outside ForgeRelay state directory: ${path}`);
+    }
+    return relationship.split(sep).join("/");
+}
+export function resolveStateRelativePath(stateDir, path) {
+    const absolute = resolve(stateDir, path);
+    const relationship = relative(resolve(stateDir), absolute);
+    if (relationship === ".." || relationship.startsWith(`..${sep}`)) {
+        throw new Error(`Activity log reference escapes ForgeRelay state directory: ${path}`);
+    }
+    return absolute;
+}
+export function ensureParentPrivate(path) {
+    ensurePrivateDirectory(dirname(path));
+}

package/dist/activity/storage/segmented-log.js

@@ -0,0 +1,149 @@
+import { closeSync, constants as fsConstants, fstatSync, openSync, readSync, readdirSync, statSync, writeSync, } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { ensureParentPrivate, resolveStateRelativePath, stateRelativePath } from "./paths.js";
+/**
+ * Segment files are deliberately small enough to inspect, copy, prune, and
+ * recover independently. The logical stream may be arbitrarily large; no
+ * individual on-disk activity/output file should grow without bound.
+ */
+export const ACTIVITY_LOG_SEGMENT_BYTES = 8 * 1024 * 1024;
+export class SegmentedLogStore {
+    stateDir;
+    segmentBytes;
+    appendOffsets = new Map();
+    constructor(stateDir, segmentBytes = ACTIVITY_LOG_SEGMENT_BYTES) {
+        this.stateDir = stateDir;
+        this.segmentBytes = segmentBytes;
+    }
+    append(prefixPath, data) {
+        const prefix = stateRelativePath(this.stateDir, prefixPath);
+        const currentOffset = this.appendOffsets.get(prefix) ?? this.discoverLength(prefixPath);
+        this.writeAt(prefixPath, currentOffset, data);
+        this.appendOffsets.set(prefix, currentOffset + data.byteLength);
+        return { prefix, offset: currentOffset, length: data.byteLength };
+    }
+    appendAt(prefix, logicalOffset, data) {
+        const prefixPath = resolveStateRelativePath(this.stateDir, prefix);
+        this.writeAt(prefixPath, logicalOffset, data);
+        const next = logicalOffset + data.byteLength;
+        const known = this.appendOffsets.get(prefix);
+        if (known === undefined || next > known)
+            this.appendOffsets.set(prefix, next);
+    }
+    read(reference) {
+        return this.readRange(reference.prefix, reference.offset, reference.offset + reference.length);
+    }
+    readRange(prefix, start, end) {
+        if (!Number.isSafeInteger(start) || start < 0 || !Number.isSafeInteger(end) || end < start) {
+            throw new Error(`Invalid segmented log range: ${start}..${end}.`);
+        }
+        if (start === end)
+            return Buffer.alloc(0);
+        const prefixPath = resolveStateRelativePath(this.stateDir, prefix);
+        const result = Buffer.allocUnsafe(end - start);
+        let logicalOffset = start;
+        let resultOffset = 0;
+        while (logicalOffset < end) {
+            const segmentIndex = Math.floor(logicalOffset / this.segmentBytes);
+            const segmentOffset = logicalOffset % this.segmentBytes;
+            const available = Math.min(end - logicalOffset, this.segmentBytes - segmentOffset);
+            const path = segmentPath(prefixPath, segmentIndex);
+            const fd = openSync(path, fsConstants.O_RDONLY);
+            try {
+                const bytesRead = readSync(fd, result, resultOffset, available, segmentOffset);
+                if (bytesRead !== available) {
+                    throw new Error(`Segmented log ${path} ended before logical offset ${logicalOffset + available}.`);
+                }
+            }
+            finally {
+                closeSync(fd);
+            }
+            logicalOffset += available;
+            resultOffset += available;
+        }
+        return result;
+    }
+    logicalLength(prefix) {
+        const known = this.appendOffsets.get(prefix);
+        if (known !== undefined)
+            return known;
+        const prefixPath = resolveStateRelativePath(this.stateDir, prefix);
+        const length = this.discoverLength(prefixPath);
+        this.appendOffsets.set(prefix, length);
+        return length;
+    }
+    writeAt(prefixPath, logicalOffset, data) {
+        if (!Number.isSafeInteger(logicalOffset) || logicalOffset < 0) {
+            throw new Error(`Invalid segmented log offset: ${logicalOffset}.`);
+        }
+        if (data.byteLength === 0)
+            return;
+        ensureParentPrivate(prefixPath);
+        const bytes = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        let sourceOffset = 0;
+        let current = logicalOffset;
+        while (sourceOffset < bytes.length) {
+            const segmentIndex = Math.floor(current / this.segmentBytes);
+            const segmentOffset = current % this.segmentBytes;
+            const writable = Math.min(bytes.length - sourceOffset, this.segmentBytes - segmentOffset);
+            const path = segmentPath(prefixPath, segmentIndex);
+            const fd = openSync(path, fsConstants.O_CREAT | fsConstants.O_WRONLY, 0o600);
+            try {
+                const stats = fstatSync(fd);
+                if (stats.size !== segmentOffset) {
+                    throw new Error(`Segmented log append position mismatch for ${path}: expected ${segmentOffset}, found ${stats.size}.`);
+                }
+                const written = writeSync(fd, bytes, sourceOffset, writable, segmentOffset);
+                if (written !== writable) {
+                    throw new Error(`Short write while appending segmented log ${path}.`);
+                }
+            }
+            finally {
+                closeSync(fd);
+            }
+            sourceOffset += writable;
+            current += writable;
+        }
+    }
+    discoverLength(prefixPath) {
+        const directory = dirname(prefixPath);
+        const stem = basename(prefixPath);
+        let files;
+        try {
+            files = readdirSync(directory);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return 0;
+            throw error;
+        }
+        const pattern = new RegExp(`^${escapeRegExp(stem)}\\.(\\d{6})\\.log$`);
+        let maxIndex = -1;
+        let maxSize = 0;
+        for (const file of files) {
+            const match = pattern.exec(file);
+            if (!match)
+                continue;
+            const index = Number(match[1]);
+            const size = statSync(join(directory, file)).size;
+            if (size > this.segmentBytes) {
+                throw new Error(`Segmented log shard exceeds ${this.segmentBytes} bytes: ${join(directory, file)}.`);
+            }
+            if (index > maxIndex) {
+                maxIndex = index;
+                maxSize = size;
+            }
+        }
+        if (maxIndex < 0)
+            return 0;
+        if (maxSize < this.segmentBytes)
+            return maxIndex * this.segmentBytes + maxSize;
+        return (maxIndex + 1) * this.segmentBytes;
+    }
+}
+export function segmentPath(prefixPath, index) {
+    return `${prefixPath}.${String(index).padStart(6, "0")}.log`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}