scientific-protocol 0.1.0

package/dist/sdk/types.d.ts

@@ -0,0 +1,300 @@
+import type { AgentRequestEnvelope } from "../shared/agent-request-envelope.js";
+export type { AgentRequestActionType, AgentRequestEnvelope, } from "../shared/agent-request-envelope.js";
+export type { DeploymentAddresses, DeploymentFile } from "../shared/deployment.js";
+export type ProtocolRecord = any;
+export type AgentRequestView = ProtocolRecord;
+export type AgentReviewCalibrationContributionView = ProtocolRecord;
+export type AgentReviewCalibrationView = ProtocolRecord;
+export type AgentRewardStateView = ProtocolRecord;
+export type AgentRuntimeEventView = ProtocolRecord;
+export type AgentView = ProtocolRecord;
+export type AgentWebhookDeliveryView = ProtocolRecord;
+export type AgentWebhookEventType = string;
+export type AgentWebhookSubscriptionView = ProtocolRecord;
+export type AgentWorkSummaryView = ProtocolRecord;
+export type AppealView = ProtocolRecord;
+export type ArtifactMaintenanceTaskRunView = ProtocolRecord;
+export type ArtifactMaintenanceTaskView = ProtocolRecord;
+export type ArtifactView = ProtocolRecord;
+export type ChallengeView = ProtocolRecord;
+export type CheckpointView = ProtocolRecord;
+export type ClaimEventView = ProtocolRecord;
+export type ClaimFeedItemView = ProtocolRecord;
+export type ClaimReviewState = ProtocolRecord;
+export type ClaimRewardStateView = ProtocolRecord;
+export type ClaimView = ProtocolRecord;
+export type ClaimWorkGraphView = ProtocolRecord;
+export type ClaimWorkItemDetailView = ProtocolRecord;
+export type ClaimWorkItemView = ProtocolRecord;
+export type ClaimWorkOrchestrationView = ProtocolRecord;
+export type ClaimWorkRoutingView = ProtocolRecord;
+export type ClaimWorkSchedulingView = ProtocolRecord;
+export type ConfirmSourcePublicationResult = ProtocolRecord;
+export type DemoClaimInput = ProtocolRecord;
+export type DemoClaimResult = ProtocolRecord;
+export type DemoDomainRecomputeResult = ProtocolRecord;
+export type DemoScenarioView = ProtocolRecord;
+export type ForecastView = ProtocolRecord;
+export type GovernanceEventView = ProtocolRecord;
+export type GovernanceOverviewView = ProtocolRecord;
+export type GovernanceProposalDetailView = ProtocolRecord;
+export type GovernanceProposalSummaryView = ProtocolRecord;
+export type GovernanceTreasuryView = ProtocolRecord;
+export type IndexerRuntimeStatus = ProtocolRecord;
+export type PersistedArtifactAuditView = ProtocolRecord;
+export type PersistedArtifactProvenanceView = ProtocolRecord;
+export type PersistedArtifactReplicaView = ProtocolRecord;
+export type PersistedArtifactView = ProtocolRecord;
+export type ProductionArtifactDraftInput = ProtocolRecord;
+export type ProductionArtifactDraftResult = ProtocolRecord;
+export type ProductionClaimInput = ProtocolRecord;
+export type ProductionClaimResult = ProtocolRecord;
+export type ReadModelCounts = Record<string, number>;
+export type RecipientRewardStateView = ProtocolRecord;
+export type RejectSourcePublicationResult = ProtocolRecord;
+export type ReplicationJobRunView = ProtocolRecord;
+export type ReplicationJobView = ProtocolRecord;
+export type ReplicationView = ProtocolRecord;
+export type ReviewAuthorResponseView = ProtocolRecord;
+export type ReviewIssueView = ProtocolRecord;
+export type ReviewSubmissionView = ProtocolRecord;
+export type ReviewTaskRunView = ProtocolRecord;
+export type ReviewTaskView = ProtocolRecord;
+export type RewardProtocolConfigView = ProtocolRecord;
+export type RewardSettlementHistoryView = ProtocolRecord;
+export type SourceEventView = ProtocolRecord;
+export type SourceExtractionCandidate = ProtocolRecord;
+export type SourceFeedItemView = ProtocolRecord;
+export type SourcePublicationDecisionView = ProtocolRecord;
+export type SourceRecordView = ProtocolRecord;
+export type SourceWorkGraphView = ProtocolRecord;
+export type WriteProtocolConfigView = ProtocolRecord;
+export type PublicWriteActionType = "claim_create" | "claim_draft_from_artifact" | "domain_recompute" | "replication_job_open" | "replication_job_process" | "replication_job_resolve" | "source_publication_confirm" | "source_publication_reject" | "source_submit";
+export type PublicWriteEnvelope = {
+    actionType: PublicWriteActionType;
+    actorAddress: string;
+    chainId: number;
+    issuedAt: string;
+    payload: ProtocolRecord;
+    requestNonce: string;
+    scopeKey: string;
+};
+export type ReadModel = {
+    metadata: ProtocolRecord;
+    [key: string]: unknown;
+};
+export type PageResult<T> = {
+    items: T[];
+    limit: number;
+    offset: number;
+    total: number;
+};
+export type PagedResponse<T> = PageResult<T>;
+export type ClaimCollectionCounts = {
+    appeals: number;
+    artifacts: number;
+    challenges: number;
+    checkpoints: number;
+    forecasts: number;
+    replications: number;
+};
+export type ClaimDetailResponse = ClaimView & {
+    collectionCounts: ClaimCollectionCounts;
+    appeals?: AppealView[];
+    artifacts?: ArtifactView[];
+    challenges?: ChallengeView[];
+    checkpoints?: CheckpointView[];
+    forecasts?: ForecastView[];
+    replications?: ReplicationView[];
+    rewards?: ClaimRewardStateView;
+    review?: ClaimReviewState;
+    workGraph?: ClaimWorkGraphView;
+};
+export type DemoScenarioPayload = DemoScenarioView & {
+    claim: (ClaimView & {
+        collectionCounts: ClaimCollectionCounts;
+    }) | null;
+};
+export type ApiSyncStatus = {
+    blocksRemaining: number | null;
+    chainHeadBlock: number | null;
+    cursorBlock: number | null;
+    indexer: IndexerRuntimeStatus;
+    lagBlocks: number | null;
+    rpcError: string | null;
+    rpcReachable: boolean;
+    syncedToHead: boolean | null;
+};
+export type HealthResponse = ReadModel["metadata"] & {
+    counts: ReadModelCounts;
+    databaseUrl: string;
+    ok: true;
+    sync: ApiSyncStatus;
+};
+export type AdminStatusResponse = {
+    counts: ReadModelCounts;
+    metadata: ReadModel["metadata"];
+    sync: ApiSyncStatus;
+};
+export type DemoAdminStatusResponse = {
+    counts: ReadModelCounts;
+    ok: true;
+    scenarios: DemoScenarioPayload[];
+    sync: ApiSyncStatus;
+    tokenConfigured: boolean;
+};
+export type DemoMutationResponse<TResult> = {
+    ok: true;
+    result: TResult;
+    synced?: {
+        indexedAt: string;
+        latestBlock: number;
+    };
+};
+export type DemoScenariosResponse = {
+    items: DemoScenarioPayload[];
+};
+export type ReplicationJobDetailResponse = {
+    artifact: PersistedArtifactDetailResponse | null;
+    job: ReplicationJobView | null;
+    runs: ReplicationJobRunView[];
+};
+export type ArtifactMaintenanceTaskDetailResponse = {
+    artifact: PersistedArtifactDetailResponse | null;
+    runs: ArtifactMaintenanceTaskRunView[];
+    task: ArtifactMaintenanceTaskView;
+};
+export type ReviewTaskDetailResponse = {
+    runs: ReviewTaskRunView[];
+    submissions: ReviewSubmissionView[];
+    task: ReviewTaskView;
+};
+export type SourceDetailResponse = {
+    candidates: SourceExtractionCandidate[];
+    publicationDecisions: PagedResponse<SourcePublicationDecisionView>;
+    source: SourceRecordView;
+    tasks: ReviewTaskView[];
+    workGraph: SourceWorkGraphView;
+};
+export type SourceIngestionResponse = {
+    ok: true;
+    requestId: string;
+    result: ProductionArtifactDraftResult;
+};
+export type SourceListQuery = {
+    limit?: number;
+    offset?: number;
+    status?: "discovered" | "snapshotted" | "extracting" | "ready_for_publication" | "published" | "rejected";
+};
+export type SourceListResponse = PagedResponse<SourceRecordView>;
+export type SourcePublicationDecisionsResponse = PagedResponse<SourcePublicationDecisionView>;
+export type SourceFeedResponse = PagedResponse<SourceFeedItemView>;
+export type ClaimFeedResponse = PagedResponse<ClaimFeedItemView>;
+export type SourceEventsResponse = PagedResponse<SourceEventView>;
+export type ClaimEventsResponse = PagedResponse<ClaimEventView>;
+export type ConfirmSourcePublicationResponse = {
+    ok: true;
+    requestId: string;
+    result: ConfirmSourcePublicationResult;
+    synced: {
+        indexedAt: string;
+        latestBlock: number;
+    };
+};
+export type RejectSourcePublicationResponse = {
+    ok: true;
+    requestId: string;
+    result: RejectSourcePublicationResult;
+};
+export type ClaimWorkGraphResponse = ClaimWorkGraphView;
+export type SourceWorkGraphResponse = SourceWorkGraphView;
+export type ClaimWorkItemDetailResponse = ClaimWorkItemDetailView;
+export type AgentRequestDetailResponse = AgentRequestView;
+export type AgentReviewCalibrationResponse = AgentReviewCalibrationView & {
+    contributions: PagedResponse<AgentReviewCalibrationContributionView>;
+};
+export type AgentWorkSummaryResponse = {
+    agentId: string;
+    domainId: number | null;
+    summary: AgentWorkSummaryView;
+};
+export type ClaimRewardStateResponse = ClaimRewardStateView;
+export type AgentRewardStateResponse = AgentRewardStateView;
+export type RecipientRewardStateResponse = RecipientRewardStateView;
+export type RewardSettlementHistoryResponse = RewardSettlementHistoryView;
+export type RewardProtocolConfigResponse = RewardProtocolConfigView;
+export type WriteProtocolConfigResponse = WriteProtocolConfigView;
+export type GovernanceEventsResponse = PagedResponse<GovernanceEventView>;
+export type GovernanceOverviewResponse = GovernanceOverviewView;
+export type GovernanceTreasuryResponse = GovernanceTreasuryView;
+export type GovernanceProposalDetailResponse = GovernanceProposalDetailView;
+export type GovernanceProposalsResponse = PagedResponse<GovernanceProposalSummaryView>;
+export type AgentRuntimeEventsResponse = PagedResponse<AgentRuntimeEventView>;
+export type AgentWebhookSubscriptionsResponse = PagedResponse<AgentWebhookSubscriptionView>;
+export type AgentWebhookDeliveriesResponse = PagedResponse<AgentWebhookDeliveryView>;
+export type AgentWebhookSubscriptionCreateResponse = {
+    ok: true;
+    result: {
+        signingSecret: string;
+        subscription: AgentWebhookSubscriptionView;
+    };
+};
+export type AgentWebhookSubscriptionDeleteResponse = {
+    ok: true;
+    result: AgentWebhookSubscriptionView | null;
+};
+export type AgentWebhookSubscriptionPingResponse = {
+    ok: true;
+    result: {
+        delivery: AgentWebhookDeliveryView;
+        subscription: AgentWebhookSubscriptionView;
+    };
+};
+export type SignedAgentRequestBody = {
+    envelope: AgentRequestEnvelope;
+    signature: string;
+};
+export type SignedPublicWriteRequestBody = {
+    envelope: PublicWriteEnvelope;
+    signature: string;
+};
+export type PersistedArtifactDetailResponse = PersistedArtifactView & {
+    provenance: PersistedArtifactProvenanceView | null;
+    recentAudits: PagedResponse<PersistedArtifactAuditView>;
+    replicas: PersistedArtifactReplicaView[];
+};
+export type DomainLeaderboardResponse<TEntry = Record<string, unknown>> = {
+    items: TEntry[];
+    latestPayload: {
+        computedAt: string;
+        domainId: number;
+        payloadHash: string;
+        payloadId: string;
+        uri: string;
+    } | null;
+    limit: number;
+    offset: number;
+    total: number;
+};
+export type ClaimListQuery = {
+    author?: string;
+    domainId?: number;
+    limit?: number;
+    offset?: number;
+    status?: number;
+};
+export type CreateDemoClaimRequest = DemoClaimInput;
+export type CreateProductionClaimRequest = ProductionClaimInput;
+export type CreateProductionArtifactDraftRequest = ProductionArtifactDraftInput;
+export type OpenDemoReplicationJobRequest = {
+    claimId: string;
+    requestedBy?: string;
+};
+export type ProcessDemoReplicationJobRequest = {
+    workerId?: string;
+};
+export type ResolveDemoReplicationJobRequest = {
+    claimStatus?: number;
+    confidenceBps?: number;
+    resolutionStatus?: number;
+};

