pi-agent-browser-native 0.9.5 → 0.9.6

package/dist/extensions/agent-browser/lib/browser-execution-claims.js

@@ -1,202 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
-import { getErrorCode } from "./process-errors.js";
-import { join } from "node:path";
-import { readProcessStartIdentity } from "./process-identity.js";
-import { POLICY_LOCK_MAX_BYTES, } from "./browser-execution-claim-codec.js";
-import { ensureCoordinationDirectory, getCoordinationDirectory, getBrowserExecutionLockPath, } from "./browser-execution-identity.js";
-import { cleanDeadPolicyArtifacts, readClaim, readClaims, removeClaimOwnedBy, ownerAlive, waitForRetry, LOCK_OWNER_FILE, LOCK_TICKET_FILE, POLICY_LOCK_WAIT_MS, } from "./browser-execution-claim-storage.js";
-function claimPrecedes(left, right) {
-    if (left.ticket === null) {
-        return true;
-    }
-    if (right.ticket === null) {
-        return false;
-    }
-    return (left.ticket < right.ticket ||
-        (left.ticket === right.ticket && left.owner.token < right.owner.token));
-}
-async function hasPublishedLaterTicket(claim, ownClaim) {
-    if (claim.ticket !== null) {
-        return false;
-    }
-    const current = await readClaim(claim.path);
-    return current?.owner.token === claim.owner.token && !claimPrecedes(current, ownClaim);
-}
-function relevantPredecessor(claim, ownClaim) {
-    if (claim.owner.token === ownClaim.owner.token || !claimPrecedes(claim, ownClaim)) {
-        return false;
-    }
-    const ownSessions = ownClaim.owner.sessionNames;
-    const sessions = claim.owner.sessionNames;
-    return (ownSessions === null ||
-        sessions === null ||
-        ownSessions.some((session) => sessions.includes(session)));
-}
-async function claimBlocks(claim, ownClaim, budget) {
-    if (!relevantPredecessor(claim, ownClaim) || (await hasPublishedLaterTicket(claim, ownClaim))) {
-        return false;
-    }
-    const alive = await ownerAlive(claim.owner, budget);
-    if (alive === false) {
-        await removeClaimOwnedBy(claim.path, claim.owner.token);
-        return false;
-    }
-    // Native identity queries can outlive the whole critical section. Re-read the immutable
-    // claim so an already released owner, or a newly published later ticket, cannot block us.
-    if (!(await claimStillExists(claim.path))) {
-        return false;
-    }
-    return !(await hasPublishedLaterTicket(claim, ownClaim));
-}
-async function claimStillExists(path) {
-    try {
-        await lstat(path);
-        return true;
-    }
-    catch (error) {
-        return getErrorCode(error) !== "ENOENT";
-    }
-}
-async function anyPredecessorBlocks(claims, own, budget) {
-    for (const claim of claims) {
-        // Contender inspection/removal is ordered before the next ticket decision.
-        // oxlint-disable-next-line no-await-in-loop
-        if (await claimBlocks(claim, own, budget)) {
-            return true;
-        }
-    }
-    return false;
-}
-async function prepareClaim(identity, budget) {
-    const directory = getCoordinationDirectory(process.platform);
-    if (!(await ensureCoordinationDirectory(directory, process.platform))) {
-        return undefined;
-    }
-    const basePath = getBrowserExecutionLockPath(identity);
-    const token = randomUUID();
-    const startIdentity = await readProcessStartIdentity(process.pid, process.platform, budget);
-    if (startIdentity === undefined || startIdentity.length === 0) {
-        return undefined;
-    }
-    const owner = {
-        pid: process.pid,
-        startIdentity,
-        token,
-        sessionNames: identity.sessionNames,
-        version: 4,
-    };
-    const content = JSON.stringify(owner);
-    if (Buffer.byteLength(content) > POLICY_LOCK_MAX_BYTES) {
-        return undefined;
-    }
-    return {
-        owner,
-        content,
-        basePath,
-        directory,
-        candidatePath: `${basePath}.candidate-${token}`,
-        path: `${basePath}.claim-${token}`,
-    };
-}
-async function publishClaim(claim) {
-    await mkdir(claim.candidatePath, { mode: 0o700 });
-    await writeFile(join(claim.candidatePath, LOCK_OWNER_FILE), claim.content, {
-        encoding: "utf8",
-        flag: "wx",
-        mode: 0o600,
-    });
-    await rename(claim.candidatePath, claim.path);
-}
-async function publishTicket(claim) {
-    const claims = await readClaims(claim.basePath);
-    if (!claims) {
-        return undefined;
-    }
-    const maxTicket = claims.reduce((max, entry) => (entry.ticket === null ? max : Math.max(max, entry.ticket)), 0);
-    if (!Number.isSafeInteger(maxTicket + 1)) {
-        return undefined;
-    }
-    const ticket = { ticket: maxTicket + 1, token: claim.owner.token, version: 4 };
-    const candidate = join(claim.path, `.ticket-${claim.owner.token}.tmp`);
-    await writeFile(candidate, JSON.stringify(ticket), { encoding: "utf8", flag: "wx", mode: 0o600 });
-    await rename(candidate, join(claim.path, LOCK_TICKET_FILE));
-    return ticket.ticket;
-}
-function acquisitionCancelled(budget) {
-    return budget.signal?.aborted === true;
-}
-async function waitForTurn(claim, ticket, budget, deadline) {
-    while (budget.signal?.aborted !== true) {
-        // Each poll observes a fresh published ticket set after the previous delay.
-        // oxlint-disable-next-line no-await-in-loop
-        const claims = await readClaims(claim.basePath);
-        if (!claims) {
-            return false;
-        }
-        const own = claims.find((entry) => entry.owner.token === claim.owner.token);
-        if (!own || own.ticket !== ticket) {
-            return false;
-        }
-        // Liveness checks and stale-claim removal must finish before acquisition.
-        // oxlint-disable-next-line no-await-in-loop
-        if (!(await anyPredecessorBlocks(claims, own, budget))) {
-            // Opportunistic GC must finish before the final cancellation check.
-            // oxlint-disable-next-line no-await-in-loop
-            await cleanDeadPolicyArtifacts(claim.directory, budget);
-            // GC stays within the wait budget but cannot revoke a turn this claim already won;
-            // only cancellation can. Callers enforce their own operation deadlines.
-            return !acquisitionCancelled(budget);
-        }
-        if (Date.now() >= deadline) {
-            return false;
-        }
-        // Polling respects ordering and cancellation; contenders cannot run concurrently here.
-        // oxlint-disable-next-line no-await-in-loop
-        await waitForRetry(budget.signal);
-    }
-    return false;
-}
-function acquisitionDeadline(options) {
-    return options.deadline ?? Date.now() + (options.timeoutMs ?? POLICY_LOCK_WAIT_MS);
-}
-export async function acquireExecutionClaim(options) {
-    if (options.signal?.aborted === true) {
-        return undefined;
-    }
-    const deadline = acquisitionDeadline(options);
-    // timeoutMs: 0 retains the existing single-attempt policy probe contract.
-    const budget = {
-        signal: options.signal,
-        deadline: options.timeoutMs === 0 ? undefined : deadline,
-    };
-    const claim = await prepareClaim(options.identity, budget);
-    if (!claim) {
-        return undefined;
-    }
-    let published = false;
-    let acquired = false;
-    try {
-        await publishClaim(claim);
-        published = true;
-        const ticket = await publishTicket(claim);
-        if (ticket === undefined || !(await waitForTurn(claim, ticket, budget, deadline))) {
-            return undefined;
-        }
-        acquired = true;
-        return {
-            release: async () => {
-                await removeClaimOwnedBy(claim.path, claim.owner.token, Date.now() + POLICY_LOCK_WAIT_MS);
-            },
-        };
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        await rm(claim.candidatePath, { force: true, recursive: true }).catch(() => undefined);
-        if (published && !acquired) {
-            await removeClaimOwnedBy(claim.path, claim.owner.token, Date.now() + POLICY_LOCK_WAIT_MS);
-        }
-    }
-}

