@zewstid/zeye-capture 0.2.0

package/dist/src/transport.d.ts

@@ -0,0 +1,156 @@
+import { type CaptureActor, type CaptureCompleteness, type CapturePrivacyProfile, type CaptureRepositoryReference } from "@zewstid/zeye-shared";
+import type { DeliveryRecord, DurableOutbox } from "./types";
+type TransportRequest = (url: string, init: {
+    method: "POST";
+    headers: Record<string, string>;
+    body: string;
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+}>;
+export interface CaptureTransportConfiguration {
+    endpoint: string;
+    token: string;
+    organizationId: string;
+    captureInstallationId: string;
+    actor: CaptureActor;
+    privacy: CapturePrivacyProfile;
+    repositories?: CaptureRepositoryReference[];
+    completeness?: CaptureCompleteness[];
+}
+export interface FlushResult {
+    delivered: number;
+    failed: number;
+    deferred: number;
+}
+/**
+ * Machine credentials must never be sent to a cleartext or arbitrary collector.
+ * Local loopback HTTP is allowed only for an explicitly local development API.
+ */
+export declare function validateCaptureEndpoint(value: string): string;
+export declare function capabilityManifestForAdapter(adapter: string, transcriptContentEnabled?: boolean): {
+    provider: "claude_code" | "codex" | "github_copilot" | "cursor" | "gemini_cli" | "ironclad" | "trajectory" | "opentelemetry" | "agent_client_protocol" | "generic";
+    clientName: string;
+    clientVersion: string;
+    contractVersion: "2026-09-05";
+    completeness: {
+        dimension: "LIFECYCLE" | "MESSAGES" | "TOOLS" | "FILE_CHANGES" | "GIT" | "USAGE" | "SUBAGENT_LINEAGE" | "ARTIFACTS";
+        maximumStatus: "COMPLETE" | "PARTIAL" | "METADATA_ONLY" | "UNAVAILABLE" | "CONFLICTED";
+        limitation?: string | undefined;
+    }[];
+    manifestVersion: string;
+    transports: ("native_hook" | "local_jsonl" | "provider_api" | "otlp" | "acp" | "webhook" | "import" | "manual")[];
+    supportedEventTypes: ("session.started" | "session.resumed" | "session.forked" | "session.compacted" | "session.ended" | "message.recorded" | "tool.started" | "tool.completed" | "file.changed" | "git.observed" | "artifact.claimed" | "artifact.verified" | "usage.recorded" | "subagent.started" | "subagent.ended" | "checkpoint.recorded" | "capture.warning")[];
+    supports: {
+        rawEvidenceReference: boolean;
+        offlineOutbox: boolean;
+        idempotentReplay: boolean;
+        resume: boolean;
+        fork: boolean;
+        compaction: boolean;
+        subagents: boolean;
+        localRedaction: boolean;
+    };
+    fixtureSetVersion: string;
+};
+export declare function deliveryToBatch(record: DeliveryRecord, config: CaptureTransportConfiguration): {
+    contractVersion: "2026-09-05";
+    batchId: string;
+    sentAt: Date;
+    events: {
+        capturedAt: Date;
+        contractVersion: "2026-09-05";
+        eventId: string;
+        idempotencyKey: string;
+        eventHash: string;
+        organizationId: string;
+        captureInstallationId: string;
+        logicalSessionId: string;
+        sessionGenerationId: string;
+        sourceSession: {
+            provider: "claude_code" | "codex" | "github_copilot" | "cursor" | "gemini_cli" | "ironclad" | "trajectory" | "opentelemetry" | "agent_client_protocol" | "generic";
+            clientName: string;
+            sourceSessionId: string;
+            relationship: "ROOT" | "RESUMED_FROM" | "FORKED_FROM" | "SUBAGENT_OF" | "CONTINUATION_OF";
+            clientVersion?: string | undefined;
+            sourceGenerationId?: string | undefined;
+            relatedSourceSessionId?: string | undefined;
+        };
+        actor: {
+            kind: "HUMAN" | "SERVICE" | "AGENT" | "INSTALLATION";
+            confidence: "CONFLICTED" | "VERIFIED" | "ASSERTED" | "INFERRED" | "UNRESOLVED";
+            zeyeUserId?: string | undefined;
+            providerSubjectId?: string | undefined;
+            providerSubjectHash?: string | undefined;
+            displayName?: string | undefined;
+            resolvedAt?: Date | undefined;
+        };
+        eventType: "session.started" | "session.resumed" | "session.forked" | "session.compacted" | "session.ended" | "message.recorded" | "tool.started" | "tool.completed" | "file.changed" | "git.observed" | "artifact.claimed" | "artifact.verified" | "usage.recorded" | "subagent.started" | "subagent.ended" | "checkpoint.recorded" | "capture.warning";
+        sequence: number;
+        occurredAt: Date;
+        transport: "native_hook" | "local_jsonl" | "provider_api" | "otlp" | "acp" | "webhook" | "import" | "manual";
+        privacy: {
+            classification: "PUBLIC" | "INTERNAL" | "CONFIDENTIAL" | "RESTRICTED";
+            contentMode: "METADATA_ONLY" | "REDACTED_CONTENT" | "ENCRYPTED_RAW_REFERENCE";
+            redactionApplied: boolean;
+            retentionClass: "STANDARD" | "SHORT" | "EXTENDED" | "LEGAL_HOLD";
+            visibility: "RESTRICTED" | "ACTOR_ONLY" | "TEAM" | "PRODUCT" | "ORGANIZATION";
+            redactionPolicyVersion?: string | undefined;
+            contentConsentId?: string | undefined;
+        };
+        repositories: {
+            isPrimary: boolean;
+            repositoryId?: string | undefined;
+            providerRepositoryId?: string | undefined;
+            remoteUrlHash?: string | undefined;
+            canonicalName?: string | undefined;
+            worktreePathHash?: string | undefined;
+            branch?: string | undefined;
+            headCommitSha?: string | undefined;
+        }[];
+        completeness: {
+            dimension: "LIFECYCLE" | "MESSAGES" | "TOOLS" | "FILE_CHANGES" | "GIT" | "USAGE" | "SUBAGENT_LINEAGE" | "ARTIFACTS";
+            status: "COMPLETE" | "PARTIAL" | "METADATA_ONLY" | "UNAVAILABLE" | "CONFLICTED";
+            observedAt: Date;
+            source: "CLIENT" | "RECONCILIATION" | "IMPORT" | "ADMIN";
+            reason?: string | undefined;
+        }[];
+        payload: Record<string, unknown>;
+        payloadSchemaVersion: string;
+        boundarySnapshot?: {
+            snapshotId: string;
+            capturedAt: Date;
+            policyVersion: string;
+            productIds: string[];
+            featureIds: string[];
+            workItemIds: string[];
+            repositoryBindings: {
+                repositoryId: string;
+                pathPrefix?: string | null | undefined;
+            }[];
+        } | undefined;
+        providerEventType?: string | undefined;
+        rawEvidenceReference?: string | undefined;
+        transcript?: {
+            redactionPolicyVersion: string;
+            kind: "USER_MESSAGE" | "ASSISTANT_MESSAGE" | "SYSTEM_MESSAGE" | "TOOL_INPUT" | "TOOL_OUTPUT";
+            text: string;
+            redactionCount: number;
+            providerMessageId?: string | undefined;
+            toolName?: string | undefined;
+        } | undefined;
+    }[];
+};
+export declare class CaptureHttpTransport {
+    private readonly outbox;
+    private readonly request;
+    private readonly config;
+    constructor(outbox: DurableOutbox, config: CaptureTransportConfiguration, request?: TransportRequest);
+    flush(limit?: number): Promise<FlushResult>;
+    publishManifest(manifest: ReturnType<typeof capabilityManifestForAdapter>): Promise<void>;
+    /** Explicit liveness signal for cron/launchd/Task Scheduler sync runs. */
+    heartbeat(): Promise<void>;
+}
+export {};

package/dist/src/transport.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaptureHttpTransport = void 0;
+exports.validateCaptureEndpoint = validateCaptureEndpoint;
+exports.capabilityManifestForAdapter = capabilityManifestForAdapter;
+exports.deliveryToBatch = deliveryToBatch;
+const zeye_shared_1 = require("@zewstid/zeye-shared");
+/**
+ * Machine credentials must never be sent to a cleartext or arbitrary collector.
+ * Local loopback HTTP is allowed only for an explicitly local development API.
+ */
+function validateCaptureEndpoint(value) {
+    let endpoint;
+    try {
+        endpoint = new URL(value);
+    }
+    catch {
+        throw new Error("ZEYE_CAPTURE_ENDPOINT must be an absolute URL");
+    }
+    const loopback = endpoint.hostname === "localhost" ||
+        endpoint.hostname === "127.0.0.1" ||
+        endpoint.hostname === "[::1]" ||
+        endpoint.hostname === "::1";
+    if (endpoint.protocol !== "https:" &&
+        !(endpoint.protocol === "http:" && loopback)) {
+        throw new Error("ZEYE_CAPTURE_ENDPOINT must use HTTPS (HTTP is allowed only for loopback development)");
+    }
+    if (endpoint.username ||
+        endpoint.password ||
+        endpoint.search ||
+        endpoint.hash) {
+        throw new Error("ZEYE_CAPTURE_ENDPOINT must not contain credentials, query parameters, or a fragment");
+    }
+    endpoint.pathname = endpoint.pathname.replace(/\/+$/, "");
+    if (!endpoint.pathname.endsWith("/engineering-memory/ingest")) {
+        throw new Error("ZEYE_CAPTURE_ENDPOINT must end with /engineering-memory/ingest");
+    }
+    return endpoint.toString();
+}
+const providerByAdapter = {
+    "claude-code": "claude_code",
+    codex: "codex",
+    "vscode-copilot": "github_copilot",
+};
+const eventTypes = new Set([
+    "session.started",
+    "session.resumed",
+    "session.forked",
+    "session.compacted",
+    "session.ended",
+    "message.recorded",
+    "tool.started",
+    "tool.completed",
+    "file.changed",
+    "git.observed",
+    "artifact.claimed",
+    "artifact.verified",
+    "usage.recorded",
+    "subagent.started",
+    "subagent.ended",
+    "checkpoint.recorded",
+    "capture.warning",
+]);
+const clientNameByAdapter = {
+    "claude-code": "Claude Code",
+    codex: "Codex",
+    "vscode-copilot": "VS Code / GitHub Copilot",
+};
+const transportByAdapter = {
+    "claude-code": "native_hook",
+    codex: "local_jsonl",
+    "vscode-copilot": "manual",
+};
+// A capability manifest is an observation contract. Do not advertise event
+// types merely because the shared schema understands them: Zeye uses this to
+// distinguish unavailable evidence from a misleading zero.
+const adapterCapabilities = {
+    "claude-code": {
+        supportedEventTypes: [
+            "session.started",
+            "session.ended",
+            "session.compacted",
+            "message.recorded",
+            "tool.started",
+            "tool.completed",
+            "subagent.started",
+            "subagent.ended",
+            "capture.warning",
+        ],
+        completeness: [
+            { dimension: "LIFECYCLE", maximumStatus: "COMPLETE" },
+            { dimension: "MESSAGES", maximumStatus: "METADATA_ONLY" },
+            { dimension: "TOOLS", maximumStatus: "METADATA_ONLY" },
+            { dimension: "SUBAGENT_LINEAGE", maximumStatus: "PARTIAL" },
+            { dimension: "FILE_CHANGES", maximumStatus: "UNAVAILABLE" },
+            { dimension: "GIT", maximumStatus: "UNAVAILABLE" },
+            { dimension: "USAGE", maximumStatus: "UNAVAILABLE" },
+            { dimension: "ARTIFACTS", maximumStatus: "UNAVAILABLE" },
+        ],
+        supports: {
+            offlineOutbox: true,
+            idempotentReplay: true,
+            resume: false,
+            fork: false,
+            compaction: true,
+            subagents: true,
+            rawEvidenceReference: false,
+            localRedaction: true,
+        },
+    },
+    codex: {
+        supportedEventTypes: [
+            "session.started",
+            "session.resumed",
+            "session.forked",
+            "session.compacted",
+            "session.ended",
+            "message.recorded",
+            "tool.started",
+            "tool.completed",
+            "usage.recorded",
+            "subagent.started",
+            "subagent.ended",
+            "capture.warning",
+        ],
+        completeness: [
+            { dimension: "LIFECYCLE", maximumStatus: "COMPLETE" },
+            { dimension: "TOOLS", maximumStatus: "METADATA_ONLY" },
+            { dimension: "USAGE", maximumStatus: "PARTIAL" },
+            { dimension: "SUBAGENT_LINEAGE", maximumStatus: "PARTIAL" },
+            { dimension: "MESSAGES", maximumStatus: "UNAVAILABLE" },
+            { dimension: "FILE_CHANGES", maximumStatus: "UNAVAILABLE" },
+            { dimension: "GIT", maximumStatus: "UNAVAILABLE" },
+            { dimension: "ARTIFACTS", maximumStatus: "UNAVAILABLE" },
+        ],
+        supports: {
+            offlineOutbox: true,
+            idempotentReplay: true,
+            resume: true,
+            fork: true,
+            compaction: true,
+            subagents: true,
+            rawEvidenceReference: false,
+            localRedaction: true,
+        },
+    },
+    "vscode-copilot": {
+        supportedEventTypes: [
+            "session.started",
+            "session.resumed",
+            "session.compacted",
+            "session.ended",
+            "message.recorded",
+            "tool.started",
+            "tool.completed",
+            "file.changed",
+            "git.observed",
+            "usage.recorded",
+            "subagent.started",
+            "subagent.ended",
+            "capture.warning",
+        ],
+        completeness: [
+            { dimension: "LIFECYCLE", maximumStatus: "COMPLETE" },
+            { dimension: "MESSAGES", maximumStatus: "METADATA_ONLY" },
+            { dimension: "TOOLS", maximumStatus: "METADATA_ONLY" },
+            { dimension: "FILE_CHANGES", maximumStatus: "METADATA_ONLY" },
+            { dimension: "GIT", maximumStatus: "METADATA_ONLY" },
+            { dimension: "USAGE", maximumStatus: "PARTIAL" },
+            { dimension: "SUBAGENT_LINEAGE", maximumStatus: "PARTIAL" },
+            { dimension: "ARTIFACTS", maximumStatus: "UNAVAILABLE" },
+        ],
+        supports: {
+            offlineOutbox: true,
+            idempotentReplay: true,
+            resume: true,
+            fork: false,
+            compaction: true,
+            subagents: true,
+            rawEvidenceReference: false,
+            localRedaction: true,
+        },
+    },
+};
+function capabilityManifestForAdapter(adapter, transcriptContentEnabled = false) {
+    const provider = providerByAdapter[adapter];
+    const capability = adapterCapabilities[adapter];
+    if (!provider || !capability)
+        throw new Error(`Unsupported capture adapter: ${adapter}`);
+    return zeye_shared_1.EngineeringMemoryCaptureCapabilityManifest.parse({
+        contractVersion: zeye_shared_1.ENGINEERING_MEMORY_CAPTURE_CONTRACT_VERSION,
+        manifestVersion: "1",
+        provider,
+        // Provider releases are event-specific and may not be exposed by the
+        // host. `unknown` is an explicit truthful value, unlike a capture-package
+        // version masquerading as the provider client version.
+        clientName: clientNameByAdapter[adapter],
+        clientVersion: "unknown",
+        transports: [transportByAdapter[adapter]],
+        supportedEventTypes: capability.supportedEventTypes,
+        completeness: capability.completeness.map((entry) => transcriptContentEnabled &&
+            adapter !== "vscode-copilot" &&
+            (entry.dimension === "MESSAGES" || entry.dimension === "TOOLS")
+            ? { ...entry, maximumStatus: "COMPLETE" }
+            : entry),
+        supports: capability.supports,
+        fixtureSetVersion: "1",
+    });
+}
+function deliveryToBatch(record, config) {
+    const provider = providerByAdapter[record.adapter];
+    if (!provider)
+        throw new Error(`Unsupported capture adapter: ${record.adapter}`);
+    const eventType = eventTypes.has(record.type)
+        ? record.type
+        : "capture.warning";
+    // Terminal-only observations are legitimate when capture begins mid-session.
+    // They are evidence of a session end, but not proof that its full lifecycle
+    // was observed.
+    const terminalOnly = eventType === "session.ended" && record.sequence === 0;
+    const completeness = terminalOnly
+        ? [
+            ...(config.completeness || []).filter((entry) => entry.dimension !== "LIFECYCLE"),
+            {
+                dimension: "LIFECYCLE",
+                status: "PARTIAL",
+                reason: "Capture began after the session start.",
+                observedAt: record.createdAt,
+                source: "CLIENT",
+            },
+        ]
+        : config.completeness || [];
+    const privacy = record.transcript
+        ? config.privacy
+        : {
+            ...config.privacy,
+            contentMode: "METADATA_ONLY",
+            contentConsentId: undefined,
+        };
+    return zeye_shared_1.EngineeringMemoryCaptureBatch.parse({
+        contractVersion: zeye_shared_1.ENGINEERING_MEMORY_CAPTURE_CONTRACT_VERSION,
+        batchId: record.deliveryId,
+        sentAt: new Date().toISOString(),
+        events: [
+            {
+                contractVersion: zeye_shared_1.ENGINEERING_MEMORY_CAPTURE_CONTRACT_VERSION,
+                eventId: record.deliveryId,
+                idempotencyKey: record.sourceKey,
+                eventHash: record.payloadHash,
+                organizationId: config.organizationId,
+                captureInstallationId: config.captureInstallationId,
+                logicalSessionId: record.sessionId,
+                sessionGenerationId: record.sourceGenerationId || record.sessionId,
+                sourceSession: {
+                    provider,
+                    clientName: record.clientName || clientNameByAdapter[record.adapter],
+                    ...(record.clientVersion
+                        ? { clientVersion: record.clientVersion }
+                        : {}),
+                    sourceSessionId: record.sessionId,
+                    sourceGenerationId: record.sourceGenerationId || record.sessionId,
+                    relationship: record.relationship || "ROOT",
+                    ...(record.relatedSourceSessionId
+                        ? { relatedSourceSessionId: record.relatedSourceSessionId }
+                        : {}),
+                },
+                actor: config.actor,
+                eventType,
+                sequence: record.sequence,
+                occurredAt: record.occurredAt,
+                capturedAt: record.createdAt,
+                transport: transportByAdapter[record.adapter],
+                privacy,
+                // New durable records carry the checkout facts observed at capture time.
+                // The runtime configuration remains a compatibility fallback for records
+                // created before the context field existed.
+                repositories: record.captureRepositories ?? config.repositories ?? [],
+                completeness,
+                payload: record.payload,
+                payloadSchemaVersion: "1",
+                providerEventType: record.type,
+                ...(record.transcript ? { transcript: record.transcript } : {}),
+            },
+        ],
+    });
+}
+class CaptureHttpTransport {
+    outbox;
+    request;
+    config;
+    constructor(outbox, config, request = fetch) {
+        this.outbox = outbox;
+        this.request = request;
+        this.config = {
+            ...config,
+            endpoint: validateCaptureEndpoint(config.endpoint),
+        };
+    }
+    async flush(limit = 25) {
+        const records = await this.outbox.nextBatch(limit);
+        let delivered = 0;
+        let failed = 0;
+        let deferred = 0;
+        for (const record of records) {
+            try {
+                const batch = deliveryToBatch(record, this.config);
+                const response = await this.request(this.config.endpoint, {
+                    method: "POST",
+                    headers: {
+                        authorization: `Bearer ${this.config.token}`,
+                        "content-type": "application/json",
+                    },
+                    body: JSON.stringify(batch),
+                });
+                const body = (await response.json().catch(() => ({})));
+                if (!response.ok || !body.receiptId) {
+                    await this.outbox.markAttempt(record.deliveryId, `capture_upload_${response.status}`);
+                    if (response.status >= 400 && response.status < 500)
+                        deferred += 1;
+                    else
+                        failed += 1;
+                    continue;
+                }
+                await this.outbox.acknowledge(record.deliveryId, body.receiptId);
+                delivered += 1;
+            }
+            catch (error) {
+                await this.outbox.markAttempt(record.deliveryId, error instanceof Error
+                    ? error.message.slice(0, 200)
+                    : "capture_upload_failed");
+                failed += 1;
+            }
+        }
+        return { delivered, failed, deferred };
+    }
+    async publishManifest(manifest) {
+        const endpoint = this.config.endpoint.replace(/\/ingest$/, "/manifest");
+        if (endpoint === this.config.endpoint)
+            throw new Error("Capture endpoint must end with /ingest to publish a manifest");
+        const response = await this.request(endpoint, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.config.token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(manifest),
+        });
+        if (!response.ok)
+            throw new Error(`capture_manifest_${response.status}`);
+    }
+    /** Explicit liveness signal for cron/launchd/Task Scheduler sync runs. */
+    async heartbeat() {
+        const endpoint = this.config.endpoint.replace(/\/ingest$/, "/heartbeat");
+        if (endpoint === this.config.endpoint)
+            throw new Error("Capture endpoint must end with /ingest to publish a heartbeat");
+        const response = await this.request(endpoint, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.config.token}`,
+                "content-type": "application/json",
+            },
+            body: "{}",
+        });
+        if (!response.ok)
+            throw new Error(`capture_heartbeat_${response.status}`);
+    }
+}
+exports.CaptureHttpTransport = CaptureHttpTransport;

package/dist/src/types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Provider-neutral data accepted by the local capture boundary. Adapters must
+ * use stable sourceEventId values whenever their provider exposes them.
+ */
+export interface CaptureEvent {
+    adapter: string;
+    sessionId: string;
+    sourceEventId: string;
+    occurredAt: string;
+    type: string;
+    payload: unknown;
+    deliveryId?: string;
+    /** Provider client metadata and lineage are facts, not payload. Keeping
+     * them outside payload preserves the redaction boundary and the server's
+     * source-session identity contract. */
+    clientName?: string;
+    clientVersion?: string;
+    sourceGenerationId?: string;
+    relationship?: 'ROOT' | 'RESUMED_FROM' | 'FORKED_FROM' | 'SUBAGENT_OF' | 'CONTINUATION_OF';
+    relatedSourceSessionId?: string;
+    transcript?: {
+        kind: 'USER_MESSAGE' | 'ASSISTANT_MESSAGE' | 'SYSTEM_MESSAGE' | 'TOOL_INPUT' | 'TOOL_OUTPUT';
+        text: string;
+        providerMessageId?: string;
+        toolName?: string;
+        redactionCount?: number;
+        redactionPolicyVersion?: string;
+    };
+}
+/**
+ * Provider adapters emit only observable metadata. They must never place a
+ * prompt, agent response, shell command, file body, environment value, or
+ * credential in `payload`.
+ */
+export interface MetadataCaptureEvent extends CaptureEvent {
+    provider: 'claude_code' | 'codex' | 'github_copilot';
+    clientName: string;
+}
+export interface RedactionResult {
+    payload: unknown;
+    transcript?: CaptureEvent['transcript'];
+    redactionCount: number;
+    redactionReasons?: string[];
+}
+/**
+ * The capture boundary is deliberately injectable. Production adapters must
+ * redact before durable local storage and before any future network delivery.
+ */
+export interface RedactionBoundary {
+    redact(event: CaptureEvent): RedactionResult | Promise<RedactionResult>;
+}
+export type DeliveryStatus = 'PENDING' | 'RETRY' | 'ACKNOWLEDGED' | 'CONFLICT';
+export interface DeliveryRecord {
+    deliveryId: string;
+    sourceKey: string;
+    adapter: string;
+    sessionId: string;
+    sourceEventId: string;
+    clientName?: string;
+    clientVersion?: string;
+    sourceGenerationId?: string;
+    relationship?: 'ROOT' | 'RESUMED_FROM' | 'FORKED_FROM' | 'SUBAGENT_OF' | 'CONTINUATION_OF';
+    relatedSourceSessionId?: string;
+    transcript?: NonNullable<CaptureEvent['transcript']> & {
+        redactionCount: number;
+        redactionPolicyVersion: string;
+    };
+    type: string;
+    /** Monotonic per local session; assigned durably by the outbox. */
+    sequence: number;
+    occurredAt: string;
+    /**
+     * Repository facts observed when this delivery entered the durable outbox.
+     * They must not be rebuilt from a later checkout, branch, or enrollment
+     * environment when an offline record is replayed.
+     */
+    captureRepositories?: CaptureRepositoryReference[];
+    payload: unknown;
+    payloadHash: string;
+    redactionCount: number;
+    redactionReasons: string[];
+    status: DeliveryStatus;
+    attempts: number;
+    createdAt: string;
+    updatedAt: string;
+    lastAttemptAt?: string;
+    lastError?: string;
+    acknowledgedAt?: string;
+    receiptId?: string;
+}
+/** Immutable non-secret evidence context captured with one delivery. */
+export interface CaptureDeliveryContext {
+    repositories: CaptureRepositoryReference[];
+}
+export interface SourceCheckpoint {
+    adapter: string;
+    scope: string;
+    cursor: string;
+    updatedAt: string;
+}
+export interface CaptureOutboxState {
+    version: 1;
+    deliveries: Record<string, DeliveryRecord>;
+    checkpoints: Record<string, SourceCheckpoint>;
+}
+export type EnqueueResult = {
+    status: 'ENQUEUED';
+    record: DeliveryRecord;
+} | {
+    status: 'DUPLICATE';
+    record: DeliveryRecord;
+} | {
+    status: 'CONFLICT';
+    record: DeliveryRecord;
+};
+export interface DurableOutbox {
+    enqueue(event: CaptureEvent, context?: CaptureDeliveryContext): Promise<EnqueueResult>;
+    nextBatch(limit: number): Promise<DeliveryRecord[]>;
+    markAttempt(deliveryId: string, error?: string): Promise<DeliveryRecord>;
+    acknowledge(deliveryId: string, receiptId: string): Promise<DeliveryRecord>;
+    checkpoint(adapter: string, scope: string, cursor: string): Promise<SourceCheckpoint>;
+    getCheckpoint(adapter: string, scope: string): Promise<SourceCheckpoint | undefined>;
+    list(): Promise<DeliveryRecord[]>;
+}
+import type { CaptureRepositoryReference } from '@zewstid/zeye-shared';

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/test/fileOutbox.test.d.ts

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