opencode-ext-connector 0.3.0

package/dist/providers/cursor/proto/unknown-field.js

@@ -0,0 +1,22 @@
+import { concatBytes } from "../proto-wire";
+import { CursorProtocolError } from "./errors";
+function encodeVarint(value) {
+    const output = [];
+    let remaining = value >>> 0;
+    while (remaining > 0x7f) {
+        output.push((remaining & 0x7f) | 0x80);
+        remaining >>>= 7;
+    }
+    output.push(remaining);
+    return Uint8Array.from(output);
+}
+export function encodeUnknownField(field, wire, bytes) {
+    const tag = encodeVarint((field << 3) | wire);
+    if (wire === 2) {
+        return concatBytes([tag, encodeVarint(bytes.length), bytes]);
+    }
+    if (wire === 0 || wire === 1 || wire === 5) {
+        return concatBytes([tag, bytes]);
+    }
+    throw new CursorProtocolError("wrong-wire", "protobuf field", `unsupported wire type ${wire}`);
+}

package/dist/providers/cursor/proto-value.d.ts

@@ -0,0 +1,3 @@
+export declare function decodeProtobufValue(bytes: Uint8Array): unknown;
+export declare function encodeProtobufValue(value: unknown): Uint8Array;
+export declare function decodeProtobufValueStrict(bytes: Uint8Array): unknown;

package/dist/providers/cursor/proto-value.js

