@memorax/memorax-code 0.1.1 → 0.1.3

package/lib/memorax-code-backend/dist/{repository-memory-scope.js → repository/scope.js}

@@ -57,7 +57,10 @@ export async function resolveRepositoryMemoryScope(input) {
             }),
         };
     }
-    const workspaceName = sanitizeWorkspaceName(basename(workspace));
+    const localWorkspace = gitRepository.kind === "degraded"
+        ? gitRepository.workspaceRoot
+        : workspace;
+    const workspaceName = sanitizeWorkspaceName(basename(localWorkspace));
     if (!workspaceName) {
         return {
             ok: false,
@@ -69,18 +72,30 @@ export async function resolveRepositoryMemoryScope(input) {
         ok: true,
         scope: memoryScope({
             baseUserId,
-            repositoryKey: identityKey("workspace-directory", workspace),
+            repositoryKey: identityKey("workspace-directory", localWorkspace),
             repositorySlug: workspaceName,
             identitySource: "workspace-directory",
             scopeKind: "local-directory",
-            boundWorkspaceRoot: workspace,
+            fallbackReason: gitRepository.kind === "degraded" ? gitRepository.reason : undefined,
+            boundWorkspaceRoot: localWorkspace,
         }),
     };
 }
 export function repositoryMemoryScopesMatch(left, right) {
     return left.repositoryKey === right.repositoryKey
         && left.baseUserId === right.baseUserId
-        && left.effectiveUserId === right.effectiveUserId;
+        && left.effectiveUserId === right.effectiveUserId
+        && left.fallbackReason === right.fallbackReason;
+}
+export function repositoryMemoryScopeCanUpgradeFromDegradedGit(previous, current) {
+    return previous.scopeKind === "local-directory"
+        && previous.identitySource === "workspace-directory"
+        && previous.fallbackReason === "git_metadata_invalid"
+        && current.scopeKind === "git-repository"
+        && current.fallbackReason === undefined
+        && previous.baseUserId === current.baseUserId
+        && previous.boundWorkspaceRoot !== undefined
+        && previous.boundWorkspaceRoot === current.boundWorkspaceRoot;
 }
 export async function repositoryMemoryScopeContainsWorkspace(scope, workspaceRoot) {
     if (!scope.boundWorkspaceRoot || !workspaceRoot?.trim())
@@ -96,6 +111,11 @@ export async function repositoryMemoryScopeContainsWorkspace(scope, workspaceRoo
     }
     if (!pathContains(scope.boundWorkspaceRoot, workspace))
         return false;
+    if (scope.scopeKind === "local-directory" && scope.fallbackReason === "git_metadata_invalid") {
+        const gitRepository = await resolveGitRepository(workspace);
+        return gitRepository.kind === "degraded"
+            && identityKey("workspace-directory", gitRepository.workspaceRoot) === scope.repositoryKey;
+    }
     return scope.scopeKind !== "local-directory"
         || !await hasGitMarkerBetween(workspace, scope.boundWorkspaceRoot);
 }
@@ -112,6 +132,7 @@ function memoryScope(input) {
         repositoryName: input.repositorySlug,
         identitySource: input.identitySource,
         scopeKind: input.scopeKind,
+        ...(input.fallbackReason ? { fallbackReason: input.fallbackReason } : {}),
         ...(input.boundWorkspaceRoot ? { boundWorkspaceRoot: input.boundWorkspaceRoot } : {}),
     };
 }
@@ -134,8 +155,11 @@ async function resolveGitRepository(workspace) {
     }
     if (!marker)
         return { kind: "none" };
+    let directDirectoryMarker = false;
     try {
-        const gitDir = await resolveGitDir(marker.path);
+        const resolvedGitDir = await resolveGitDir(marker.path);
+        directDirectoryMarker = resolvedGitDir.directDirectoryMarker;
+        const gitDir = resolvedGitDir.path;
         await validateGitHead(gitDir);
         const commonDir = await resolveGitCommonDir(gitDir);
         await validateGitCommonDir(commonDir);
@@ -149,7 +173,14 @@ async function resolveGitRepository(workspace) {
             workspaceRoot: marker.workspaceRoot,
         };
     }
