@rakelabs/evidence-publisher 0.1.0

package/dist/src/MetaEvidencePublisher.js

@@ -0,0 +1,104 @@
+import { MetaEvidenceJsonBuilder } from './MetaEvidenceJsonBuilder.js';
+import { HttpPinByCidClient } from './http/HttpPinByCidClient.js';
+export class MetaEvidencePublisher {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Publish a MetaEvidence document.
+     *
+     * - **Manual path**: supply the full draft (file fields optional).
+     * - **Assisted path**: include `attachment` on the request; the SDK uploads
+     *   the attachment first and wires its URI / hash into the MetaEvidence JSON.
+     *   Attachment-derived file metadata takes precedence over any file fields
+     *   provided on the draft.
+     */
+    async publish(input) {
+        let documentJson;
+        let publishedAttachment;
+        if ('attachment' in input && input.attachment) {
+            if (!this.options.attachmentStore) {
+                throw new Error('attachmentStore is required when attachment is provided');
+            }
+            publishedAttachment = await this.options.attachmentStore.putAttachment(input.attachment);
+            documentJson = MetaEvidenceJsonBuilder.withAttachment(input, publishedAttachment);
+        }
+        else {
+            documentJson = MetaEvidenceJsonBuilder.build(input);
+        }
+        const publishedDocument = await this.options.documentStore.putMetaEvidenceDocument(documentJson);
+        const baseResult = {
+            documentJson,
+            document: publishedDocument,
+            ...(publishedAttachment ? { attachment: publishedAttachment } : {}),
+        };
+        const remotePinning = await this.runRemotePinning(publishedDocument, publishedAttachment);
+        return {
+            ...baseResult,
+            ...(remotePinning !== undefined ? { remotePinning } : {}),
+        };
+    }
+    async uploadAttachment(input) {
+        if (!this.options.attachmentStore) {
+            throw new Error('attachmentStore is required to upload attachments');
+        }
+        return this.options.attachmentStore.putAttachment(input);
+    }
+    async pinCid(input) {
+        if (!this.options.pinByCidClient) {
+            throw new Error('pinByCidClient is required to pin CIDs');
+        }
+        const result = await this.options.pinByCidClient.pinByCid({ cid: input.cid });
+        return {
+            cid: result.cid ?? input.cid,
+            ...(result.cid ? { uri: `ipfs://${result.cid}` } : {}),
+        };
+    }
+    /**
+     * Release underlying resources (e.g. stop the Helia node).
+     * Always call this when the publisher is no longer needed.
+     */
+    async close() {
+        await this.options.onClose?.();
+    }
+    // ── Remote pinning pipeline ──────────────────────────────────────────────
+    async runRemotePinning(document, attachment) {
+        const config = this.options.remotePinning;
+        if (!config || config.enabled === false) {
+            return undefined;
+        }
+        const client = new HttpPinByCidClient({
+            providerUrl: config.endpoint,
+            auth: config.auth,
+            requestPath: config.requestPath,
+            headers: config.headers,
+        });
+        try {
+            const docPinResponse = await client.pinByCid({ cid: document.cid });
+            const documentPin = {
+                cid: docPinResponse.cid ?? document.cid,
+                ...(docPinResponse.cid ? { uri: `ipfs://${docPinResponse.cid}` } : {}),
+                ...(docPinResponse.pinId ? { metadata: { pinId: docPinResponse.pinId } } : {}),
+            };
+            let attachmentPin;
+            if (attachment) {
+                const attPinResponse = await client.pinByCid({ cid: attachment.cid });
+                attachmentPin = {
+                    cid: attPinResponse.cid ?? attachment.cid,
+                    ...(attPinResponse.cid ? { uri: `ipfs://${attPinResponse.cid}` } : {}),
+                    ...(attPinResponse.pinId ? { metadata: { pinId: attPinResponse.pinId } } : {}),
+                };
+            }
+            return {
+                documentPin,
+                ...(attachmentPin ? { attachmentPin } : {}),
+            };
+        }
+        catch (err) {
+            return {
+                error: err instanceof Error ? err : new Error(String(err)),
+            };
+        }
+    }
+}

package/dist/src/advanced.d.ts

