@jinn-network/core 0.1.0

package/dist/corpus-read/acquire.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Per-artifact resolution chain: cache → self-store → routeResolver → origin.
+ *
+ * Always hash-verifies before persisting to cache.
+ *
+ * Spec §2.3 step 4-6.
+ */
+import { type AcquireResult } from './fetch-artifact.js';
+import type { ArtifactContent, ArtifactSource, CorpusStorePort, RouteResolver } from './types.js';
+/**
+ * Origin acquire function. Historically returned `Buffer | null`; the
+ * discriminated union lets callers distinguish not_found vs network_error.
+ * We accept either shape so test fakes that still return `Buffer | null`
+ * keep working. `privateKey` is accepted for signature compatibility with
+ * older fakes but is unused — acquisition is a free fetch now.
+ */
+type AcquireFn = (endpoint: string, sha256: string, privateKey?: string) => Promise<Buffer | null | AcquireResult>;
+type FetchFromIpfsFn = (gatewayUrl: string, cid: string) => Promise<unknown>;
+export interface AcquireArtifactArgs {
+    sha256: string;
+    artifactType: string;
+    access: {
+        endpoint: string;
+        priceUsdc: string;
+    };
+    store: CorpusStorePort;
+    selfSafeAddress: string;
+    privateKey: string;
+    routeResolver?: RouteResolver;
+    envelopeCid?: string;
+    sources?: ArtifactSource[];
+    ipfsGatewayUrl?: string;
+    /** Safe address that produced this artifact, when known (from envelope.participant). */
+    ownerSafe?: string;
+    acquireFn?: AcquireFn;
+    fetchFromIpfs?: FetchFromIpfsFn;
+}
+export declare function acquireArtifactContent(args: AcquireArtifactArgs): Promise<ArtifactContent>;
+export {};

package/dist/corpus-read/acquire.js