@@ -0,0 +1,170 @@
+// Derived from Rahularya01/pi-cursor protobuf Value handling. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { CursorProtocolDriftError, CursorProtocolError } from "./proto/errors";
+import { assertKnownFields, repeatedFields, requiredField, requiredString } from "./proto/fields";
+import { concatBytes, decodeFields, decodeFieldsStrict, decodeUtf8, decodeUtf8Strict, decodeVarintNumber, decodeVarintNumberStrict, encodeBoolField, encodeBytesField, encodeDoubleField, encodeStringField, } from "./proto-wire";
+function encodeStruct(value) {
+    const entries = [];
+    for (const key of Object.keys(value)) {
+        entries.push(encodeBytesField(1, concatBytes([
+            encodeStringField(1, key),
+            encodeBytesField(2, encodeProtobufValue(value[key])),
+        ])));
+    }
+    return concatBytes(entries);
+}
+function decodeStruct(bytes) {
+    const result = {};
+    for (const entry of decodeFields(bytes)) {
+        if (entry.field !== 1) {
+            continue;
+        }
+        const fields = decodeFields(entry.bytes);
+        let key = "";
+        let value = null;
+        for (const inner of fields) {
+            if (inner.field === 1) {
+                key = decodeUtf8(inner.bytes);
+            }
+            if (inner.field === 2) {
+                value = decodeProtobufValue(inner.bytes);
+            }
+        }
+        if (key.length > 0) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export function decodeProtobufValue(bytes) {
+    const [entry] = decodeFields(bytes);
+    if (entry === undefined) {
+        return null;
+    }
+    switch (entry.field) {
+        case 1:
+            return null;
+        case 2:
+            if (entry.bytes.length < 8) {
+                return 0;
+            }
+            return new DataView(entry.bytes.buffer, entry.bytes.byteOffset, 8).getFloat64(0, true);
+        case 3:
+            return decodeUtf8(entry.bytes);
+        case 4:
+            return decodeVarintNumber(entry.bytes) !== 0;
+        case 5:
+            return decodeStruct(entry.bytes);
+        case 6: {
+            const values = [];
+            for (const item of decodeFields(entry.bytes)) {
+                if (item.field === 1) {
+                    values.push(decodeProtobufValue(item.bytes));
+                }
+            }
+            return values;
+        }
+        default:
+            return null;
+    }
+}
+export function encodeProtobufValue(value) {
+    if (value === null || value === undefined) {
+        return encodeBoolField(1, false);
+    }
+    if (typeof value === "number") {
+        return encodeDoubleField(2, value);
+    }
+    if (typeof value === "string") {
+        return encodeStringField(3, value);
+    }
+    if (typeof value === "boolean") {
+        return encodeBoolField(4, value);
+    }
+    if (Array.isArray(value)) {
+        return encodeBytesField(6, concatBytes(value.map((item) => encodeBytesField(1, encodeProtobufValue(item)))));
+    }
+    if (typeof value === "object") {
+        const record = {};
+        for (const key of Object.keys(value)) {
+            record[key] = Reflect.get(value, key);
+        }
+        return encodeBytesField(5, encodeStruct(record));
+    }
+    return encodeStringField(3, String(value));
+}
+function decodeStructStrict(bytes) {
+    const context = "google.protobuf.Struct";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1], context);
+    const result = {};
+    for (const entry of repeatedFields(fields, { context, field: 1, wire: 2 })) {
+        const entryContext = "google.protobuf.Struct.FieldsEntry";
+        const mapFields = decodeFieldsStrict(entry.bytes, { context: entryContext });
+        assertKnownFields(mapFields, [1, 2], entryContext);
+        const key = requiredString(mapFields, { context: entryContext, field: 1, wire: 2 });
+        const value = requiredField(mapFields, { context: entryContext, field: 2, wire: 2 });
+        if (Object.hasOwn(result, key)) {
+            throw new CursorProtocolError("malformed", entryContext, `duplicate key ${key}`);
+        }
+        result[key] = decodeProtobufValueStrict(value.bytes);
+    }
+    return result;
+}
+function decodeListStrict(bytes) {
+    const context = "google.protobuf.ListValue";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1], context);
+    return repeatedFields(fields, { context, field: 1, wire: 2 }).map((entry) => decodeProtobufValueStrict(entry.bytes));
+}
+export function decodeProtobufValueStrict(bytes) {
+    const context = "google.protobuf.Value";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5, 6], context);
+    if (fields.length !== 1) {
+        throw new CursorProtocolError("malformed", context, `expected one variant, received ${fields.length}`);
+    }
+    const entry = fields.at(0);
+    if (entry === undefined) {
+        throw new CursorProtocolError("malformed", context, "Value variant is absent");
+    }
+    switch (entry.field) {
+        case 1: {
+            if (entry.wire !== 0 || decodeVarintNumberStrict(entry.bytes, context) !== 0) {
+                throw new CursorProtocolError("malformed", context, "invalid null variant");
+            }
+            return null;
+        }
+        case 2: {
+            if (entry.wire !== 1 || entry.bytes.length !== 8) {
+                throw new CursorProtocolError("wrong-wire", context, "invalid number variant");
+            }
+            const value = new DataView(entry.bytes.buffer, entry.bytes.byteOffset, 8).getFloat64(0, true);
+            if (!Number.isFinite(value)) {
+                throw new CursorProtocolError("malformed", context, "number is not finite");
+            }
+            return value;
+        }
+        case 3:
+            if (entry.wire !== 2) {
+                throw new CursorProtocolError("wrong-wire", context, "invalid string variant");
+            }
+            return decodeUtf8Strict(entry.bytes, context);
+        case 4: {
+            if (entry.wire !== 0) {
+                throw new CursorProtocolError("wrong-wire", context, "invalid boolean variant");
+            }
+            const value = decodeVarintNumberStrict(entry.bytes, context);
+            if (value !== 0 && value !== 1) {
+                throw new CursorProtocolError("malformed", context, "invalid boolean value");
+            }
+            return value === 1;
+        }
+        case 5:
+            return decodeStructStrict(entry.bytes);
+        case 6:
+            return decodeListStrict(entry.bytes);
+        default:
+            throw new CursorProtocolDriftError(context, entry.field, "unsupported Value variant");
+    }
+}

package/dist/providers/cursor/proto-wire.d.ts

@@ -0,0 +1,22 @@
+export declare const MAX_PROTO_MESSAGE_BYTES: number;
+export type ProtoField = {
+    readonly field: number;
+    readonly wire: number;
+    readonly bytes: Uint8Array;
+};
+export type ProtoDecodeOptions = {
+    readonly context?: string;
+    readonly maxBytes?: number;
+};
+export declare function concatBytes(parts: readonly Uint8Array[]): Uint8Array;
+export declare function encodeBytesField(field: number, value: Uint8Array): Uint8Array;
+export declare function encodeBoolField(field: number, value: boolean): Uint8Array;
+export declare function encodeInt32Field(field: number, value: number): Uint8Array;
+export declare function encodeDoubleField(field: number, value: number): Uint8Array;
+export declare function encodeStringField(field: number, value: string): Uint8Array;
+export declare function decodeUtf8(bytes: Uint8Array): string;
+export declare function decodeVarintNumber(bytes: Uint8Array): number;
+export declare function decodeFields(buffer: Uint8Array): readonly ProtoField[];
+export declare function decodeUtf8Strict(bytes: Uint8Array, context?: string): string;
+export declare function decodeVarintNumberStrict(bytes: Uint8Array, context?: string): number;
+export declare function decodeFieldsStrict(buffer: Uint8Array, options?: ProtoDecodeOptions): readonly ProtoField[];