@@ -0,0 +1,15 @@
+export type { RequestAuth, RequestContext, RequestFieldValue, RequestFields, UploadRequest, PinByCidRequest, PinningRequest, Attachment, PublishedAttachment, PublishedEvidenceDocument, CidInput, PinResult, RemotePinningConfig, RemotePinOutcome, EvidenceDraft, EvidenceJson, EvidenceJsonDocument, EvidencePublishRequest, EvidencePublishResult, RulingOptionType, CourtEncodingVersion, RulingOptions, MetaEvidence, MetaEvidenceDraft, ManualMetaEvidencePublishRequest, AssistedMetaEvidencePublishRequest, MetaEvidencePublishRequest, MetaEvidencePublishResult, } from './types.js';
+export type { ContentPublishOptions, ContentAddResult, AttachmentStore, EvidenceStore, MetaEvidenceStore } from './storage-types.js';
+export type { StorageConfig, StorageConfigReadOptions, AddressingModel, ProviderConfig, PinningConfig, ProviderAuth, } from './config.js';
+export { parseStorageConfig, readStorageConfigFile, normalizeStorageConfig, readEnvFile, EvidenceConfigError, } from './config.js';
+export { EvidencePublisher } from './EvidencePublisher.js';
+export type { EvidencePublisherOptions } from './EvidencePublisher.js';
+export { MetaEvidencePublisher } from './MetaEvidencePublisher.js';
+export type { MetaEvidencePublisherOptions } from './MetaEvidencePublisher.js';
+export { MetaEvidenceJsonBuilder } from './MetaEvidenceJsonBuilder.js';
+export type { EvidencePublisherFactoryOptions, EvidencePublisherConfig, MetaEvidencePublisherFactoryOptions, } from './EvidencePublisherFactory.js';
+export { createHttpEvidencePublisher, createHttpMetaEvidencePublisher } from './EvidencePublisherFactory.js';
+export { HttpMultipartUploadClient } from './http/HttpMultipartUploadClient.js';
+export type { HttpMultipartUploadClientOptions, HttpMultipartUploadInput } from './http/HttpMultipartUploadClient.js';
+export { HttpPinByCidClient } from './http/HttpPinByCidClient.js';
+export type { HttpPinByCidClientOptions, HttpPinByCidResult } from './http/HttpPinByCidClient.js';

package/dist/src/advanced.js

@@ -0,0 +1,7 @@
+export { parseStorageConfig, readStorageConfigFile, normalizeStorageConfig, readEnvFile, EvidenceConfigError, } from './config.js';
+export { EvidencePublisher } from './EvidencePublisher.js';
+export { MetaEvidencePublisher } from './MetaEvidencePublisher.js';
+export { MetaEvidenceJsonBuilder } from './MetaEvidenceJsonBuilder.js';
+export { createHttpEvidencePublisher, createHttpMetaEvidencePublisher } from './EvidencePublisherFactory.js';
+export { HttpMultipartUploadClient } from './http/HttpMultipartUploadClient.js';
+export { HttpPinByCidClient } from './http/HttpPinByCidClient.js';

package/dist/src/config.d.ts

@@ -0,0 +1,51 @@
+import type { RequestAuth, RemotePinningConfig } from './types.js';
+export type AddressingModel = 'content' | 'location';
+export type ProviderAuth = RequestAuth;
+export interface ProviderConfig {
+    /** Semantic identifier for logs/debugging. */
+    name: string;
+    /** Target endpoint when there is one. */
+    url?: string;
+    /** Thin overridable auth strategy. */
+    auth: RequestAuth;
+    /**
+     * Provider-specific extra fields sent with every multipart upload request.
+     * Example: `{ network: "public" }` for Pinata v3.
+     */
+    fields?: Record<string, string>;
+    /**
+     * Extra HTTP headers applied to every upload request.
+     * Merged before per-request headers; per-request headers take precedence.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Multipart field name for the file blob.
+     * Defaults to "file" when not set.
+     */
+    fileFieldName?: string;
+}
+export interface PinningConfig {
+    /** Whether the published content should be kept durable/pinned. */
+    enabled: boolean;
+}
+export interface StorageConfig {
+    addressing: AddressingModel;
+    provider: ProviderConfig;
+    pinning: PinningConfig;
+    /** Optional remote pinning config loaded from the YAML `remotePinning` section. */
+    remotePinning?: RemotePinningConfig;
+}
+export interface StorageConfigReadOptions {
+    /** Explicit environment map used to resolve placeholders. Defaults to process.env. */
+    env?: NodeJS.ProcessEnv;
+    /** Optional `.env` file loaded before resolving placeholders. */
+    envFilePath?: string;
+}
+export declare class EvidenceConfigError extends Error {
+    readonly source: string;
+    constructor(message: string, source: string);
+}
+export declare function readEnvFile(filePath: string): Promise<Record<string, string>>;
+export declare function readStorageConfigFile(filePath: string, options?: StorageConfigReadOptions): Promise<StorageConfig>;
+export declare function parseStorageConfig(raw: string, env?: NodeJS.ProcessEnv, source?: string): StorageConfig;
+export declare function normalizeStorageConfig(value: unknown, source?: string): StorageConfig;