@@ -0,0 +1,212 @@
+/**
+ * Per-artifact resolution chain: cache → self-store → routeResolver → origin.
+ *
+ * Always hash-verifies before persisting to cache.
+ *
+ * Spec §2.3 step 4-6.
+ */
+import { createHash } from 'node:crypto';
+import { fetchArtifactContent } from './fetch-artifact.js';
+import { AcquireError, HashMismatchError } from './types.js';
+import { fetchFromIpfs as defaultFetchFromIpfs } from './ipfs.js';
+const DONATION_ARTIFACT_ENCODING = 'jinn.artifact.donation.v1';
+function sha256Hex(buf) {
+    return createHash('sha256').update(buf).digest('hex');
+}
+function decodeDonationArtifact(raw, expectedSha256) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error('donation artifact payload is not an object');
+    }
+    const record = raw;
+    if (record['schemaVersion'] !== DONATION_ARTIFACT_ENCODING || record['encoding'] !== DONATION_ARTIFACT_ENCODING) {
+        throw new Error('donation artifact payload has unexpected encoding');
+    }
+    if (record['sha256'] !== expectedSha256) {
+        throw new Error('donation artifact sha256 does not match requested artifact');
+    }
+    if (typeof record['data'] !== 'string') {
+        throw new Error('donation artifact payload is missing base64 data');
+    }
+    return Buffer.from(record['data'], 'base64');
+}
+export async function acquireArtifactContent(args) {
+    const { sha256, artifactType, access, store, selfSafeAddress, privateKey, routeResolver, envelopeCid, sources = [], ipfsGatewayUrl, ownerSafe, acquireFn = (endpoint, sha256) => fetchArtifactContent(endpoint, sha256), fetchFromIpfs = defaultFetchFromIpfs, } = args;
+    const now = () => new Date().toISOString();
+    // 1. Cache hit
+    const cached = store.getNetworkArtifact(sha256);
+    if (cached) {
+        store.touchNetworkArtifactUsage(sha256, now());
+        return {
+            sha256,
+            bytes: cached.content,
+            artifactType: cached.artifactType,
+            source: 'cache',
+            paidAmountUsdc: '0',
+            fetchedAt: cached.fetchedAt,
+            sourceOperator: cached.sourceOperator ?? undefined,
+        };
+    }
+    // 2. Public IPFS donation source.
+    const ipfsSource = sources.find((source) => source.kind === 'ipfs');
+    if (ipfsSource && ipfsGatewayUrl) {
+        try {
+            const raw = await fetchFromIpfs(ipfsGatewayUrl, ipfsSource.cid);
+            const bytes = decodeDonationArtifact(raw, sha256);
+            const actualSha = sha256Hex(bytes);
+            if (actualSha !== sha256) {
+                throw new HashMismatchError(sha256, actualSha, 'ipfs', ownerSafe);
+            }
+            const ts = now();
+            store.saveNetworkArtifact({
+                sha256,
+                artifactType,
+                envelopeCid: envelopeCid ?? null,
+                content: bytes,
+                source: 'origin',
+                sourceOperator: ownerSafe ?? null,
+                sourceEndpoint: `ipfs://${ipfsSource.cid}`,
+                paidAmountUsdc: '0',
+                fetchedAt: ts,
+            });
+            return {
+                sha256,
+                bytes,
+                artifactType,
+                source: 'ipfs',
+                paidAmountUsdc: '0',
+                fetchedAt: ts,
+                sourceOperator: ownerSafe,
+            };
+        }
+        catch (err) {
+            if (err instanceof HashMismatchError)
+                throw err;
+            // Donated IPFS is an opportunistic fast path. Gateway failures and
+            // malformed donation payloads should not block the acquisition chain;
+            // only verified byte hash mismatches remain fatal.
+        }
+    }
+    // 3. Self-store fast path
+    if (ownerSafe && ownerSafe.toLowerCase() === selfSafeAddress.toLowerCase()) {
+        const own = store.getServedArtifact(sha256);
+        if (own) {
+            // Re-verify before mirroring. If served_artifacts has been corrupted
+            // (disk error, manual edit, future migration bug, etc.) we must NOT
+            // propagate the bad bytes into network_artifacts where peers can
+            // fetch them. Throwing closes the cache-poisoning gap; the self-store
+            // path is now hash-equivalent to origin / route-resolver.
+            const actualSha = sha256Hex(own.content);
+            if (actualSha !== sha256) {
+                throw new HashMismatchError(sha256, actualSha, 'self-store', selfSafeAddress);
+            }
+            // Mirror into cache so peer asks for the same content can hit cache (provenance: self-store-mirror).
+            const ts = now();
+            store.saveNetworkArtifact({
+                sha256,
+                artifactType: own.artifactType,
+                envelopeCid: own.envelopeCid,
+                content: own.content,
+                source: 'self-store-mirror',
+                paidAmountUsdc: '0',
+                fetchedAt: ts,
+            });
+            return {
+                sha256,
+                bytes: own.content,
+                artifactType: own.artifactType,
+                source: 'self-store',
+                paidAmountUsdc: '0',
+                fetchedAt: ts,
+            };
+        }
+    }
+    // 4. Route resolver
+    if (routeResolver) {
+        try {
+            const out = await routeResolver.resolve({ sha256, access, requesterSafe: selfSafeAddress });
+            if (out) {
+                const actualSha = sha256Hex(out.bytes);
+                if (actualSha !== sha256) {
+                    throw new HashMismatchError(sha256, actualSha, 'route-resolver', out.sourceOperator);
+                }
+                const ts = now();
+                store.saveNetworkArtifact({
+                    sha256,
+                    artifactType,
+                    envelopeCid: envelopeCid ?? null,
+                    content: out.bytes,
+                    source: 'route-resolver',
+                    sourceOperator: out.sourceOperator ?? null,
+                    paidAmountUsdc: out.pricePaidUsdc,
+                    fetchedAt: ts,
+                });
+                return {
+                    sha256,
+                    bytes: out.bytes,
+                    artifactType,
+                    source: 'route-resolver',
+                    paidAmountUsdc: out.pricePaidUsdc,
+                    fetchedAt: ts,
+                    sourceOperator: out.sourceOperator,
+                };
+            }
+        }
+        catch (err) {
+            if (err instanceof HashMismatchError)
+                throw err;
+            throw new AcquireError(sha256, 'routeResolver failed', err);
+        }
+    }
+    // 5. Origin fetch
+    let bytes;
+    try {
+        const raw = await acquireFn(access.endpoint, sha256, privateKey);
+        // Accept both the legacy `Buffer | null` shape and the discriminated
+        // union from fetchArtifactContent. Buffer.isBuffer guards before we
+        // duck-type into the union.
+        if (raw === null || Buffer.isBuffer(raw)) {
+            bytes = raw;
+        }
+        else if (raw.ok === true) {
+            bytes = raw.content;
+        }
+        else {
+            // ok: false — preserve the reason so the caller / daemon route can
+            // surface it via AcquireError.cause.
+            throw new AcquireError(sha256, `origin fetch failed: ${raw.reason}${raw.message ? ` (${raw.message})` : ''}`, raw);
+        }
+    }
+    catch (err) {
+        if (err instanceof AcquireError)
+            throw err;
+        throw new AcquireError(sha256, 'origin fetch failed', err);
+    }
+    if (!bytes) {
+        throw new AcquireError(sha256, 'origin returned null (404 / not found)');
+    }
+    const actualSha = sha256Hex(bytes);
+    if (actualSha !== sha256) {
+        throw new HashMismatchError(sha256, actualSha, 'origin', ownerSafe);
+    }
+    const ts = now();
+    store.saveNetworkArtifact({
+        sha256,
+        artifactType,
+        envelopeCid: envelopeCid ?? null,
+        content: bytes,
+        source: 'origin',
+        sourceOperator: ownerSafe ?? null,
+        sourceEndpoint: access.endpoint,
+        paidAmountUsdc: access.priceUsdc,
+        fetchedAt: ts,
+    });
+    return {
+        sha256,
+        bytes,
+        artifactType,
+        source: 'origin',
+        paidAmountUsdc: access.priceUsdc,
+        fetchedAt: ts,
+        sourceOperator: ownerSafe,
+    };
+}