package/dist/providers/cursor/proto-wire.js

@@ -0,0 +1,224 @@
+import { CursorProtocolError } from "./proto/errors";
+export const MAX_PROTO_MESSAGE_BYTES = 64 * 1024 * 1024;
+function encodeVarint(value) {
+    const out = [];
+    let remaining = value >>> 0;
+    while (remaining > 0x7f) {
+        out.push((remaining & 0x7f) | 0x80);
+        remaining >>>= 7;
+    }
+    out.push(remaining);
+    return Uint8Array.from(out);
+}
+function decodeVarint(buffer, offset) {
+    let value = 0;
+    let shift = 0;
+    let index = offset;
+    while (index < buffer.length) {
+        const byte = buffer[index];
+        if (byte === undefined) {
+            return null;
+        }
+        index += 1;
+        value |= (byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+            return { value, next: index };
+        }
+        shift += 7;
+        if (shift > 35) {
+            return null;
+        }
+    }
+    return null;
+}
+export function concatBytes(parts) {
+    let length = 0;
+    for (const part of parts) {
+        length += part.length;
+    }
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+export function encodeBytesField(field, value) {
+    return concatBytes([encodeVarint((field << 3) | 2), encodeVarint(value.length), value]);
+}
+export function encodeBoolField(field, value) {
+    return concatBytes([encodeVarint((field << 3) | 0), encodeVarint(value ? 1 : 0)]);
+}
+export function encodeInt32Field(field, value) {
+    return concatBytes([encodeVarint((field << 3) | 0), encodeVarint(value >>> 0)]);
+}
+export function encodeDoubleField(field, value) {
+    const raw = new Uint8Array(8);
+    new DataView(raw.buffer).setFloat64(0, value, true);
+    return concatBytes([encodeVarint((field << 3) | 1), raw]);
+}
+export function encodeStringField(field, value) {
+    return encodeBytesField(field, new TextEncoder().encode(value));
+}
+export function decodeUtf8(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+export function decodeVarintNumber(bytes) {
+    const decoded = decodeVarint(bytes, 0);
+    return decoded === null ? 0 : decoded.value;
+}
+export function decodeFields(buffer) {
+    const fields = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+        const tag = decodeVarint(buffer, offset);
+        if (tag === null) {
+            break;
+        }
+        const field = tag.value >>> 3;
+        const wire = tag.value & 7;
+        offset = tag.next;
+        if (wire === 0) {
+            const varint = decodeVarint(buffer, offset);
+            if (varint === null) {
+                break;
+            }
+            fields.push({ field, wire, bytes: buffer.subarray(tag.next, varint.next) });
+            offset = varint.next;
+            continue;
+        }
+        if (wire === 1) {
+            const end = offset + 8;
+            if (end > buffer.length) {
+                break;
+            }
+            fields.push({ field, wire, bytes: buffer.subarray(offset, end) });
+            offset = end;
+            continue;
+        }
+        if (wire === 2) {
+            const length = decodeVarint(buffer, offset);
+            if (length === null) {
+                break;
+            }
+            const start = length.next;
+            const end = start + length.value;
+            if (end > buffer.length) {
+                break;
+            }
+            fields.push({ field, wire, bytes: buffer.subarray(start, end) });
+            offset = end;
+            continue;
+        }
+        break;
+    }
+    return fields;
+}
+function decodeRawVarintStrict(buffer, offset, context) {
+    for (let index = offset; index < offset + 10; index += 1) {
+        const byte = buffer[index];
+        if (byte === undefined) {
+            throw new CursorProtocolError("truncated", context, "incomplete varint");
+        }
+        if (index === offset + 9 && byte > 1) {
+            throw new CursorProtocolError("malformed", context, "uint64 varint overflow");
+        }
+        if ((byte & 0x80) === 0) {
+            return { next: index + 1, raw: buffer.subarray(offset, index + 1) };
+        }
+    }
+    throw new CursorProtocolError("malformed", context, "varint exceeds ten bytes");
+}
+function decodeVarintStrict(buffer, offset, context) {
+    const decoded = decodeRawVarintStrict(buffer, offset, context);
+    if (decoded.raw.length > 5 || (decoded.raw.length === 5 && (decoded.raw[4] ?? 0) > 0x0f)) {
+        throw new CursorProtocolError("malformed", context, "uint32 varint overflow");
+    }
+    let value = 0;
+    let factor = 1;
+    for (const byte of decoded.raw) {
+        value += (byte & 0x7f) * factor;
+        factor *= 0x80;
+    }
+    return { value, next: decoded.next };
+}
+function fixedFieldEnd(offset, width, length, context) {
+    const end = offset + width;
+    if (end > length) {
+        throw new CursorProtocolError("truncated", context, `fixed${width * 8} field is incomplete`);
+    }
+    return end;
+}
+export function decodeUtf8Strict(bytes, context = "protobuf string") {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            throw new CursorProtocolError("malformed", context, "invalid UTF-8");
+        }
+        throw error;
+    }
+}
+export function decodeVarintNumberStrict(bytes, context = "protobuf uint32") {
+    const decoded = decodeVarintStrict(bytes, 0, context);
+    if (decoded.next !== bytes.length) {
+        throw new CursorProtocolError("malformed", context, "varint has trailing bytes");
+    }
+    return decoded.value;
+}
+export function decodeFieldsStrict(buffer, options = {}) {
+    const context = options.context ?? "protobuf message";
+    const maxBytes = options.maxBytes ?? MAX_PROTO_MESSAGE_BYTES;
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) {
+        throw new CursorProtocolError("malformed", context, "invalid message size bound");
+    }
+    if (buffer.length > maxBytes) {
+        throw new CursorProtocolError("oversized", context, `message exceeds ${maxBytes} bytes`);
+    }
+    const fields = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+        const tag = decodeVarintStrict(buffer, offset, `${context} tag`);
+        const field = Math.floor(tag.value / 8);
+        const wire = tag.value % 8;
+        if (field === 0) {
+            throw new CursorProtocolError("malformed", context, "field number zero");
+        }
+        offset = tag.next;
+        switch (wire) {
+            case 0: {
+                const value = decodeRawVarintStrict(buffer, offset, `${context} field ${field}`);
+                fields.push({ field, wire, bytes: buffer.subarray(offset, value.next) });
+                offset = value.next;
+                break;
+            }
+            case 1: {
+                const end = fixedFieldEnd(offset, 8, buffer.length, `${context} field ${field}`);
+                fields.push({ field, wire, bytes: buffer.subarray(offset, end) });
+                offset = end;
+                break;
+            }
+            case 2: {
+                const length = decodeVarintStrict(buffer, offset, `${context} field ${field} length`);
+                const end = length.next + length.value;
+                if (end > buffer.length) {
+                    throw new CursorProtocolError("truncated", context, `field ${field} payload is incomplete`);
+                }
+                fields.push({ field, wire, bytes: buffer.subarray(length.next, end) });
+                offset = end;
+                break;
+            }
+            case 5: {
+                const end = fixedFieldEnd(offset, 4, buffer.length, `${context} field ${field}`);
+                fields.push({ field, wire, bytes: buffer.subarray(offset, end) });
+                offset = end;
+                break;
+            }
+            default:
+                throw new CursorProtocolError("wrong-wire", context, `unsupported wire type ${wire}`);
+        }
+    }
+    return fields;
+}