package/dist/src/config.js

@@ -0,0 +1,245 @@
+import { readFile } from 'node:fs/promises';
+import { parse as parseDotEnv } from 'dotenv';
+import { parse as parseYaml } from 'yaml';
+export class EvidenceConfigError extends Error {
+    source;
+    constructor(message, source) {
+        super(`${message} (${source})`);
+        this.source = source;
+        this.name = 'EvidenceConfigError';
+    }
+}
+export async function readEnvFile(filePath) {
+    const raw = await readFile(filePath, 'utf8');
+    return parseDotEnv(raw);
+}
+export async function readStorageConfigFile(filePath, options = {}) {
+    const raw = await readFile(filePath, 'utf8');
+    const env = await loadConfigEnvironment(options.env, options.envFilePath);
+    return parseStorageConfig(raw, env, filePath);
+}
+export function parseStorageConfig(raw, env = process.env, source = '(inline config)') {
+    let parsed;
+    try {
+        parsed = parseYaml(raw);
+    }
+    catch (cause) {
+        throw new EvidenceConfigError(`Failed to parse YAML config: ${cause.message}`, source);
+    }
+    const resolved = resolveEnvironmentValues(parsed, toEnvRecord(env), source);
+    return normalizeStorageConfig(resolved, source);
+}
+export function normalizeStorageConfig(value, source = '(inline config)') {
+    const record = asRecord(value, source, 'config');
+    const addressing = normalizeAddressing(record.addressing, source);
+    const provider = normalizeProvider(record.provider, addressing, source);
+    const pinning = normalizePinning(record.pinning, addressing, source);
+    const remotePinning = normalizeRemotePinning(record.remotePinning, source);
+    return {
+        addressing,
+        provider,
+        pinning,
+        ...(remotePinning ? { remotePinning } : {}),
+    };
+}
+function normalizeAddressing(value, source) {
+    const addressing = readString(value, source, 'addressing');
+    if (addressing !== 'content' && addressing !== 'location') {
+        throw new EvidenceConfigError(`addressing must be 'content' or 'location'`, source);
+    }
+    return addressing;
+}
+function normalizeProvider(value, addressing, source) {
+    const record = asRecord(value, source, 'provider');
+    const name = readString(record.name, source, 'provider.name');
+    const url = optionalString(record.url, source, 'provider.url');
+    const auth = normalizeAuth(record.auth, source, 'provider.auth');
+    const fields = normalizeStringMap(record.fields, source, 'provider.fields');
+    const headers = normalizeStringMap(record.headers, source, 'provider.headers');
+    const fileFieldName = optionalString(record.fileFieldName, source, 'provider.fileFieldName');
+    if (addressing === 'location' && !url) {
+        throw new EvidenceConfigError(`provider.url is required when addressing is 'location'`, source);
+    }
+    if (url) {
+        validateUrl(url, source, 'provider.url');
+    }
+    return {
+        name,
+        ...(url ? { url } : {}),
+        auth,
+        ...(fields ? { fields } : {}),
+        ...(headers ? { headers } : {}),
+        ...(fileFieldName ? { fileFieldName } : {}),
+    };
+}
+function normalizeAuth(value, source, fieldPath = 'provider.auth') {
+    if (value === undefined || value === null) {
+        return { type: 'none' };
+    }
+    const record = asRecord(value, source, fieldPath);
+    const type = readString(record.type, source, `${fieldPath}.type`);
+    switch (type) {
+        case 'none':
+            return { type: 'none' };
+        case 'basic': {
+            const username = readString(record.username, source, `${fieldPath}.username`);
+            const password = readString(record.password, source, `${fieldPath}.password`);
+            return { type: 'basic', username, password };
+        }
+        case 'bearer': {
+            const token = readString(record.token, source, `${fieldPath}.token`);
+            return { type: 'bearer', token };
+        }
+        case 'header': {
+            const name = readString(record.name, source, `${fieldPath}.name`);
+            const value = readString(record.value, source, `${fieldPath}.value`);
+            return { type: 'header', name, value };
+        }
+        default:
+            throw new EvidenceConfigError(`${fieldPath}.type must be one of: none, basic, bearer, header`, source);
+    }
+}
+function normalizePinning(value, addressing, source) {
+    if (value === undefined || value === null) {
+        return {
+            enabled: addressing === 'content',
+        };
+    }
+    const record = asRecord(value, source, 'pinning');
+    const enabled = readBoolean(record.enabled, source, 'pinning.enabled');
+    return {
+        enabled,
+    };
+}
+function normalizeRemotePinning(value, source) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const record = asRecord(value, source, 'remotePinning');
+    const endpoint = readString(record.endpoint, source, 'remotePinning.endpoint');
+    validateUrl(endpoint, source, 'remotePinning.endpoint');
+    const auth = normalizeAuth(record.auth, source, 'remotePinning.auth');
+    const requestPath = optionalString(record.requestPath, source, 'remotePinning.requestPath');
+    const headers = normalizeStringMap(record.headers, source, 'remotePinning.headers');
+    let enabled;
+    if (record.enabled !== undefined && record.enabled !== null) {
+        enabled = readBoolean(record.enabled, source, 'remotePinning.enabled');
+    }
+    return {
+        endpoint,
+        auth,
+        ...(requestPath ? { requestPath } : {}),
+        ...(headers ? { headers } : {}),
+        ...(enabled !== undefined ? { enabled } : {}),
+    };
+}
+function normalizeStringMap(value, source, field) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const record = asRecord(value, source, field);
+    const result = {};
+    for (const [key, item] of Object.entries(record)) {
+        if (typeof item !== 'string') {
+            throw new EvidenceConfigError(`${field}.${key} must be a string`, source);
+        }
+        result[key] = item;
+    }
+    return result;
+}
+async function loadConfigEnvironment(env, envFilePath) {
+    const fromFile = envFilePath ? await readEnvFileIfPresent(envFilePath) : {};
+    const fromProcess = toEnvRecord(process.env);
+    const fromOptions = toEnvRecord(env ?? process.env);
+    return {
+        ...fromFile,
+        ...fromProcess,
+        ...fromOptions,
+    };
+}
+async function readEnvFileIfPresent(filePath) {
+    try {
+        return await readEnvFile(filePath);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return {};
+        }
+        throw error;
+    }
+}
+function resolveEnvironmentValues(value, env, source, path = 'config') {
+    if (typeof value === 'string') {
+        return resolveEnvPlaceholders(value, env, source, path);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index) => resolveEnvironmentValues(item, env, source, `${path}[${index}]`));
+    }
+    if (typeof value === 'object' && value !== null) {
+        const resolved = {};
+        for (const [key, item] of Object.entries(value)) {
+            resolved[key] = resolveEnvironmentValues(item, env, source, `${path}.${key}`);
+        }
+        return resolved;
+    }
+    return value;
+}
+function resolveEnvPlaceholders(value, env, source, path) {
+    const placeholderPattern = /\$\{([^}]+)}/g;
+    return value.replace(placeholderPattern, (_match, rawName) => {
+        const name = rawName.trim();
+        const resolved = env[name];
+        if (resolved === undefined || resolved.trim() === '') {
+            throw new EvidenceConfigError(`Environment variable ${name} referenced by ${path} was not found or was blank`, source);
+        }
+        return resolved;
+    });
+}
+function validateUrl(url, source, field) {
+    try {
+        // Ensure the URL is syntactically valid, but do not constrain protocol.
+        // eslint-disable-next-line no-new
+        new URL(url);
+    }
+    catch {
+        throw new EvidenceConfigError(`${field} must be a valid absolute URL`, source);
+    }
+}
+function asRecord(value, source, field) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new EvidenceConfigError(`${field} must be an object`, source);
+    }
+    return value;
+}
+function readString(value, source, field) {
+    if (typeof value !== 'string') {
+        throw new EvidenceConfigError(`${field} must be a string`, source);
+    }
+    if (value.trim() === '') {
+        throw new EvidenceConfigError(`${field} must not be blank`, source);
+    }
+    return value;
+}
+function optionalString(value, source, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    return readString(value, source, field);
+}
+function readBoolean(value, source, field) {
+    if (typeof value !== 'boolean') {
+        throw new EvidenceConfigError(`${field} must be a boolean`, source);
+    }
+    return value;
+}
+function toEnvRecord(env) {
+    const record = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value === 'string' && value.length > 0) {
+            record[key] = value;
+        }
+    }
+    return record;
+}
+function isMissingFileError(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}