package/dist/extensions/agent-browser/lib/browser-execution-identity.js

@@ -1,77 +0,0 @@
-import { createHash } from "node:crypto";
-import { lstat, mkdir, realpath } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { canonicalizeAgentBrowserNamespace, foldAgentBrowserFilesystemIdentity, } from "./argv-grammar.js";
-import { getAgentBrowserSocketDirValidationError, resolveAgentBrowserSocketDir, } from "./process-socket-storage.js";
-import { getCurrentProcessUid } from "./process-identity.js";
-import { getErrorCode } from "./process-errors.js";
-export function getCoordinationDirectory(platform = process.platform) {
-    if (platform !== "win32") {
-        const uid = getCurrentProcessUid();
-        const suffix = uid === undefined ? "" : `-${uid}`;
-        return platform === "android"
-            ? join(tmpdir(), `pi-agent-browser-policy${suffix}`)
-            : `/tmp/pi-agent-browser-policy${suffix}`;
-    }
-    const user = process.env.USERNAME ?? process.env.USER ?? "unknown";
-    const suffix = createHash("sha256").update(user).digest("hex").slice(0, 12);
-    return join(tmpdir(), `pi-agent-browser-policy-${suffix}`);
-}
-function directoryOwnerTrusted(entry, platform) {
-    if (platform === "win32") {
-        return true;
-    }
-    const uid = getCurrentProcessUid();
-    return uid !== undefined && entry.uid === uid && (entry.mode & 0o077) === 0;
-}
-export async function ensureCoordinationDirectory(path, platform) {
-    try {
-        try {
-            await mkdir(path, { mode: 0o700 });
-        }
-        catch (error) {
-            if (getErrorCode(error) !== "EEXIST") {
-                return false;
-            }
-        }
-        const entry = await lstat(path);
-        return !entry.isSymbolicLink() && entry.isDirectory() && directoryOwnerTrusted(entry, platform);
-    }
-    catch {
-        return false;
-    }
-}
-/** Resolve only after native routing; omit sessionName for a namespace-wide operation. */
-export async function resolveBrowserExecutionIdentity(options) {
-    const socketDir = resolveAgentBrowserSocketDir(options);
-    const namespace = canonicalizeAgentBrowserNamespace(options.namespace);
-    let socketContext;
-    if (process.platform === "win32") {
-        // Windows native TCP daemons are shared across storage roots; don't split their coordination.
-        socketContext = `win32-native:${namespace ?? ""}`;
-    }
-    else {
-        if (socketDir === undefined) {
-            throw new Error("Browser execution coordination requires the native socket directory.");
-        }
-        const error = await getAgentBrowserSocketDirValidationError(socketDir);
-        if (error !== undefined && error.length > 0) {
-            throw new Error(`Browser execution coordination cannot use socket storage: ${error}.`);
-        }
-        const root = await realpath(socketDir);
-        socketContext =
-            namespace !== undefined && namespace.length > 0
-                ? join(root, "namespaces", namespace, "run")
-                : root;
-    }
-    return {
-        socketContext: foldAgentBrowserFilesystemIdentity(socketContext, process.platform),
-        ...(options.sessionName !== undefined
-            ? { sessionName: foldAgentBrowserFilesystemIdentity(options.sessionName, process.platform) }
-            : {}),
-    };
-}
-export function getBrowserExecutionLockPath(identity) {
-    return join(getCoordinationDirectory(), `.pi-agent-browser-policy-${createHash("sha256").update(identity.socketContext).digest("hex")}.lock-v4`);
-}