package/dist/providers/cursor/protocol-failure.d.ts

@@ -0,0 +1,18 @@
+import { CursorProtocolError } from "./proto/errors";
+export type CursorProtocolFailureStage = "connect-frame" | "server-dispatch";
+export type CursorProtocolDiagnosticContext = "AgentServerMessage" | "Connect end-stream" | "Connect stream" | "HeartbeatUpdate" | "InteractionUpdate" | "TextDeltaUpdate" | "ThinkingDeltaUpdate" | "TokenDeltaUpdate" | "TurnEndedUpdate" | "other";
+export type CursorProtocolFailureProjection = {
+    readonly context: CursorProtocolDiagnosticContext;
+    readonly reason: CursorProtocolError["reason"];
+    readonly stage: CursorProtocolFailureStage;
+};
+export declare class CursorProtocolFailure extends Error {
+    readonly stage: CursorProtocolFailureStage;
+    readonly name = "CursorProtocolFailure";
+    readonly code = "CURSOR_PROTOCOL_FAILURE";
+    constructor(error: CursorProtocolError, stage: CursorProtocolFailureStage);
+    readonly reason: CursorProtocolError["reason"];
+    readonly context: string;
+}
+export declare function annotateCursorProtocolFailure(error: unknown, stage: CursorProtocolFailureStage): never;
+export declare function projectCursorProtocolFailure(error: unknown): CursorProtocolFailureProjection | null;