package/dist/src/helia/HeliaAttachmentStore.d.ts

@@ -0,0 +1,8 @@
+import { HeliaIpfsClient, type HeliaIpfsClientOptions } from './HeliaIpfsClient.js';
+import type { AttachmentStore } from '../storage-types.js';
+import type { Attachment, PublishedAttachment } from '../types.js';
+export declare class HeliaAttachmentStore implements AttachmentStore {
+    private readonly client;
+    constructor(options: HeliaIpfsClientOptions | HeliaIpfsClient);
+    putAttachment(input: Attachment): Promise<PublishedAttachment>;
+}

package/dist/src/helia/HeliaAttachmentStore.js

@@ -0,0 +1,20 @@
+import { HeliaIpfsClient } from './HeliaIpfsClient.js';
+import { EvidenceHasher } from '../EvidenceHasher.js';
+export class HeliaAttachmentStore {
+    client;
+    constructor(options) {
+        this.client = options instanceof HeliaIpfsClient ? options : new HeliaIpfsClient(options);
+    }
+    async putAttachment(input) {
+        const added = await this.client.addBytes(input.bytes);
+        return {
+            cid: added.cid,
+            uri: added.uri,
+            fileHash: EvidenceHasher.hashBytes(input.bytes),
+            fileTypeExtension: input.fileTypeExtension,
+            mediaType: input.mediaType,
+            sizeBytes: input.bytes.length,
+            gatewayUrls: added.gatewayUrls,
+        };
+    }
+}