package/dist/extensions/agent-browser/lib/browser-journal-branch.js

@@ -1,98 +0,0 @@
-import { isRecord } from "./parsing.js";
-/** An admitted branch follows native append-only identity/ancestry, never entry body snapshots. */
-class CapturedBrowserBranch {
-    manager;
-    isGenerationCurrent;
-    sessionId;
-    anchorId;
-    trackedAnchor;
-    validatedAnchor;
-    validatedLeaf;
-    constructor(manager, isGenerationCurrent) {
-        this.manager = manager;
-        this.isGenerationCurrent = isGenerationCurrent;
-        this.sessionId = manager.getSessionId();
-        this.anchorId = manager.getLeafId();
-        this.trackedAnchor = this.anchorId;
-    }
-    isCurrent() {
-        if (!this.isGenerationCurrent() || this.manager.getSessionId() !== this.sessionId) {
-            return false;
-        }
-        if (this.anchorId !== this.trackedAnchor) {
-            this.clearCache();
-            this.trackedAnchor = this.anchorId;
-        }
-        const result = this.walk();
-        // Native entries/parents are append-only. Cache only after validation to a root or cached endpoint.
-        // ponytail: behind-host ancestor mutation without native reseed/generation is outside this contract; upgrade if Pi exposes ancestry revisions.
-        if (result.current && result.selected) {
-            this.validatedAnchor = result.anchor ?? this.validatedAnchor;
-            this.validatedLeaf = result.selected;
-        }
-        return result.current;
-    }
-    clearCache() {
-        this.validatedAnchor = undefined;
-        this.validatedLeaf = undefined;
-    }
-    entry(leaf) {
-        const entry = this.manager.getEntry(leaf);
-        if (!isRecord(entry) ||
-            entry.id !== leaf ||
-            (entry.parentId !== null && typeof entry.parentId !== "string")) {
-            throw new Error("Selected Pi journal ancestry is incomplete.");
-        }
-        return { value: entry, parentId: entry.parentId };
-    }
-    cached(leaf) {
-        if (leaf === this.anchorId) {
-            return this.validatedAnchor;
-        }
-        return leaf === (isRecord(this.validatedLeaf?.entry) ? this.validatedLeaf.entry.id : undefined)
-            ? this.validatedLeaf
-            : undefined;
-    }
-    validCache(leaf, entry) {
-        const cached = this.cached(leaf);
-        if (!cached) {
-            return false;
-        }
-        // Keep indexed lookup: the native API also refreshes fork journal identity.
-        if (cached.entry === entry.value && cached.parentId === entry.parentId) {
-            return true;
-        }
-        this.clearCache();
-        return false;
-    }
-    walk() {
-        let leaf = this.manager.getLeafId();
-        // Empty selection is not a universal ancestor of independent roots.
-        let current = this.anchorId === null && leaf === null;
-        const seen = new Set();
-        let selected;
-        let anchor;
-        while (leaf !== null) {
-            if (typeof leaf !== "string" || seen.has(leaf)) {
-                throw new Error("Selected Pi journal ancestry is invalid or cyclic.");
-            }
-            seen.add(leaf);
-            const entry = this.entry(leaf);
-            selected ??= { entry: entry.value, parentId: entry.parentId };
-            if (this.validCache(leaf, entry)) {
-                current = true;
-                break;
-            }
-            if (leaf === this.anchorId) {
-                current = true;
-                anchor = { entry: entry.value, parentId: entry.parentId };
-            }
-            leaf = entry.parentId;
-        }
-        return { current, selected, anchor };
-    }
-}
-/** Capture before waiting: native branch selection precedes awaited session_tree handlers. */
-export function captureBrowserBranch(manager, isGenerationCurrent) {
-    return new CapturedBrowserBranch(manager, isGenerationCurrent);
-}