package/dist/corpus-read/cache.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Corpus cache helpers.
+ *
+ * The corpus library reuses the existing `network_artifacts` and `served_artifacts`
+ * tables on the daemon's `Store`. There is no separate corpus cache layer — the
+ * acquire chain in `acquire.ts` is the only writer/reader. This module exposes
+ * thin convenience helpers for higher-level code that wants to inspect or
+ * pre-populate the cache without going through `acquireArtifactContent`.
+ *
+ * Spec: spec/2026-04-30-phase-a-umbrella.md §2.4 (caching semantics).
+ */
+import type { CorpusStorePort, NetworkArtifactRow } from './types.js';
+export declare function getCachedArtifact(store: CorpusStorePort, sha256: string): NetworkArtifactRow | null;
+export declare function hasCachedArtifact(store: CorpusStorePort, sha256: string): boolean;

package/dist/corpus-read/cache.js

@@ -0,0 +1,17 @@
+/**
+ * Corpus cache helpers.
+ *
+ * The corpus library reuses the existing `network_artifacts` and `served_artifacts`
+ * tables on the daemon's `Store`. There is no separate corpus cache layer — the
+ * acquire chain in `acquire.ts` is the only writer/reader. This module exposes
+ * thin convenience helpers for higher-level code that wants to inspect or
+ * pre-populate the cache without going through `acquireArtifactContent`.
+ *
+ * Spec: spec/2026-04-30-phase-a-umbrella.md §2.4 (caching semantics).
+ */
+export function getCachedArtifact(store, sha256) {
+    return store.getNetworkArtifact(sha256);
+}
+export function hasCachedArtifact(store, sha256) {
+    return store.getNetworkArtifact(sha256) !== null;
+}

package/dist/corpus-read/capture-meta.d.ts

@@ -0,0 +1,16 @@
+export interface CaptureMetaHit {
+    manifestCid: string;
+    taskSummary: string;
+    tags: string[];
+    repositorySlug?: string;
+    synthesis?: string;
+    retrievalVisible?: boolean;
+    provenance: string;
+    verifiabilityTier: string;
+}
+export declare function queryCaptureMeta({ url, query, limit, fetchImpl, }: {
+    url: string;
+    query: string;
+    limit: number;
+    fetchImpl?: typeof fetch;
+}): Promise<CaptureMetaHit[]>;

package/dist/corpus-read/capture-meta.js

@@ -0,0 +1,18 @@
+export async function queryCaptureMeta({ url, query, limit, fetchImpl = globalThis.fetch, }) {
+    if (!url || query === '')
+        return [];
+    try {
+        const response = await fetchImpl(`${url}?q=${encodeURIComponent(query)}&limit=${limit}`);
+        if (!response.ok)
+            return [];
+        const body = (await response.json());
+        if (!Array.isArray(body))
+            return [];
+        return body.filter((hit) => hit !== null
+            && typeof hit === 'object'
+            && typeof hit.manifestCid === 'string');
+    }
+    catch {
+        return [];
+    }
+}

package/dist/corpus-read/create-corpus.d.ts

@@ -0,0 +1,2 @@
+import type { Corpus, CorpusDeps, CorpusManifest, CorpusOptions } from './types.js';
+export declare function createCorpus<TEnvelope extends CorpusManifest>(options: CorpusOptions<TEnvelope>, deps?: CorpusDeps): Corpus<TEnvelope>;