package/dist/providers/cursor/protocol-failure.js

@@ -0,0 +1,45 @@
+import { CursorProtocolError } from "./proto/errors";
+function diagnosticContext(context) {
+    switch (context) {
+        case "AgentServerMessage":
+        case "Connect end-stream":
+        case "Connect stream":
+        case "HeartbeatUpdate":
+        case "InteractionUpdate":
+        case "TextDeltaUpdate":
+        case "ThinkingDeltaUpdate":
+        case "TokenDeltaUpdate":
+        case "TurnEndedUpdate":
+            return context;
+        default:
+            return "other";
+    }
+}
+export class CursorProtocolFailure extends Error {
+    stage;
+    name = "CursorProtocolFailure";
+    code = "CURSOR_PROTOCOL_FAILURE";
+    constructor(error, stage) {
+        super(error.message, { cause: error });
+        this.stage = stage;
+        this.context = error.context;
+        this.reason = error.reason;
+    }
+    reason;
+    context;
+}
+export function annotateCursorProtocolFailure(error, stage) {
+    if (error instanceof CursorProtocolError) {
+        throw new CursorProtocolFailure(error, stage);
+    }
+    throw error;
+}
+export function projectCursorProtocolFailure(error) {
+    if (!(error instanceof CursorProtocolFailure))
+        return null;
+    return {
+        context: diagnosticContext(error.context),
+        reason: error.reason,
+        stage: error.stage,
+    };
+}

package/dist/providers/cursor/recovery.d.ts

@@ -0,0 +1,48 @@
+import type { Clock } from "../../core/clock";
+import { type CursorProtocolFailureProjection } from "./protocol-failure";
+export type CursorRecoveryAttemptMode = "initial" | "checkpoint" | "history";
+export type CursorReplayState = {
+    readonly outputEpoch: number;
+    readonly checkpointEpoch: number | null;
+    readonly toolBoundary: boolean;
+};
+export type CursorRecoveryDecision = {
+    readonly kind: "retry";
+    readonly mode: "checkpoint" | "history";
+} | {
+    readonly kind: "fail";
+    readonly reason: "exhausted" | "replay-unsafe" | "non-retryable";
+};
+export declare class CursorRecoveryError extends Error {
+    readonly reason: "idle" | "exhausted" | "replay-unsafe" | "non-retryable";
+    readonly attemptedModes: readonly CursorRecoveryAttemptMode[];
+    readonly retryable: boolean;
+    readonly cause: unknown;
+    readonly name = "CursorRecoveryError";
+    readonly code = "CURSOR_RECOVERY_ERROR";
+    readonly protocolFailure: CursorProtocolFailureProjection | null;
+    constructor(reason: "idle" | "exhausted" | "replay-unsafe" | "non-retryable", attemptedModes: readonly CursorRecoveryAttemptMode[], retryable: boolean, cause?: unknown);
+}
+export type CursorRecoveryPlanner = {
+    readonly next: (input: {
+        readonly checkpointAvailable: boolean;
+        readonly replay: CursorReplayState;
+        readonly retryable: boolean;
+    }) => CursorRecoveryDecision;
+    readonly requireRetry: (decision: CursorRecoveryDecision, cause: unknown) => "checkpoint" | "history";
+    readonly attemptedModes: () => readonly CursorRecoveryAttemptMode[];
+};
+export declare function createCursorRecoveryPlanner(): CursorRecoveryPlanner;
+export type CursorIdleWatchdog = {
+    readonly signal: AbortSignal;
+    readonly expired: () => boolean;
+    readonly progress: () => void;
+    readonly heartbeat: () => void;
+    readonly park: () => void;
+    readonly dispose: () => void;
+};
+export declare function createCursorIdleWatchdog(options: {
+    readonly clock: Clock;
+    readonly idleTimeoutMs?: number;
+    readonly parentSignal: AbortSignal;
+}): CursorIdleWatchdog;

package/dist/providers/cursor/recovery.js