package/dist/src/helia/HeliaEvidenceStore.d.ts

@@ -0,0 +1,8 @@
+import { HeliaIpfsClient, type HeliaIpfsClientOptions } from './HeliaIpfsClient.js';
+import type { EvidenceStore } from '../storage-types.js';
+import type { EvidenceJsonDocument, PublishedEvidenceDocument } from '../types.js';
+export declare class HeliaEvidenceStore implements EvidenceStore {
+    private readonly client;
+    constructor(options: HeliaIpfsClientOptions | HeliaIpfsClient);
+    putEvidenceDocument(document: EvidenceJsonDocument): Promise<PublishedEvidenceDocument>;
+}

package/dist/src/helia/HeliaEvidenceStore.js

@@ -0,0 +1,16 @@
+import { HeliaIpfsClient } from './HeliaIpfsClient.js';
+import { EvidenceHasher } from '../EvidenceHasher.js';
+export class HeliaEvidenceStore {
+    client;
+    constructor(options) {
+        this.client = options instanceof HeliaIpfsClient ? options : new HeliaIpfsClient(options);
+    }
+    async putEvidenceDocument(document) {
+        const added = await this.client.addBytes(EvidenceHasher.serialize(document));
+        return {
+            cid: added.cid,
+            uri: added.uri,
+            gatewayUrls: added.gatewayUrls,
+        };
+    }
+}

package/dist/src/helia/HeliaIpfsClient.d.ts

@@ -0,0 +1,15 @@
+import type { ContentAddResult, ContentPublishOptions } from '../storage-types.js';
+export interface HeliaIpfsClientOptions extends ContentPublishOptions {
+    helia?: unknown;
+}
+export declare class HeliaIpfsClient {
+    private readonly options;
+    private nodePromise?;
+    constructor(options: HeliaIpfsClientOptions);
+    addBytes(bytes: Uint8Array): Promise<ContentAddResult>;
+    private getHeliaNode;
+    private initializeHeliaNode;
+    stop(): Promise<void>;
+    private pinCid;
+}
+export declare function buildGatewayUrls(cid: string, gatewayBaseUrls?: string[]): string[];

package/dist/src/helia/HeliaIpfsClient.js