package/dist/corpus-read/create-corpus.js

@@ -0,0 +1,97 @@
+import { acquireArtifactContent } from './acquire.js';
+import { fetchManifest } from './fetch.js';
+export function createCorpus(options, deps = {}) {
+    async function query(query) {
+        let refs;
+        if (options.discovery) {
+            try {
+                refs = await options.discovery.queryEnvelopes(query);
+            }
+            catch (error) {
+                throw new Error(`corpus query failed (discovery): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else if (options.legacyQuery) {
+            try {
+                refs = await options.legacyQuery(query);
+            }
+            catch (error) {
+                throw new Error(`corpus query failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            refs = [];
+        }
+        const deduped = new Map();
+        for (const ref of refs) {
+            if (!deduped.has(ref.manifestCid))
+                deduped.set(ref.manifestCid, ref);
+        }
+        return [...deduped.values()];
+    }
+    function fetchOne(ref) {
+        return fetchManifest(ref, options.ipfsGatewayUrl, {
+            ...(deps.fetchFromIpfs ? { fetchFromIpfs: deps.fetchFromIpfs } : {}),
+            parseEnvelope: options.parseEnvelope,
+        });
+    }
+    async function acquire(manifest) {
+        const contents = new Map();
+        for (const artifact of manifest.envelope.artifacts) {
+            const content = await acquireArtifactContent({
+                sha256: artifact.sha256,
+                artifactType: artifact.artifactType,
+                access: artifact.access,
+                store: options.store,
+                selfSafeAddress: options.selfSafeAddress,
+                privateKey: options.signer.privateKey,
+                routeResolver: options.routeResolver,
+                envelopeCid: manifest.ref.manifestCid,
+                sources: artifact.sources,
+                ipfsGatewayUrl: options.ipfsGatewayUrl,
+                ownerSafe: manifest.envelope.participant.safeAddress,
+                acquireFn: deps.acquireFn,
+                fetchFromIpfs: deps.fetchFromIpfs,
+            });
+            contents.set(artifact.sha256, content);
+        }
+        return {
+            ref: manifest.ref,
+            envelope: manifest.envelope,
+            artifactContents: contents,
+        };
+    }
+    async function acquireBySha256(sha256, access, hint = {}) {
+        return acquireArtifactContent({
+            sha256,
+            artifactType: hint.artifactType ?? 'unknown',
+            access,
+            store: options.store,
+            selfSafeAddress: options.selfSafeAddress,
+            privateKey: options.signer.privateKey,
+            routeResolver: options.routeResolver,
+            envelopeCid: hint.envelopeCid,
+            sources: hint.sources,
+            ipfsGatewayUrl: options.ipfsGatewayUrl,
+            ownerSafe: hint.ownerSafe,
+            acquireFn: deps.acquireFn,
+            fetchFromIpfs: deps.fetchFromIpfs,
+        });
+    }
+    async function read(args) {
+        const refs = await query(args.query);
+        const previews = [];
+        for (const ref of refs)
+            previews.push(await fetchOne(ref));
+        const solverType = args.query.solverType;
+        const matching = solverType
+            ? previews.filter((preview) => preview.envelope.solverType === solverType)
+            : previews;
+        const selected = args.select ? args.select(matching) : matching;
+        const envelopes = [];
+        for (const preview of selected)
+            envelopes.push(await acquire(preview));
+        return envelopes;
+    }
+    return { read, query, fetchManifest: fetchOne, acquire, acquireBySha256 };
+}

package/dist/corpus-read/fetch-artifact.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Free artifact fetch — pulls remote artifact bytes over plain HTTP.
+ *
+ * Knowledge is a free, opt-in public good (tokenless-OLAS pivot): artifact
+ * acquisition is an unauthenticated GET, no payment wrapper. The server
+ * returns raw bytes; the consumer hashes them locally to verify integrity
+ * against the envelope's `artifact.sha256` field.
+ *
+ * Keys artifacts by sha256 (not IPFS CID) — artifacts no longer have IPFS
+ * CIDs (post jinn-mono-vy37.1.2).
+ */
+export type AcquireResult = {
+    ok: true;
+    content: Buffer;
+} | {
+    ok: false;
+    reason: 'not_found' | 'network_error';
+    message?: string;
+};
+export declare function buildArtifactUrl(endpoint: string, sha256: string): string;
+export declare function fetchArtifactContent(endpoint: string, sha256: string): Promise<AcquireResult>;

package/dist/corpus-read/fetch-artifact.js

@@ -0,0 +1,32 @@
+/**
+ * Free artifact fetch — pulls remote artifact bytes over plain HTTP.
+ *
+ * Knowledge is a free, opt-in public good (tokenless-OLAS pivot): artifact
+ * acquisition is an unauthenticated GET, no payment wrapper. The server
+ * returns raw bytes; the consumer hashes them locally to verify integrity
+ * against the envelope's `artifact.sha256` field.
+ *
+ * Keys artifacts by sha256 (not IPFS CID) — artifacts no longer have IPFS
+ * CIDs (post jinn-mono-vy37.1.2).
+ */
+export function buildArtifactUrl(endpoint, sha256) {
+    return `${endpoint.replace(/\/$/, '')}/v1/artifacts/${sha256}/content`;
+}
+export async function fetchArtifactContent(endpoint, sha256) {
+    const url = buildArtifactUrl(endpoint, sha256);
+    try {
+        const response = await globalThis.fetch(url);
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { ok: false, reason: 'not_found', message: `HTTP 404 for ${url}` };
+            }
+            return { ok: false, reason: 'network_error', message: `HTTP ${response.status} for ${url}` };
+        }
+        const buf = Buffer.from(await response.arrayBuffer());
+        return { ok: true, content: buf };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, reason: 'network_error', message };
+    }
+}