package/dist/extensions/agent-browser/lib/browser-journal-contracts.js

@@ -1 +0,0 @@
-export {};

package/dist/extensions/agent-browser/lib/browser-journal-projection.js

@@ -1,221 +0,0 @@
-import { Readable, Writable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { isRecord } from "./parsing.js";
-import { normalizeProcessError } from "./process-errors.js";
-const ENVELOPE_MAX_BYTES = 16 * 1024 * 1024;
-function matches(field, key) {
-    return field === key || (field === "*" && typeof key === "number");
-}
-function selectedPath(path, fields) {
-    return fields.some((field) => field.every((key, index) => matches(key, path[index])) ||
-        path.every((key, index) => matches(field[index], key)));
-}
-/** Own only selected JSON values; discarded token streams still receive full syntax validation. */
-class JsonProjection {
-    fields;
-    maxBytes;
-    stack = [];
-    root;
-    literal;
-    inKey = false;
-    keyText = "";
-    bytes = 0;
-    constructor(fields, maxBytes) {
-        this.fields = fields;
-        this.maxBytes = maxBytes;
-    }
-    result() {
-        return isRecord(this.root) ? this.root : undefined;
-    }
-    reserve(size) {
-        this.bytes += size;
-        if (this.bytes > this.maxBytes) {
-            throw new Error("Selected journal envelope exceeds its bounded read size.");
-        }
-    }
-    path() {
-        const frame = this.stack.at(-1);
-        return frame ? [...frame.path, frame.key ?? frame.index] : [];
-    }
-    excluded() {
-        const frame = this.stack.at(-1);
-        return frame !== undefined && frame.value === undefined;
-    }
-    frame() {
-        const frame = this.stack.at(-1);
-        if (!frame) {
-            throw new Error("Journal JSON container is missing.");
-        }
-        return frame;
-    }
-    put(value) {
-        const parent = this.stack.at(-1);
-        if (!parent) {
-            this.root = value;
-            return;
-        }
-        if (parent.value && value !== undefined) {
-            if (Array.isArray(parent.value)) {
-                parent.value[parent.index] = value;
-            }
-            else {
-                if (parent.key === undefined) {
-                    throw new Error("Journal object key is missing.");
-                }
-                Object.defineProperty(parent.value, parent.key, {
-                    value,
-                    writable: true,
-                    enumerable: true,
-                    configurable: true,
-                });
-            }
-        }
-        parent.key = undefined;
-        parent.index += 1;
-    }
-    consume(token) {
-        if (token.name === "startKey") {
-            this.inKey = true;
-            this.keyText = "";
-            return;
-        }
-        if (token.name === "endKey") {
-            this.inKey = false;
-            this.frame().key = this.keyText;
-            return;
-        }
-        if (this.inKey) {
-            this.consumeKey(token);
-            return;
-        }
-        switch (token.name) {
-            case "startObject":
-            case "startArray":
-                this.startContainer(token.name);
-                break;
-            case "endObject":
-            case "endArray": {
-                const frame = this.stack.pop();
-                if (!frame) {
-                    throw new Error("Journal JSON container is missing.");
-                }
-                this.put(frame.value);
-                break;
-            }
-            case "startString":
-            case "startNumber":
-                this.literal = {
-                    value: "",
-                    selected: !this.excluded() && selectedPath(this.path(), this.fields),
-                    number: token.name === "startNumber",
-                };
-                break;
-            case "stringChunk":
-            case "numberChunk":
-                this.consumeLiteral(token.value);
-                break;
-            case "endString":
-            case "endNumber":
-                this.endLiteral();
-                break;
-            case "trueValue":
-            case "falseValue":
-            case "nullValue":
-                this.consumeConstant(token.name);
-                break;
-            case "keyValue":
-            case "numberValue":
-            case "stringValue":
-            case "whitespace":
-                // The unpacked tokenizer emits chunk events; packed/whitespace tokens need no projection.
-                break;
-        }
-    }
-    consumeKey(token) {
-        if (token.name !== "stringChunk" || this.excluded()) {
-            return;
-        }
-        const path = this.frame().path;
-        const wholeContainer = this.fields.some((field) => field.every((key, index) => matches(key, path[index])));
-        if (wholeContainer || this.keyText.length <= 1024) {
-            if (wholeContainer) {
-                this.reserve(Buffer.byteLength(token.value));
-            }
-            this.keyText += token.value;
-        }
-    }
-    startContainer(name) {
-        if (this.stack.length >= 1024) {
-            throw new Error("Journal JSON nesting exceeds 1024 levels.");
-        }
-        // Excluded containers cannot contain a requested descendant; don't allocate their keys/paths.
-        const currentPath = this.excluded() ? [] : this.path();
-        const selected = !this.excluded() && selectedPath(currentPath, this.fields);
-        if (selected) {
-            this.reserve(32);
-        }
-        let value;
-        if (selected) {
-            value = name === "startObject" ? {} : [];
-        }
-        this.stack.push({ path: currentPath, index: 0, value });
-    }
-    consumeLiteral(value) {
-        if (this.literal?.selected === true) {
-            this.reserve(Buffer.byteLength(value));
-            this.literal.value += value;
-        }
-    }
-    endLiteral() {
-        const literal = this.literal;
-        let value;
-        if (literal?.selected === true) {
-            value = literal.number ? Number(literal.value) : literal.value;
-        }
-        this.put(value);
-        this.literal = undefined;
-    }
-    consumeConstant(name) {
-        const selected = !this.excluded() && selectedPath(this.path(), this.fields);
-        if (selected) {
-            this.reserve(8);
-        }
-        let value;
-        if (selected) {
-            value = name === "nullValue" ? null : name === "trueValue";
-        }
-        this.put(value);
-    }
-}
-/** Validate discarded values too; the parser never packs their strings or numbers. */
-export async function projectJson(
-// The native async iterator owns a mutable cursor; this reader consumes bytes without mutating them.
-// oxlint-disable-next-line typescript/prefer-readonly-parameter-types
-input, fields, maxBytes = ENVELOPE_MAX_BYTES) {
-    const { parser } = await import("stream-json/parser.js");
-    async function* decode() {
-        const decoder = new TextDecoder("utf-8", { fatal: true });
-        for await (const chunk of input) {
-            yield decoder.decode(chunk, { stream: true });
-        }
-        const tail = decoder.decode();
-        if (tail.length > 0) {
-            yield tail;
-        }
-    }
-    const projection = new JsonProjection(fields, maxBytes);
-    const sink = new Writable({
-        objectMode: true,
-        write(token, _encoding, done) {
-            try {
-                projection.consume(token);
-                done();
-            }
-            catch (error) {
-                done(normalizeProcessError(error));
-            }
-        },
-    });
-    await pipeline(Readable.from(decode()), parser.asStream({ packValues: false, streamValues: true }), sink);
-    return projection.result();
-}

package/dist/extensions/agent-browser/lib/browser-journal-reader.js

@@ -1,89 +0,0 @@
-import { projectJson } from "./browser-journal-projection.js";
-export { projectJson } from "./browser-journal-projection.js";
-const CHUNK_BYTES = 64 * 1024;
-export async function* readRange(file, range) {
-    let position = range.offset;
-    const end = range.offset + range.length;
-    while (position < end) {
-        const buffer = Buffer.allocUnsafe(Math.min(CHUNK_BYTES, end - position));
-        // The next range read depends on the bytes actually returned by this read.
-        // oxlint-disable-next-line no-await-in-loop
-        const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
-        if (bytesRead === 0) {
-            throw new Error("Journal changed or truncated during read.");
-        }
-        position += bytesRead;
-        yield buffer.subarray(0, bytesRead);
-    }
-}
-/** Byte framing, not readline: even one discarded value can exceed V8's string limit. */
-class JournalLineFramer {
-    start;
-    nonblank = false;
-    constructor(offset) {
-        this.start = offset;
-    }
-    *accept(buffer, position) {
-        for (let index = 0; index < buffer.length; index++) {
-            const byte = buffer[index];
-            if (byte === 10) {
-                if (this.nonblank) {
-                    yield { offset: this.start, length: position + index + 1 - this.start };
-                }
-                this.start = position + index + 1;
-                this.nonblank = false;
-            }
-            else if (![9, 13, 32].includes(byte)) {
-                this.nonblank = true;
-            }
-        }
-    }
-    final(end, sealed) {
-        return this.nonblank && sealed ? { offset: this.start, length: end - this.start } : undefined;
-    }
-}
-export async function* journalRanges(file, end, sealed = false, offset = 0) {
-    let position = offset;
-    const framer = new JournalLineFramer(offset);
-    while (position < end) {
-        const buffer = Buffer.allocUnsafe(Math.min(CHUNK_BYTES, end - position));
-        // Byte offsets and line framing depend on the preceding read's actual length.
-        // oxlint-disable-next-line no-await-in-loop
-        const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
-        if (bytesRead === 0) {
-            throw new Error("Journal truncated during read.");
-        }
-        yield* framer.accept(buffer.subarray(0, bytesRead), position);
-        position += bytesRead;
-    }
-    const final = framer.final(end, sealed);
-    if (final) {
-        yield final;
-    }
-}
-const STRUCTURAL_FIELDS = [
-    ["type"],
-    ["id"],
-    ["parentId"],
-    ["timestamp"],
-    ["version"],
-    ["customType"],
-    ["data", "event", "version"],
-    ["data", "snapshot", "id"],
-    ["message", "toolName"],
-    ["message", "details", "browserEventVersion"],
-    ["message", "details", "sessionName"],
-    ["message", "details", "artifactManifest", "version"],
-    ["message", "details", "electron", "action"],
-];
-export async function scanJournalMetadata(file, end, sealed = false) {
-    const entries = [];
-    for await (const range of journalRanges(file, end, sealed)) {
-        const value = await projectJson(readRange(file, range), STRUCTURAL_FIELDS);
-        if (!value) {
-            throw new Error(`Expected a journal object at byte ${range.offset}.`);
-        }
-        entries.push({ ...range, value });
-    }
-    return entries;
-}