-    catch {
+    catch (error) {
+        if (directDirectoryMarker && canFallbackFromDirectGitDirectory(error)) {
+            return {
+                kind: "degraded",
+                reason: "git_metadata_invalid",
+                workspaceRoot: marker.workspaceRoot,
+            };
+        }
         return { kind: "invalid" };
     }
 }
@@ -191,19 +222,27 @@ async function hasGitMarkerBetween(workspace, boundary) {
     }
 }
 async function resolveGitDir(marker) {
-    if ((await fs.lstat(marker)).isSymbolicLink())
-        throw new Error("symbolic Git metadata marker is not allowed");
-    const markerStat = await fs.stat(marker);
-    if (markerStat.isDirectory())
-        return await canonicalDirectory(marker);
+    const markerStat = await fs.lstat(marker);
+    if (markerStat.isSymbolicLink()) {
+        throw new GitMetadataValidationError("symbolic Git metadata marker is not allowed");
+    }
+    if (markerStat.isDirectory()) {
+        return {
+            path: await canonicalDirectory(marker),
+            directDirectoryMarker: true,
+        };
+    }
     if (!markerStat.isFile())
-        throw new Error("invalid Git metadata marker");
+        throw new GitMetadataValidationError("invalid Git metadata marker");
     const line = await readSingleLine(marker, MAX_GIT_POINTER_BYTES);
     const match = /^gitdir:[ \t]*(.+)$/i.exec(line);
     const gitDir = match?.[1]?.trim();
     if (!gitDir)
-        throw new Error("invalid Git metadata pointer");
-    return await canonicalDirectory(resolveMetadataPath(dirname(marker), gitDir));
+        throw new GitMetadataValidationError("invalid Git metadata pointer");
+    return {
+        path: await canonicalDirectory(resolveMetadataPath(dirname(marker), gitDir)),
+        directDirectoryMarker: false,
+    };
 }
 async function resolveGitCommonDir(gitDir) {
     const path = join(gitDir, "commondir");
@@ -217,34 +256,35 @@ async function resolveGitCommonDir(gitDir) {
     }
     const commonDir = (await readSingleLine(path, MAX_GIT_POINTER_BYTES)).trim();
     if (!commonDir)
-        throw new Error("invalid Git common directory pointer");
+        throw new GitMetadataValidationError("invalid Git common directory pointer");
     return await canonicalDirectory(resolveMetadataPath(gitDir, commonDir));
 }
 function resolveMetadataPath(base, value) {
     if (value.includes("\0"))
-        throw new Error("invalid Git metadata path");
+        throw new GitMetadataValidationError("invalid Git metadata path");
     return isAbsolute(value) ? value : resolve(base, value);
 }
 async function canonicalDirectory(path) {
     const canonical = await fs.realpath(path);
-    if (!(await fs.stat(canonical)).isDirectory())
-        throw new Error("Git metadata path is not a directory");
+    if (!(await fs.stat(canonical)).isDirectory()) {
+        throw new GitMetadataValidationError("Git metadata path is not a directory");
+    }
     return canonical;
 }
 async function validateGitHead(gitDir) {
     const head = (await readSingleLine(join(gitDir, "HEAD"), MAX_GIT_POINTER_BYTES)).trim();
     if (!/^ref: refs\/[^\0\r\n]+$/.test(head) && !/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(head)) {
-        throw new Error("invalid Git HEAD");
+        throw new GitMetadataValidationError("invalid Git HEAD");
     }
 }
 async function validateGitCommonDir(commonDir) {
     if (!(await fs.stat(join(commonDir, "objects"))).isDirectory()) {
-        throw new Error("invalid Git objects directory");
+        throw new GitMetadataValidationError("invalid Git objects directory");
     }
     const hasRefs = await isDirectory(join(commonDir, "refs"));
     const hasReftable = await isDirectory(join(commonDir, "reftable"));
     if (!hasRefs && !hasReftable)
-        throw new Error("invalid Git references directory");
+        throw new GitMetadataValidationError("invalid Git references directory");
 }
 async function isDirectory(path) {
     try {
@@ -263,17 +303,18 @@ async function readSingleLine(path, maxBytes) {
     else if (value.endsWith("\n"))
         value = value.slice(0, -1);
     if (!value || value.includes("\0") || value.includes("\r") || value.includes("\n")) {
-        throw new Error("invalid single-line Git metadata");
+        throw new GitMetadataValidationError("invalid single-line Git metadata");
     }
     return value;
 }
 async function readBoundedTextFile(path, maxBytes) {
     const file = await fs.stat(path);
-    if (!file.isFile() || file.size > maxBytes)
-        throw new Error("invalid Git metadata file");
+    if (!file.isFile() || file.size > maxBytes) {
+        throw new GitMetadataValidationError("invalid Git metadata file");
+    }
     const value = await fs.readFile(path, "utf8");
     if (Buffer.byteLength(value, "utf8") > maxBytes || value.includes("\0")) {
-        throw new Error("invalid Git metadata file");
+        throw new GitMetadataValidationError("invalid Git metadata file");
     }
     return value;
 }
@@ -306,7 +347,7 @@ function parseDirectRemoteUrls(source) {
             continue;
         const assignment = /^[ \t]*([A-Za-z][A-Za-z0-9-]*)[ \t]*(?:=[ \t]*)?(.*)$/.exec(line);
         if (!assignment)
-            throw new Error("invalid Git config assignment");
+            throw new GitMetadataValidationError("invalid Git config assignment");
         if (assignment[1]?.toLowerCase() !== "url")
             continue;
         remotes.set(remote, parseGitConfigValue(assignment[2] ?? ""));
@@ -328,7 +369,7 @@ function logicalGitConfigLines(source) {
         }
     }
     if (pending)
-        throw new Error("unterminated Git config continuation");
+        throw new GitMetadataValidationError("unterminated Git config continuation");
     return lines;
 }
 function hasUnescapedTrailingBackslash(value) {
@@ -340,7 +381,7 @@ function hasUnescapedTrailingBackslash(value) {
 function parseGitConfigSection(line) {
     const match = /^\[[ \t]*([A-Za-z0-9][A-Za-z0-9.-]*)[ \t]*(?:"((?:[^"\\]|\\.)*)")?[ \t]*\](?:[ \t]*[#;].*)?$/.exec(line);
     if (!match?.[1])
-        throw new Error("invalid Git config section");
+        throw new GitMetadataValidationError("invalid Git config section");
     if (!match[2] && match[1].includes(".")) {
         const separator = match[1].indexOf(".");
         return {
@@ -378,11 +419,11 @@ function parseGitConfigValue(value) {
         }
         const trailing = input.slice(index + 1).trim();
         if (trailing && !trailing.startsWith("#") && !trailing.startsWith(";")) {
-            throw new Error("invalid Git config value");
+            throw new GitMetadataValidationError("invalid Git config value");
         }
         return result;
     }
-    throw new Error("unterminated Git config value");
+    throw new GitMetadataValidationError("unterminated Git config value");
 }
 function unescapeGitConfigText(value) {
     let result = "";
@@ -394,7 +435,7 @@ function unescapeGitConfigText(value) {
         }
         const escaped = value[index + 1];
         if (escaped === undefined)
-            throw new Error("invalid Git config escape");
+            throw new GitMetadataValidationError("invalid Git config escape");
         result += unescapeGitConfigCharacter(escaped);
         index += 1;
     }
@@ -409,7 +450,7 @@ function unescapeGitConfigCharacter(value) {
         return "\b";
     if (value === '"' || value === "\\")
         return value;
-    throw new Error("invalid Git config escape");
+    throw new GitMetadataValidationError("invalid Git config escape");
 }
 function selectedRemoteRepositoryName(remotes) {
     const origin = remotes.get("origin");
@@ -465,7 +506,7 @@ function repositoryNameFromCommonDir(commonDir) {
         : commonName.replace(/\.git$/i, "");
     const normalized = sanitizeWorkspaceName(name);
     if (!normalized)
-        throw new Error("Git common directory has no usable repository name");
+        throw new GitMetadataValidationError("Git common directory has no usable repository name");
     return normalized;
 }
 function identityKey(source, value) {
@@ -488,3 +529,10 @@ function pathContains(root, candidate) {
 function isNodeErrorCode(error, code) {
     return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
 }
+class GitMetadataValidationError extends Error {
+}
+function canFallbackFromDirectGitDirectory(error) {
+    return error instanceof GitMetadataValidationError
+        || isNodeErrorCode(error, "ENOENT")
+        || isNodeErrorCode(error, "ENOTDIR");
+}

package/lib/memorax-code-backend/dist/server.js

@@ -1,217 +1,8 @@
 #!/usr/bin/env node
-import { createServer, } from "node:http";
-import { isMainEntrypoint } from "./entrypoint.js";
-import { backendDebug } from "./debug-log.js";
-import { createMemoryReminderTraceRecorder } from "./memory-reminder-trace-recorder.js";
-import { handleMemoryViewerRequest } from "./server-memory-viewer.js";
-import { handleMemoryHookRequest } from "./server-memory-hook.js";
-import { createBackendMemoryObservability } from "./server-observability.js";
-import { createMemoryService } from "./memory-service.js";
-import { handleHealthRequest } from "./server-health.js";
-import { authorized, memoryViewerSessionCookieHeader, publicErrorMessage, statusCodeFromError } from "./server-http.js";
-import { json } from "./server-json.js";
-import { createBackendState } from "./backend-state.js";
-import { TRACE_CLIENTS } from "./trace-config.js";
-import { pruneExpiredTraceSessionsForClient } from "./trace-store.js";
-import { startMemoryWritebackReconciler } from "./memory-writeback-reconciler.js";
-import { createMemoryWritebackTaskProjection } from "./memory-writeback-task-projection.js";
-import { readActiveManagedClients } from "./active-client-selection.js";
-const DEFAULT_BACKEND_SHUTDOWN_TIMEOUT_MS = 4_000;
-export function createBackendServer(state = createBackendState(), options = {}) {
-    const memoryEnv = { ...process.env, MEMORAX_CODE_HOME: state.sessionHome };
-    const memoryWritebackTaskProjections = TRACE_CLIENTS.map((client) => createMemoryWritebackTaskProjection({
-        memoraxCodeHome: state.sessionHome,
-        client,
-    }));
-    const memoryObservability = createBackendMemoryObservability(state.sessionHome, options.memoryObservability, memoryEnv, memoryWritebackTaskProjections.map((projection) => projection.observabilityHook));
-    const memoryService = createMemoryService({
-        diagnosticLogger: backendDebug,
-        env: memoryEnv,
-        memoraxCodeHome: state.sessionHome,
-        memoryObservability,
-    });
-    const memoryHookDependencies = {
-        memoryService,
-        memoryReminderTraceRecorder: createMemoryReminderTraceRecorder({
-            diagnosticLogger: backendDebug,
-            env: memoryEnv,
-            memoraxCodeHome: state.sessionHome,
-        }),
-    };
-    for (const client of TRACE_CLIENTS) {
-        void pruneExpiredTraceSessionsForClient({
-            client,
-            memoraxCodeHome: state.sessionHome,
-        }).catch((error) => {
-            backendDebug(`${client}_trace.retention_cleanup_failed`, {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-    }
-    const memoryWritebackReconcilers = memoryWritebackTaskProjections.map((taskProjection) => (startMemoryWritebackReconciler({
-        memoraxCodeHome: state.sessionHome,
-        env: memoryEnv,
-        taskProjection,
-    })));
-    const handleRequest = async (req, res) => {
-        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
-        backendDebug("http.request", {
-            method: req.method,
-            path: url.pathname,
-        });
-        try {
-            if (req.method === "GET" && url.pathname === "/health")
-                return handleHealthRequest(state, res);
-            if (!authorized(state, req, url))
-                return json(res, 401, { ok: false, error: "unauthorized" });
-            if (url.pathname === "/memory-viewer"
-                || url.pathname.startsWith("/memory-viewer/")) {
-                if (await handleMemoryViewerRequest(url, req, res, {
-                    memoraxCodeHome: state.sessionHome,
-                    claudeProjectsRoot: readActiveManagedClients(state.sessionHome)?.claude === true
-                        ? state.claudeProjectsRoot
-                        : false,
-                    sessionCookie: memoryViewerSessionCookieHeader(state, req, url),
-                }))
-                    return;
-            }
-            if (await handleMemoryHookRequest(memoryHookDependencies, url, req, res))
-                return;
-            return json(res, 404, { ok: false, error: "not found" });
-        }
-        catch (error) {
-            const status = statusCodeFromError(error);
-            const publicMessage = publicErrorMessage(error);
-            if (status >= 500)
-                console.error("request failed", error);
-            if (res.headersSent) {
-                return res.end();
-            }
-            return json(res, status, { ok: false, error: publicMessage });
-        }
-    };
-    const activeRequests = new Set();
-    const server = createServer((req, res) => {
-        const request = handleRequest(req, res);
-        activeRequests.add(request);
-        void request.then(() => activeRequests.delete(request), () => activeRequests.delete(request));
-    });
-    return attachBackendShutdown(server, {
-        activeRequests,
-        memoryObservability,
-        memoryService,
-        memoryWritebackReconcilers,
-        timeoutMs: positiveShutdownTimeout(options.shutdownTimeoutMs),
-    });
-}
-function attachBackendShutdown(server, resources) {
-    const closeHttpServer = server.close.bind(server);
-    const backendServer = server;
-    let shutdownPromise;
-    backendServer.shutdown = () => {
-        shutdownPromise ??= shutdownBackend(backendServer, closeHttpServer, resources);
-        return shutdownPromise;
-    };
-    backendServer.close = ((callback) => {
-        void backendServer.shutdown().then(() => callback?.(), (error) => callback?.(error instanceof Error ? error : new Error(String(error))));
-        return backendServer;
-    });
-    return backendServer;
-}
-async function shutdownBackend(server, closeHttpServer, resources) {
-    const deadline = Date.now() + resources.timeoutMs;
-    const reconcilerDrain = settleShutdownWork("memory_writeback_reconcilers", Promise.all(resources.memoryWritebackReconcilers.map((reconciler) => reconciler.close())));
-    try {
-        await waitForShutdownPhase("http_server", closeBackendHttpServer(server, closeHttpServer, resources.timeoutMs), deadline);
-        await waitForShutdownPhase("http_requests", waitForActiveRequests(resources.activeRequests), deadline);
-        if (Date.now() < deadline) {
-            await waitForShutdownPhase("memory_service", settleShutdownWork("memory_service", resources.memoryService.drain()), deadline);
-        }
-        if (Date.now() < deadline && resources.memoryObservability?.drain) {
-            await waitForShutdownPhase("memory_observability", settleShutdownWork("memory_observability", resources.memoryObservability.drain()), deadline);
-        }
-        await waitForShutdownPhase("background_work", reconcilerDrain, deadline);
-    }
-    finally {
-        resources.memoryService.close();
-    }
-}
-function closeBackendHttpServer(server, closeHttpServer, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const forceTimer = setTimeout(() => {
-            backendDebug("shutdown.http_connections_forced", { timeoutMs });
-            try {
-                server.closeAllConnections();
-            }
-            catch (error) {
-                backendDebug("shutdown.http_connections_force_failed", {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }, timeoutMs);
-        const done = (error) => {
-            clearTimeout(forceTimer);
-            if (error && error.code !== "ERR_SERVER_NOT_RUNNING") {
-                reject(error);
-                return;
-            }
-            resolve();
-        };
-        try {
-            closeHttpServer(done);
-            server.closeIdleConnections();
-        }
-        catch (error) {
-            done(error instanceof Error ? error : new Error(String(error)));
-        }
-    });
-}
-async function waitForActiveRequests(activeRequests) {
-    while (activeRequests.size > 0) {
-        await Promise.allSettled([...activeRequests]);
-    }
-}
-async function waitForShutdownPhase(phase, work, deadline) {
-    const remainingMs = deadline - Date.now();
-    if (remainingMs <= 0) {
-        backendDebug("shutdown.phase_timed_out", { phase, remainingMs: 0 });
-        return false;
-    }
-    let timer;
-    const result = await Promise.race([
-        work.then(() => ({ completed: true }), (error) => ({ completed: true, error })),
-        new Promise((resolve) => {
-            timer = setTimeout(() => resolve({ completed: false }), remainingMs);
-        }),
-    ]);
-    if (timer)
-        clearTimeout(timer);
-    if (!result.completed) {
-        backendDebug("shutdown.phase_timed_out", { phase, remainingMs });
-        return false;
-    }
-    if ("error" in result)
-        throw result.error;
-    return true;
-}
-async function settleShutdownWork(label, work) {
-    try {
-        await work;
-    }
-    catch (error) {
-        backendDebug("shutdown.work_failed", {
-            label,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-function positiveShutdownTimeout(value) {
-    if (typeof value === "number" && Number.isSafeInteger(value) && value > 0)
-        return value;
-    return DEFAULT_BACKEND_SHUTDOWN_TIMEOUT_MS;
-}
+import { isMainEntrypoint } from "./entrypoints/main.js";
+export { createBackendServer } from "./app/backend-server.js";
 if (isMainEntrypoint(import.meta.url)) {
-    import("./server-cli.js")
+    import("./entrypoints/backend-cli.js")
         .then(({ runBackendCli }) => runBackendCli(process.argv))
         .catch((error) => {
         console.error(error instanceof Error ? error.message : String(error));

package/lib/memorax-code-backend/dist/service-entrypoint.js

@@ -1,4 +1,4 @@
-import { runBackendCli } from "./server-cli.js";
+import { runBackendCli } from "./entrypoints/backend-cli.js";
 const markerIndex = process.argv.indexOf("--memorax-code-backend-instance");
 const instanceId = markerIndex >= 0 ? process.argv[markerIndex + 1] : undefined;
 if (!instanceId

package/lib/memorax-code-backend/dist/{debug-log.js → shared/debug-log.js}

@@ -1,4 +1,4 @@
-import { backendEnv } from "./backend-env.js";
+import { backendEnv } from "../config/backend-env.js";
 export function backendDebugEnabled() {
     const value = backendEnv("DEBUG_REQUESTS");
     return value === "1" || value === "true" || value === "yes";

package/lib/memorax-code-backend/dist/shared/jsonl-append.js

@@ -0,0 +1,75 @@
+import { open } from "node:fs/promises";
+const JSONL_TAIL_SCAN_CHUNK_BYTES = 8 * 1024;
+const pathOperations = new Map();
+export async function appendRepairingJsonl(path, text) {
+    await serializePath(path, async () => {
+        const handle = await open(path, "a+", 0o600);
+        try {
+            const { rollbackSize, separator } = await prepareTailForAppend(handle);
+            try {
+                await handle.writeFile(`${separator}${text}`, "utf8");
+            }
+            catch (error) {
+                await handle.truncate(rollbackSize).catch(() => undefined);
+                throw error;
+            }
+        }
+        finally {
+            await handle.close();
+        }
+    });
+}
+async function serializePath(path, operation) {
+    const previous = pathOperations.get(path) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(operation);
+    pathOperations.set(path, current);
+    try {
+        return await current;
+    }
+    finally {
+        if (pathOperations.get(path) === current)
+            pathOperations.delete(path);
+    }
+}
+async function prepareTailForAppend(handle) {
+    const size = (await handle.stat()).size;
+    if (size === 0)
+        return { rollbackSize: 0, separator: "" };
+    const lastByte = Buffer.allocUnsafe(1);
+    await readExactAt(handle, lastByte, size - 1);
+    if (lastByte[0] === 0x0a)
+        return { rollbackSize: size, separator: "" };
+    const tailStart = await jsonlTailStart(handle, size);
+    const tail = Buffer.allocUnsafe(size - tailStart);
+    await readExactAt(handle, tail, tailStart);
+    try {
+        JSON.parse(tail.toString("utf8"));
+        return { rollbackSize: size, separator: "\n" };
+    }
+    catch {
+        await handle.truncate(tailStart);
+        return { rollbackSize: tailStart, separator: "" };
+    }
+}
+async function jsonlTailStart(handle, size) {
+    let end = size;
+    while (end > 0) {
+        const start = Math.max(0, end - JSONL_TAIL_SCAN_CHUNK_BYTES);
+        const buffer = Buffer.allocUnsafe(end - start);
+        await readExactAt(handle, buffer, start);
+        const newline = buffer.lastIndexOf(0x0a);
+        if (newline >= 0)
+            return start + newline + 1;
+        end = start;
+    }
+    return 0;
+}
+async function readExactAt(handle, buffer, position) {
+    let offset = 0;
+    while (offset < buffer.length) {
+        const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, position + offset);
+        if (bytesRead === 0)
+            throw new Error("failed to read JSONL tail");
+        offset += bytesRead;
+    }
+}