@@ -0,0 +1,102 @@
+import { InvalidArgumentError, OperationCancelledError } from "../../core/errors";
+import { projectCursorProtocolFailure, } from "./protocol-failure";
+export class CursorRecoveryError extends Error {
+    reason;
+    attemptedModes;
+    retryable;
+    cause;
+    name = "CursorRecoveryError";
+    code = "CURSOR_RECOVERY_ERROR";
+    protocolFailure;
+    constructor(reason, attemptedModes, retryable, cause = null) {
+        super(`Cursor recovery failed: ${reason}`, { cause });
+        this.reason = reason;
+        this.attemptedModes = attemptedModes;
+        this.retryable = retryable;
+        this.cause = cause;
+        this.protocolFailure = projectCursorProtocolFailure(cause);
+    }
+}
+export function createCursorRecoveryPlanner() {
+    const attempted = ["initial"];
+    let checkpointTried = false;
+    let historyTried = false;
+    const next = (input) => {
+        if (!input.retryable || input.replay.toolBoundary) {
+            return { kind: "fail", reason: "non-retryable" };
+        }
+        const checkpointCoversOutput = input.replay.checkpointEpoch !== null &&
+            input.replay.checkpointEpoch === input.replay.outputEpoch;
+        if (!checkpointTried && input.checkpointAvailable && checkpointCoversOutput) {
+            checkpointTried = true;
+            attempted.push("checkpoint");
+            return { kind: "retry", mode: "checkpoint" };
+        }
+        if (input.replay.outputEpoch > 0) {
+            return { kind: "fail", reason: "replay-unsafe" };
+        }
+        if (!historyTried) {
+            historyTried = true;
+            attempted.push("history");
+            return { kind: "retry", mode: "history" };
+        }
+        return { kind: "fail", reason: "exhausted" };
+    };
+    return {
+        next,
+        requireRetry: (decision, cause) => {
+            if (decision.kind === "retry")
+                return decision.mode;
+            throw new CursorRecoveryError(decision.reason, [...attempted], decision.reason === "exhausted", cause);
+        },
+        attemptedModes: () => [...attempted],
+    };
+}
+export function createCursorIdleWatchdog(options) {
+    const idleTimeoutMs = options.idleTimeoutMs ?? 60_000;
+    if (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < 0) {
+        throw new InvalidArgumentError("idleTimeoutMs");
+    }
+    const controller = new AbortController();
+    let timer = null;
+    let disposed = false;
+    const cancelTimer = () => {
+        timer?.cancel();
+        timer = null;
+    };
+    const expire = () => {
+        timer = null;
+        if (!controller.signal.aborted) {
+            controller.abort(new CursorRecoveryError("idle", ["initial"], true));
+        }
+    };
+    const arm = () => {
+        cancelTimer();
+        if (!disposed && !controller.signal.aborted) {
+            timer = options.clock.schedule(idleTimeoutMs, expire);
+        }
+    };
+    const onParentAbort = () => {
+        cancelTimer();
+        if (!controller.signal.aborted) {
+            controller.abort(new OperationCancelledError("cursor-direct-stream"));
+        }
+    };
+    options.parentSignal.addEventListener("abort", onParentAbort, { once: true });
+    if (options.parentSignal.aborted)
+        onParentAbort();
+    else
+        arm();
+    return {
+        signal: controller.signal,
+        expired: () => controller.signal.aborted && controller.signal.reason instanceof CursorRecoveryError,
+        progress: arm,
+        heartbeat: () => undefined,
+        park: cancelTimer,
+        dispose: () => {
+            disposed = true;
+            cancelTimer();
+            options.parentSignal.removeEventListener("abort", onParentAbort);
+        },
+    };
+}

package/dist/providers/cursor/request-blob-ownership.d.ts

@@ -0,0 +1,15 @@
+import type { CursorBlobId, CursorBlobStore } from "./blob-store";
+export type CursorRequestBlobOwnership = {
+    readonly blobIds: readonly CursorBlobId[];
+    readonly release: () => void;
+    readonly [Symbol.dispose]: () => void;
+};
+export type CursorRequestBlobCollector = {
+    readonly acquire: (blobId: CursorBlobId) => void;
+    readonly finish: () => CursorRequestBlobOwnership;
+    readonly rollback: () => void;
+};
+export declare class CursorRequestBlobOwnershipError extends Error {
+    constructor();
+}
+export declare function createCursorRequestBlobCollector(store: CursorBlobStore): CursorRequestBlobCollector;