package/dist/sdk/types.js

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

package/dist/shared/agent-request-envelope.d.ts

@@ -0,0 +1,40 @@
+export type AgentRequestActionType = "artifact_task_audit_submission" | "artifact_task_claim" | "artifact_task_heartbeat" | "artifact_task_repair_submission" | "replication_job_claim" | "replication_job_heartbeat" | "replication_job_submission" | "source_discovery_submission" | "webhook_subscription_create" | "webhook_subscription_delete" | "webhook_subscription_ping" | "review_task_heartbeat" | "review_task_claim" | "review_task_submission";
+export type AgentRequestEnvelope = {
+    actionType: AgentRequestActionType;
+    actorAddress: string;
+    agentId: string;
+    issuedAt: string;
+    payload: Record<string, unknown>;
+    requestNonce: string;
+    scopeKey: string;
+};
+export declare function hashAgentRequestEnvelope(envelope: AgentRequestEnvelope): string;
+export declare function verifyAgentRequestEnvelope(input: {
+    envelope: AgentRequestEnvelope;
+    signature: string;
+}): {
+    recoveredAddress: string;
+    requestHash: string;
+};
+export type AgentRequestSigner = {
+    getAddress(): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+};
+export type SignedAgentRequestEnvelope = {
+    envelope: AgentRequestEnvelope;
+    signature: string;
+};
+export declare function signAgentRequestEnvelope(input: {
+    envelope: AgentRequestEnvelope;
+    signer: AgentRequestSigner;
+}): Promise<SignedAgentRequestEnvelope>;
+export declare function createSignedAgentRequest(input: {
+    actionType: AgentRequestActionType;
+    actorAddress?: string;
+    agentId: string;
+    issuedAt?: string;
+    payload: Record<string, unknown>;
+    requestNonce: string;
+    scopeKey: string;
+    signer: AgentRequestSigner;
+}): Promise<SignedAgentRequestEnvelope>;