package/dist/corpus-read/fetch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Fetch a manifest envelope from IPFS by CID and parse it under the v1 schema.
+ *
+ * Spec §2.3 step 2.
+ */
+import type { CorpusManifest, EnvelopeRef, ManifestPreview } from './types.js';
+type FetchFromIpfs = (gatewayUrl: string, cid: string) => Promise<unknown>;
+export declare function fetchManifest<TEnvelope extends CorpusManifest>(ref: EnvelopeRef, ipfsGatewayUrl: string, ports: {
+    fetchFromIpfs?: FetchFromIpfs;
+    parseEnvelope(input: unknown): TEnvelope;
+}): Promise<ManifestPreview<TEnvelope>>;
+export {};

package/dist/corpus-read/fetch.js

@@ -0,0 +1,24 @@
+/**
+ * Fetch a manifest envelope from IPFS by CID and parse it under the v1 schema.
+ *
+ * Spec §2.3 step 2.
+ */
+import { fetchFromIpfs } from './ipfs.js';
+import { ManifestFetchError } from './types.js';
+export async function fetchManifest(ref, ipfsGatewayUrl, ports) {
+    let raw;
+    try {
+        raw = await (ports.fetchFromIpfs ?? fetchFromIpfs)(ipfsGatewayUrl, ref.manifestCid);
+    }
+    catch (err) {
+        throw new ManifestFetchError(ref.manifestCid, 'IPFS fetch failed', err);
+    }
+    let envelope;
+    try {
+        envelope = ports.parseEnvelope(raw);
+    }
+    catch (error) {
+        throw new ManifestFetchError(ref.manifestCid, `schema parse failed: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+    return { ref, envelope };
+}

package/dist/corpus-read/http-discovery.d.ts

@@ -0,0 +1,9 @@
+import type { CorpusDiscoveryPort } from './types.js';
+export interface HttpCorpusDiscoveryOptions {
+    url: string;
+    fetchImpl?: typeof fetch;
+    retryDelaysMs?: readonly number[];
+    fetchTimeoutMs?: number;
+    readyProbeTtlMs?: number;
+}
+export declare function createHttpCorpusDiscovery(options: HttpCorpusDiscoveryOptions): CorpusDiscoveryPort;

package/dist/corpus-read/http-discovery.js

@@ -0,0 +1,128 @@
+import { DiscoveryUnavailableError } from './types.js';
+const QUERY_ENVELOPES = `
+query QueryEnvelopes($where: envelopeFilter, $limit: Int!) {
+  envelopes(
+    where: $where,
+    limit: $limit,
+    orderBy: "publishedAtBlock",
+    orderDirection: "desc"
+  ) {
+    items {
+      agentId
+      manifestCid
+      manifestHash
+      evidenceTier
+      publishedAtBlock
+    }
+  }
+}
+`;
+const DEFAULT_RETRY_DELAYS_MS = [200, 500];
+const DEFAULT_TIMEOUT_MS = 15_000;
+const DEFAULT_READY_TTL_MS = 20_000;
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function createHttpCorpusDiscovery(options) {
+    const gqlUrl = options.url.endsWith('/graphql')
+        ? options.url
+        : `${options.url.replace(/\/$/, '')}/graphql`;
+    const readyUrl = `${options.url.replace(/\/graphql\/?$/, '').replace(/\/$/, '')}/ready`;
+    const baseFetch = options.fetchImpl ?? globalThis.fetch;
+    const retryDelays = options.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+    const timeoutMs = options.fetchTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const readyTtlMs = options.readyProbeTtlMs ?? DEFAULT_READY_TTL_MS;
+    let readyCache;
+    async function request(input, init) {
+        let lastError;
+        for (let attempt = 0; attempt <= retryDelays.length; attempt += 1) {
+            try {
+                const response = await baseFetch(input, {
+                    ...init,
+                    signal: init.signal ?? AbortSignal.timeout(timeoutMs),
+                });
+                if ((response.status === 502 || response.status === 503)
+                    && attempt < retryDelays.length) {
+                    await wait(retryDelays[attempt]);
+                    continue;
+                }
+                return response;
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= retryDelays.length)
+                    break;
+                await wait(retryDelays[attempt]);
+            }
+        }
+        throw new DiscoveryUnavailableError(`Ponder GraphQL network error: ${String(lastError)}`, lastError);
+    }
+    async function ensureReady() {
+        const now = Date.now();
+        if (readyCache && now - readyCache.checkedAt < readyTtlMs) {
+            if (!readyCache.ok) {
+                throw new DiscoveryUnavailableError(`indexer not ready: ${readyCache.status}`);
+            }
+            return;
+        }
+        let response;
+        try {
+            response = await request(readyUrl, { method: 'GET' });
+        }
+        catch (error) {
+            readyCache = { checkedAt: now, ok: false, status: 0 };
+            const cause = error instanceof DiscoveryUnavailableError
+                ? (error.cause ?? error)
+                : error;
+            throw new DiscoveryUnavailableError(`indexer /ready probe failed: ${String(cause)}`, cause);
+        }
+        readyCache = { checkedAt: now, ok: response.ok, status: response.status };
+        if (!response.ok) {
+            throw new DiscoveryUnavailableError(`indexer not ready: ${response.status}`);
+        }
+    }
+    return {
+        async queryEnvelopes(query) {
+            await ensureReady();
+            const where = {};
+            if (query.evidenceTier)
+                where['evidenceTier'] = query.evidenceTier;
+            if (query.manifestHash)
+                where['manifestHash'] = query.manifestHash;
+            const response = await request(gqlUrl, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    query: QUERY_ENVELOPES,
+                    variables: {
+                        where,
+                        limit: Math.min(500, Math.max(1, query.limit ?? 50)),
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new DiscoveryUnavailableError(`Ponder GraphQL HTTP ${response.status} ${response.statusText}`);
+            }
+            let body;
+            try {
+                body = await response.json();
+            }
+            catch (error) {
+                throw new DiscoveryUnavailableError(`Ponder GraphQL response parse error: ${String(error)}`, error);
+            }
+            if (body.errors?.length) {
+                throw new DiscoveryUnavailableError(`Ponder GraphQL error: ${body.errors.map((error) => error.message ?? 'unknown').join('; ')}`);
+            }
+            if (!body.data) {
+                throw new DiscoveryUnavailableError('Ponder GraphQL response missing data field');
+            }
+            return (body.data.envelopes?.items ?? []).map((row) => ({
+                manifestCid: row.manifestCid,
+                manifestHash: row.manifestHash,
+                operator: { agentId: row.agentId, safeAddress: '' },
+                evidenceTier: row.evidenceTier ?? 'unknown',
+                publishedAt: Number(row.publishedAtBlock),
+            }));
+        },
+    };
+}

package/dist/corpus-read/index.d.ts

@@ -0,0 +1,10 @@
+export * from './acquire.js';
+export * from './cache.js';
+export * from './capture-meta.js';
+export * from './create-corpus.js';
+export * from './fetch-artifact.js';
+export * from './fetch.js';
+export * from './http-discovery.js';
+export * from './ipfs.js';
+export * from './route-resolver.js';
+export * from './types.js';

package/dist/corpus-read/index.js

@@ -0,0 +1,10 @@
+export * from './acquire.js';
+export * from './cache.js';
+export * from './capture-meta.js';
+export * from './create-corpus.js';
+export * from './fetch-artifact.js';
+export * from './fetch.js';
+export * from './http-discovery.js';
+export * from './ipfs.js';
+export * from './route-resolver.js';
+export * from './types.js';