@@ -0,0 +1,63 @@
+import { createHelia } from 'helia';
+import { unixfs } from '@helia/unixfs';
+export class HeliaIpfsClient {
+    options;
+    nodePromise;
+    constructor(options) {
+        this.options = options;
+    }
+    async addBytes(bytes) {
+        const node = await this.getHeliaNode();
+        const fs = unixfs(node);
+        const cid = await fs.addBytes(bytes);
+        const cidText = cid.toString();
+        if (this.options.pinning?.enabled) {
+            await this.pinCid(node, cid);
+        }
+        return {
+            cid: cidText,
+            uri: `ipfs://${cidText}`,
+            gatewayUrls: buildGatewayUrls(cidText, this.options.gatewayBaseUrls),
+        };
+    }
+    getHeliaNode() {
+        if (!this.nodePromise) {
+            this.nodePromise = this.initializeHeliaNode();
+        }
+        return this.nodePromise;
+    }
+    async initializeHeliaNode() {
+        return this.options.helia ?? await createHelia();
+    }
+    async stop() {
+        if (!this.nodePromise)
+            return;
+        const node = await this.nodePromise;
+        const n = node;
+        if (typeof n.stop === 'function') {
+            await n.stop();
+        }
+        this.nodePromise = undefined;
+    }
+    async pinCid(node, cid) {
+        const pins = node.pins;
+        if (!pins?.add) {
+            throw new Error('Helia node does not expose pins.add(...)');
+        }
+        for await (const _ of pins.add(cid, { signal: AbortSignal.timeout(5000) })) {
+            // Consume async iterator so the pin operation completes.
+        }
+    }
+}
+export function buildGatewayUrls(cid, gatewayBaseUrls) {
+    if (!gatewayBaseUrls || gatewayBaseUrls.length === 0) {
+        return [];
+    }
+    return gatewayBaseUrls.map((baseUrl) => {
+        const trimmed = baseUrl.trim();
+        if (trimmed.includes('{cid}')) {
+            return trimmed.replace(/\{cid}/g, cid);
+        }
+        return `${trimmed.replace(/\/+$/, '')}/ipfs/${cid}`;
+    });
+}

package/dist/src/http/HttpIpfsAttachmentStore.d.ts

@@ -0,0 +1,8 @@
+import type { AttachmentStore } from '../storage-types.js';
+import type { Attachment, PublishedAttachment } from '../types.js';
+import { HttpIpfsClient, type HttpIpfsClientOptions } from './HttpIpfsClient.js';
+export declare class HttpIpfsAttachmentStore implements AttachmentStore {
+    private readonly client;
+    constructor(options: HttpIpfsClientOptions | HttpIpfsClient);
+    putAttachment(input: Attachment): Promise<PublishedAttachment>;
+}

package/dist/src/http/HttpIpfsAttachmentStore.js

@@ -0,0 +1,23 @@
+import { EvidenceHasher } from '../EvidenceHasher.js';
+import { HttpIpfsClient } from './HttpIpfsClient.js';
+export class HttpIpfsAttachmentStore {
+    client;
+    constructor(options) {
+        this.client = options instanceof HttpIpfsClient ? options : new HttpIpfsClient(options);
+    }
+    async putAttachment(input) {
+        const added = await this.client.addBytes(input.bytes, {
+            fileName: input.fileName,
+            mediaType: input.mediaType,
+        });
+        return {
+            cid: added.cid,
+            uri: added.uri,
+            fileHash: EvidenceHasher.hashBytes(input.bytes),
+            fileTypeExtension: input.fileTypeExtension,
+            mediaType: input.mediaType,
+            sizeBytes: input.bytes.length,
+            gatewayUrls: added.gatewayUrls,
+        };
+    }
+}

package/dist/src/http/HttpIpfsClient.d.ts

@@ -0,0 +1,24 @@
+import type { ContentAddResult, ContentPublishOptions } from '../storage-types.js';
+export interface HttpIpfsClientOptions extends ContentPublishOptions {
+    /** Upload endpoint path relative to provider.url. Defaults to /api/v0/add. */
+    uploadPath?: string;
+    /** Multipart field name expected by the provider. Defaults to file. */
+    uploadFieldName?: string;
+    /** Additional request headers merged into the upload request. */
+    requestHeaders?: Record<string, string>;
+    /** Candidate JSON field names used to extract a CID from the response. */
+    responseCidFields?: string[];
+}
+export interface HttpIpfsUploadInput {
+    fileName?: string;
+    mediaType?: string;
+}
+export declare class HttpIpfsClient {
+    private readonly options;
+    private readonly apiEndpoint;
+    constructor(options: HttpIpfsClientOptions);
+    addBytes(bytes: Uint8Array, input?: HttpIpfsUploadInput): Promise<ContentAddResult>;
+    private buildUploadUrl;
+    private buildFormData;
+    private buildHeaders;
+}