package/dist/shared/agent-request-envelope.js

@@ -0,0 +1,51 @@
+import { getBytes, verifyMessage } from "ethers";
+import { sha256Hex } from "./sha256.js";
+function stableSerialize(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableSerialize(entryValue)}`);
+        return `{${entries.join(",")}}`;
+    }
+    if (typeof value === "bigint") {
+        return JSON.stringify(value.toString());
+    }
+    return JSON.stringify(value);
+}
+export function hashAgentRequestEnvelope(envelope) {
+    return `0x${sha256Hex(stableSerialize(envelope))}`;
+}
+export function verifyAgentRequestEnvelope(input) {
+    const requestHash = hashAgentRequestEnvelope(input.envelope);
+    const recoveredAddress = verifyMessage(getBytes(requestHash), input.signature);
+    if (recoveredAddress.toLowerCase() !== input.envelope.actorAddress.toLowerCase()) {
+        throw new Error(`agent request signature mismatch: expected ${input.envelope.actorAddress}, recovered ${recoveredAddress}`);
+    }
+    return { recoveredAddress, requestHash };
+}
+export async function signAgentRequestEnvelope(input) {
+    const requestHash = hashAgentRequestEnvelope(input.envelope);
+    const signature = await input.signer.signMessage(getBytes(requestHash));
+    return {
+        envelope: input.envelope,
+        signature,
+    };
+}
+export async function createSignedAgentRequest(input) {
+    const actorAddress = input.actorAddress ?? (await input.signer.getAddress());
+    return signAgentRequestEnvelope({
+        envelope: {
+            actionType: input.actionType,
+            actorAddress,
+            agentId: input.agentId,
+            issuedAt: input.issuedAt ?? new Date().toISOString(),
+            payload: input.payload,
+            requestNonce: input.requestNonce,
+            scopeKey: input.scopeKey,
+        },
+        signer: input.signer,
+    });
+}

package/dist/shared/artifact-storage-attestations.d.ts

@@ -0,0 +1,64 @@
+import { type Signer } from "ethers";
+import type { ArtifactDurabilityClass, ArtifactStorageAttestationInput, ArtifactStorageCommitmentKind } from "./artifact-storage-policy.js";
+export type ArtifactStorageAttestationActionType = "artifact_storage_attestation";
+export type ArtifactStorageAttestationEnvelope = {
+    actionType: ArtifactStorageAttestationActionType;
+    artifactKey: string;
+    attestorAddress: string;
+    chainId: number;
+    cid: string;
+    commitmentKind: ArtifactStorageCommitmentKind;
+    evidenceRef: string | null;
+    issuedAt: string;
+    nodeId: string | null;
+    provider: string;
+    providerMetadata: Record<string, unknown>;
+    requestNonce: string;
+    retentionUntil: string | null;
+    retrievalUrl: string | null;
+    scopeKey: string;
+    storageClass: ArtifactDurabilityClass;
+    storageStartedAt: string;
+};
+export type ArtifactStorageAttestationSigner = Pick<Signer, "getAddress" | "signMessage">;
+export type SignedArtifactStorageAttestation = {
+    envelope: ArtifactStorageAttestationEnvelope;
+    signature: string;
+};
+export type VerifiedArtifactStorageAttestation = {
+    recoveredAddress: string;
+    signedPayloadHash: string;
+};
+export declare function buildArtifactStorageAttestationScopeKey(input: {
+    artifactKey: string;
+    cid: string;
+}): string;
+export declare function buildArtifactStorageAttestationEnvelope(input: {
+    artifactKey: string;
+    attestorAddress: string;
+    chainId: number;
+    cid: string;
+    commitmentKind: ArtifactStorageCommitmentKind;
+    evidenceRef?: string | null;
+    issuedAt?: string;
+    nodeId?: string | null;
+    provider: string;
+    providerMetadata?: Record<string, unknown>;
+    requestNonce: string;
+    retentionUntil?: string | null;
+    retrievalUrl?: string | null;
+    scopeKey?: string;
+    storageClass: ArtifactDurabilityClass;
+    storageStartedAt?: string;
+}): ArtifactStorageAttestationEnvelope;
+export declare function hashArtifactStorageAttestationEnvelope(envelope: ArtifactStorageAttestationEnvelope): string;
+export declare function signArtifactStorageAttestation(input: {
+    envelope: ArtifactStorageAttestationEnvelope;
+    signer: ArtifactStorageAttestationSigner;
+}): Promise<SignedArtifactStorageAttestation>;
+export declare function createSignedArtifactStorageAttestation(input: Omit<Parameters<typeof buildArtifactStorageAttestationEnvelope>[0], "attestorAddress"> & {
+    attestorAddress?: string;
+    signer: ArtifactStorageAttestationSigner;
+}): Promise<SignedArtifactStorageAttestation>;
+export declare function verifyArtifactStorageAttestation(signed: SignedArtifactStorageAttestation): VerifiedArtifactStorageAttestation;
+export declare function toArtifactStorageAttestationRecordInput(signed: SignedArtifactStorageAttestation): ArtifactStorageAttestationInput;

package/dist/shared/artifact-storage-attestations.js

@@ -0,0 +1,104 @@
+import { getBytes, verifyMessage } from "ethers";
+import { sha256Hex } from "./sha256.js";
+function stableSerialize(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableSerialize(entryValue)}`);
+        return `{${entries.join(",")}}`;
+    }
+    if (typeof value === "bigint") {
+        return JSON.stringify(value.toString());
+    }
+    return JSON.stringify(value);
+}
+function normalizeRequiredText(value, fieldName) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`${fieldName} is required`);
+    }
+    return trimmed;
+}
+function normalizeOptionalText(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+export function buildArtifactStorageAttestationScopeKey(input) {
+    return `artifact:${normalizeRequiredText(input.artifactKey, "artifactKey")}:cid:${normalizeRequiredText(input.cid, "cid")}`;
+}
+export function buildArtifactStorageAttestationEnvelope(input) {
+    if (!Number.isSafeInteger(input.chainId) || input.chainId <= 0) {
+        throw new Error("chainId must be a positive safe integer");
+    }
+    const artifactKey = normalizeRequiredText(input.artifactKey, "artifactKey");
+    const cid = normalizeRequiredText(input.cid, "cid");
+    return {
+        actionType: "artifact_storage_attestation",
+        artifactKey,
+        attestorAddress: normalizeRequiredText(input.attestorAddress, "attestorAddress"),
+        chainId: input.chainId,
+        cid,
+        commitmentKind: input.commitmentKind,
+        evidenceRef: normalizeOptionalText(input.evidenceRef),
+        issuedAt: input.issuedAt ?? new Date().toISOString(),
+        nodeId: normalizeOptionalText(input.nodeId),
+        provider: normalizeRequiredText(input.provider, "provider"),
+        providerMetadata: input.providerMetadata ?? {},
+        requestNonce: normalizeRequiredText(input.requestNonce, "requestNonce"),
+        retentionUntil: normalizeOptionalText(input.retentionUntil),
+        retrievalUrl: normalizeOptionalText(input.retrievalUrl),
+        scopeKey: input.scopeKey ?? buildArtifactStorageAttestationScopeKey({ artifactKey, cid }),
+        storageClass: input.storageClass,
+        storageStartedAt: input.storageStartedAt ?? new Date().toISOString(),
+    };
+}
+export function hashArtifactStorageAttestationEnvelope(envelope) {
+    return `0x${sha256Hex(stableSerialize(envelope))}`;
+}
+export async function signArtifactStorageAttestation(input) {
+    const signedPayloadHash = hashArtifactStorageAttestationEnvelope(input.envelope);
+    const signature = await input.signer.signMessage(getBytes(signedPayloadHash));
+    return {
+        envelope: input.envelope,
+        signature,
+    };
+}
+export async function createSignedArtifactStorageAttestation(input) {
+    const attestorAddress = input.attestorAddress ?? (await input.signer.getAddress());
+    return signArtifactStorageAttestation({
+        envelope: buildArtifactStorageAttestationEnvelope({
+            ...input,
+            attestorAddress,
+        }),
+        signer: input.signer,
+    });
+}
+export function verifyArtifactStorageAttestation(signed) {
+    const signedPayloadHash = hashArtifactStorageAttestationEnvelope(signed.envelope);
+    const recoveredAddress = verifyMessage(getBytes(signedPayloadHash), signed.signature);
+    if (recoveredAddress.toLowerCase() !== signed.envelope.attestorAddress.toLowerCase()) {
+        throw new Error(`artifact storage attestation signature mismatch: expected ${signed.envelope.attestorAddress}, recovered ${recoveredAddress}`);
+    }
+    return { recoveredAddress, signedPayloadHash };
+}
+export function toArtifactStorageAttestationRecordInput(signed) {
+    const { signedPayloadHash } = verifyArtifactStorageAttestation(signed);
+    return {
+        attestorAddress: signed.envelope.attestorAddress,
+        cid: signed.envelope.cid,
+        commitmentKind: signed.envelope.commitmentKind,
+        evidenceRef: signed.envelope.evidenceRef,
+        nodeId: signed.envelope.nodeId,
+        provider: signed.envelope.provider,
+        providerMetadata: signed.envelope.providerMetadata,
+        retentionUntil: signed.envelope.retentionUntil,
+        retrievalUrl: signed.envelope.retrievalUrl,
+        signature: signed.signature,
+        signedPayloadHash,
+        storageClass: signed.envelope.storageClass,
+        storageStartedAt: signed.envelope.storageStartedAt,
+    };
+}

package/dist/shared/artifact-storage-bundles.d.ts

@@ -0,0 +1,44 @@
+import type { ArtifactDurabilityClass, ArtifactStoragePolicyInput } from "./artifact-storage-policy.js";
+export type ArtifactStorageBundleManifestArtifactInput = {
+    artifactKey: string;
+    byteLength: number;
+    cid: string;
+    contentType: string;
+    durabilityClass: ArtifactDurabilityClass;
+    memberPath: string;
+    metadata?: Record<string, unknown>;
+    sha256: string;
+    sourceUri?: string | null;
+};
+export type ArtifactStorageBundleManifestInput = {
+    artifacts: ArtifactStorageBundleManifestArtifactInput[];
+    bundleCid?: string | null;
+    bundleKey: string;
+    bundleUri?: string | null;
+    generatedAt?: string;
+    metadata?: Record<string, unknown>;
+    storageRail: string;
+};
+export type ArtifactStorageBundleManifestArtifact = Required<Omit<ArtifactStorageBundleManifestArtifactInput, "metadata" | "sourceUri">> & {
+    metadata: Record<string, unknown>;
+    sourceUri: string | null;
+};
+export type ArtifactStorageBundleManifest = {
+    artifacts: ArtifactStorageBundleManifestArtifact[];
+    bundleCid: string | null;
+    bundleKey: string;
+    bundleUri: string | null;
+    generatedAt: string;
+    kind: "scientific.artifact-storage-bundle";
+    manifestDigest: string;
+    metadata: Record<string, unknown>;
+    storageRail: string;
+    version: 1;
+};
+export type ArtifactStorageBundlePolicyInput = {
+    artifactKey: string;
+    policy: Pick<ArtifactStoragePolicyInput, "bundleCid" | "bundleMemberPath" | "durabilityClass" | "metadata">;
+};
+export declare function buildArtifactStorageBundleManifest(input: ArtifactStorageBundleManifestInput): ArtifactStorageBundleManifest;
+export declare function verifyArtifactStorageBundleManifest(manifest: ArtifactStorageBundleManifest): string;
+export declare function createArtifactStorageBundlePolicyInputs(manifest: ArtifactStorageBundleManifest): ArtifactStorageBundlePolicyInput[];