@aiwg/cli 2026.8.11 → 2026.8.13

package/dist/src/providers/transformation-receipt.js

@@ -0,0 +1,215 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export const PROVIDER_TRANSFORMATION_RECEIPT_SCHEMA = 'aiwg.provider-transformation-receipt.v1';
+const SHA256 = /^[a-f0-9]{64}$/;
+const IDENTIFIER = /^[a-zA-Z0-9][a-zA-Z0-9._:/@+-]*$/;
+const FILENAME_SEGMENT = /^[a-zA-Z0-9][a-zA-Z0-9._+-]*$/;
+function digest(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+function portableRelative(value, label) {
+    const normalized = value.replaceAll('\\', '/').replace(/^\.\//, '');
+    if (!normalized || normalized.startsWith('/') || normalized.includes('\0')) {
+        throw new Error(`${label} must be a portable relative path`);
+    }
+    if (normalized.split('/').some(part => !part || part === '.' || part === '..')) {
+        throw new Error(`${label} must not escape its portable root`);
+    }
+    return normalized;
+}
+function identifier(value, label) {
+    if (!IDENTIFIER.test(value))
+        throw new Error(`${label} contains a non-portable identifier`);
+    return value;
+}
+function filenameSegment(value, label) {
+    if (!FILENAME_SEGMENT.test(value) || value === '.' || value === '..') {
+        throw new Error(`${label} must be a portable filename segment`);
+    }
+    return value;
+}
+function sha(value, label) {
+    if (!SHA256.test(value))
+        throw new Error(`${label} must be a lowercase SHA-256 digest`);
+    return value;
+}
+async function readRegularOutput(root, relative) {
+    const canonicalRoot = await realpath(root);
+    const absolute = path.resolve(canonicalRoot, relative);
+    const metadata = await lstat(absolute);
+    if (metadata.isSymbolicLink() || !metadata.isFile()) {
+        throw new Error(`receipt output '${relative}' must be a regular file and must not be a symbolic link`);
+    }
+    const canonicalOutput = await realpath(absolute);
+    const containment = path.relative(canonicalRoot, canonicalOutput);
+    if (containment === '..' || containment.startsWith(`..${path.sep}`) || path.isAbsolute(containment)) {
+        throw new Error(`receipt output '${relative}' resolves outside its configured root`);
+    }
+    return readFile(canonicalOutput);
+}
+export function providerTransformationReceiptPath(projectRoot, provider, scope) {
+    filenameSegment(provider, 'provider');
+    if (scope !== 'project' && scope !== 'user')
+        throw new Error('scope must be project or user');
+    return path.join(projectRoot, '.aiwg', 'receipts', 'providers', `${provider}.${scope}.json`);
+}
+export function validateProviderTransformationReceipt(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('receipt must be an object');
+    const receipt = value;
+    if (receipt.schemaVersion !== PROVIDER_TRANSFORMATION_RECEIPT_SCHEMA)
+        throw new Error('unsupported receipt schema');
+    if (!Number.isFinite(Date.parse(receipt.generatedAt)))
+        throw new Error('generatedAt must be an RFC 3339 date-time');
+    if (receipt.scope !== 'project' && receipt.scope !== 'user')
+        throw new Error('scope must be project or user');
+    filenameSegment(receipt.provider, 'provider');
+    identifier(receipt.source?.subject, 'source.subject');
+    sha(receipt.source?.sha256, 'source.sha256');
+    if (receipt.source?.verification !== 'verified') {
+        throw new Error('source.verification must be verified');
+    }
+    identifier(receipt.transformer?.id, 'transformer.id');
+    identifier(receipt.transformer?.version, 'transformer.version');
+    identifier(receipt.transformer?.providerAdapter, 'transformer.providerAdapter');
+    identifier(receipt.transformer?.providerAdapterVersion, 'transformer.providerAdapterVersion');
+    if (!Array.isArray(receipt.outputs) || receipt.outputs.length === 0)
+        throw new Error('outputs must not be empty');
+    const paths = new Set();
+    for (const [index, output] of receipt.outputs.entries()) {
+        output.path = portableRelative(output.path, `outputs[${index}].path`);
+        if (paths.has(output.path))
+            throw new Error(`duplicate output path '${output.path}'`);
+        paths.add(output.path);
+        sha(output.sha256, `outputs[${index}].sha256`);
+        if (!Number.isSafeInteger(output.bytes) || output.bytes < 0)
+            throw new Error(`outputs[${index}].bytes is invalid`);
+    }
+    receipt.outputs.sort((a, b) => a.path.localeCompare(b.path));
+    return receipt;
+}
+export async function createProviderTransformationReceipt(options) {
+    const outputs = [];
+    for (const raw of [...new Set(options.outputPaths)].sort()) {
+        const relative = portableRelative(raw, 'output path');
+        const bytes = await readRegularOutput(options.outputRoot ?? options.projectRoot, relative);
+        outputs.push({ path: relative, sha256: digest(bytes), bytes: bytes.byteLength });
+    }
+    return validateProviderTransformationReceipt({
+        schemaVersion: PROVIDER_TRANSFORMATION_RECEIPT_SCHEMA,
+        generatedAt: options.generatedAt ?? new Date().toISOString(),
+        scope: options.scope,
+        provider: options.provider,
+        source: options.source,
+        transformer: options.transformer,
+        outputs,
+    });
+}
+export async function writeProviderTransformationReceipt(projectRoot, receipt) {
+    validateProviderTransformationReceipt(receipt);
+    const destination = providerTransformationReceiptPath(projectRoot, receipt.provider, receipt.scope);
+    await mkdir(path.dirname(destination), { recursive: true });
+    try {
+        const existing = validateProviderTransformationReceipt(JSON.parse(await readFile(destination, 'utf8')));
+        const semantic = (value) => JSON.stringify({ ...value, generatedAt: undefined });
+        if (semantic(existing) === semantic(receipt))
+            return destination;
+    }
+    catch {
+        // A missing or invalid prior receipt is replaced atomically below.
+    }
+    const temporary = `${destination}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(receipt, null, 2)}\n`, {
+            encoding: 'utf8', mode: 0o600, flag: 'wx',
+        });
+        await rename(temporary, destination);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    return destination;
+}
+export async function diagnoseProviderTransformationReceipt(options) {
+    const receiptPath = providerTransformationReceiptPath(options.projectRoot, options.provider, options.scope);
+    let receipt;
+    try {
+        receipt = validateProviderTransformationReceipt(JSON.parse(await readFile(receiptPath, 'utf8')));
+    }
+    catch (error) {
+        const missing = error.code === 'ENOENT';
+        return {
+            status: missing ? 'missing-receipt' : 'drifted',
+            receiptPath,
+            checkedOutputs: 0,
+            findings: [{
+                    kind: 'missing-receipt',
+                    message: missing
+                        ? 'No transformation receipt exists for this provider deployment.'
+                        : `The transformation receipt is unreadable or invalid: ${error instanceof Error ? error.message : String(error)}`,
+                }],
+        };
+    }
+    const findings = [];
+    if (options.source?.verification === 'failed') {
+        findings.push({ kind: 'source-verification-failure', message: 'The canonical source subject did not verify.' });
+    }
+    else if (options.source && options.source.sha256 !== receipt.source.sha256) {
+        findings.push({
+            kind: 'stale-output',
+            message: 'The deployed output was generated from an older canonical source subject.',
+            expected: options.source.sha256,
+            actual: receipt.source.sha256,
+        });
+    }
+    if (options.transformer) {
+        for (const key of ['id', 'version', 'providerAdapter', 'providerAdapterVersion']) {
+            if (options.transformer[key] !== receipt.transformer[key]) {
+                findings.push({
+                    kind: 'transformation-mismatch',
+                    message: `The recorded ${key} does not match the active transformer.`,
+                    expected: options.transformer[key],
+                    actual: receipt.transformer[key],
+                });
+            }
+        }
+    }
+    for (const output of receipt.outputs) {
+        try {
+            const bytes = await readRegularOutput(options.outputRoot ?? options.projectRoot, output.path);
+            const actual = digest(bytes);
+            if (actual !== output.sha256 || bytes.byteLength !== output.bytes) {
+                findings.push({
+                    kind: 'user-modification',
+                    path: output.path,
+                    message: 'A generated provider output differs from its recorded receipt.',
+                    expected: output.sha256,
+                    actual,
+                });
+            }
+        }
+        catch (error) {
+            const unsafeType = error instanceof Error
+                && (error.message.includes('must be a regular file') || error.message.includes('outside its configured root'));
+            findings.push({
+                kind: unsafeType ? 'user-modification' : 'stale-output',
+                path: output.path,
+                message: unsafeType
+                    ? 'A receipt-bound output was replaced by a symbolic link, non-regular file, or path outside its configured root.'
+                    : error.code === 'ENOENT'
+                        ? 'A receipt-bound generated output is missing (partial deployment).'
+                        : `A receipt-bound generated output could not be read: ${error instanceof Error ? error.message : String(error)}`,
+                expected: output.sha256,
+            });
+        }
+    }
+    return {
+        status: findings.length === 0 ? 'verified' : 'drifted',
+        receiptPath,
+        checkedOutputs: receipt.outputs.length,
+        findings,
+    };
+}
+//# sourceMappingURL=transformation-receipt.js.map

package/dist/src/resources/web-release.d.ts

@@ -1,5 +1,6 @@
 export declare const DEFAULT_RESOURCE_BASE_URL = "https://releases.aiwg.io";
 export declare const AIWG_RELEASE_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA8BsJ2vjuHBReexz328sknfL7MKUtxynX6MGfqFVMD38=\n-----END PUBLIC KEY-----";
+declare const ARTIFACT_ATTESTATION_MEDIA_TYPE = "application/vnd.aiwg.artifact-attestation.v1+json";
 export type ResourceSource = "local" | "web" | "auto";
 export type ResourceSelector = {
     kind: "exact";
@@ -61,6 +62,14 @@ export interface VerifiedReleaseDescriptor {
     path: string;
     size: number;
     sha256: string;
+    mediaType?: string;
+    attestation?: VerifiedReleaseAttestationDescriptor;
+}
+export interface VerifiedReleaseAttestationDescriptor {
+    path: string;
+    size: number;
+    sha256: string;
+    mediaType: typeof ARTIFACT_ATTESTATION_MEDIA_TYPE;
 }
 export interface VerifiedWebRelease {
     selector: string;
@@ -79,6 +88,7 @@ export interface VerifiedWebRelease {
     fortemiExportSha256: string;
     fortemiExportSize: number;
     channelSequence?: number;
+    channelExpiresAt?: string;
     descriptors: ReadonlyMap<string, VerifiedReleaseDescriptor>;
 }
 export interface VerifiedRawResourceOptions extends Pick<WebReleaseOptions, "baseUrl" | "fetcher" | "credentialProvider" | "allowInsecureLoopbackHttp"> {
@@ -103,4 +113,5 @@ export declare function loadResourceTrustRootFile(pathname: string): Buffer;
 export declare function resolveWebRelease(options?: WebReleaseOptions): Promise<VerifiedWebRelease>;
 export declare function fetchVerifiedRawResource(release: VerifiedWebRelease, resourcePath: string, options?: VerifiedRawResourceOptions): Promise<Buffer>;
 export declare function createWebReleaseTestOptions(baseUrl: string, overrides?: Omit<WebReleaseOptions, "baseUrl" | "allowInsecureLoopbackHttp">): WebReleaseOptions;
+export {};
 //# sourceMappingURL=web-release.d.ts.map

package/dist/src/resources/web-release.js

@@ -12,6 +12,10 @@ const CHANNEL_PATTERN = /^[a-z][a-z0-9-]{0,31}$/;
 const SHA256_PATTERN = /^[0-9a-f]{64}$/;
 const DIGEST_SELECTOR_PATTERN = /^sha256:([0-9a-f]{64})$/;
 const SIGNATURE_PATTERN = /^(?:[A-Za-z0-9+/]{4}){21}(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)$/;
+const RFC3339_UTC_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+const MEDIA_TYPE_PATTERN = /^[a-z0-9][a-z0-9!#$&^_.+-]{0,63}\/[a-z0-9][a-z0-9!#$&^_.+-]{0,127}$/;
+const ARTIFACT_ATTESTATION_MEDIA_TYPE = "application/vnd.aiwg.artifact-attestation.v1+json";
+const ARTIFACT_ATTESTATION_SUFFIX = ".aiwg-attestation.json";
 const RELEASE_MANIFEST_SCHEMAS = new Set([
     "aiwg.resource-manifest/v1",
     "aiwg.resource-manifest/v2",
@@ -117,7 +121,7 @@ function assertSafeRelativePath(value, label) {
         throw new Error(`${label} is not a safe relative path`);
     }
 }
-function descriptorFrom(value, descriptorPath) {
+function descriptorBaseFrom(value, descriptorPath) {
     if (!isRecord(value))
         throw new Error(`release descriptor for ${descriptorPath} must be an object`);
     assertSafeRelativePath(value.path, `release descriptor path for ${descriptorPath}`);
@@ -127,7 +131,34 @@ function descriptorFrom(value, descriptorPath) {
     if (typeof value.sha256 !== "string" || !SHA256_PATTERN.test(value.sha256)) {
         throw new Error(`release descriptor digest for ${value.path} is invalid`);
     }
-    return { path: value.path, size: value.size, sha256: value.sha256 };
+    if (value.mediaType !== undefined && (typeof value.mediaType !== "string" || !MEDIA_TYPE_PATTERN.test(value.mediaType))) {
+        throw new Error(`release descriptor mediaType for ${value.path} is invalid`);
+    }
+    return {
+        path: value.path,
+        size: value.size,
+        sha256: value.sha256,
+        ...(typeof value.mediaType === "string" ? { mediaType: value.mediaType } : {}),
+    };
+}
+function descriptorFrom(value, descriptorPath) {
+    const descriptor = descriptorBaseFrom(value, descriptorPath);
+    if (!isRecord(value) || value.attestation === undefined)
+        return descriptor;
+    if (!descriptor.mediaType) {
+        throw new Error(`release descriptor ${descriptor.path} with an attestation must declare mediaType`);
+    }
+    const attestation = descriptorBaseFrom(value.attestation, `${descriptor.path} attestation`);
+    if (attestation.path !== `${descriptor.path}${ARTIFACT_ATTESTATION_SUFFIX}`) {
+        throw new Error(`release attestation descriptor for ${descriptor.path} is not adjacent to its artifact`);
+    }
+    if (attestation.mediaType !== ARTIFACT_ATTESTATION_MEDIA_TYPE) {
+        throw new Error(`release attestation descriptor for ${descriptor.path} has an invalid mediaType`);
+    }
+    if (isRecord(value.attestation) && value.attestation.attestation !== undefined) {
+        throw new Error(`release attestation descriptor for ${descriptor.path} must not contain another attestation`);
+    }
+    return { ...descriptor, attestation: attestation };
 }
 function validateReleaseManifest(value, version) {
     if (!isRecord(value) || typeof value.schemaVersion !== "string" || !RELEASE_MANIFEST_SCHEMAS.has(value.schemaVersion)) {
@@ -157,12 +188,24 @@ function validateReleaseManifest(value, version) {
         if (descriptors.has(descriptor.path))
             throw new Error(`duplicate release descriptor path: ${descriptor.path}`);
         descriptors.set(descriptor.path, descriptor);
+        if (descriptor.attestation) {
+            if (descriptors.has(descriptor.attestation.path)) {
+                throw new Error(`duplicate release descriptor path: ${descriptor.attestation.path}`);
+            }
+            descriptors.set(descriptor.attestation.path, descriptor.attestation);
+        }
     };
     for (const bundle of value.bundles) {
         if (!isRecord(bundle) || typeof bundle.filename !== "string" || !/^[a-z0-9-]+\.tar\.zst$/.test(bundle.filename)) {
             throw new Error("release manifest contains an unsafe bundle filename");
         }
-        add(descriptorFrom({ path: `bundles/${bundle.filename}`, size: bundle.size, sha256: bundle.sha256 }, bundle.filename));
+        add(descriptorFrom({
+            path: `bundles/${bundle.filename}`,
+            size: bundle.size,
+            sha256: bundle.sha256,
+            mediaType: bundle.mediaType,
+            attestation: bundle.attestation,
+        }, bundle.filename));
     }
     for (const file of value.files)
         add(descriptorFrom(file, "file"));
@@ -187,6 +230,16 @@ function validateChannelManifest(value, channel) {
     if (typeof value.releaseManifestSha256 !== "string" || !SHA256_PATTERN.test(value.releaseManifestSha256)) {
         throw new Error(`channel ${channel} has an invalid release manifest digest`);
     }
+    if (value.expiresAt !== undefined) {
+        if (typeof value.expiresAt !== "string" ||
+            !RFC3339_UTC_PATTERN.test(value.expiresAt) ||
+            !Number.isFinite(Date.parse(value.expiresAt))) {
+            throw new Error(`channel ${channel} has an invalid expiry`);
+        }
+        if (Date.parse(value.expiresAt) <= Date.now()) {
+            throw new Error(`channel ${channel} signed metadata has expired`);
+        }
+    }
     return value;
 }
 function validateVersionIndex(value) {
@@ -1054,7 +1107,8 @@ export async function resolveWebRelease(options = {}) {
         const cached = readCachedChannel(cacheRoot, selector.value, publicKeyPem);
         if (!cached)
             throw new Error(`AIWG resource channel ${selector.value} is not cached; offline mode cannot fetch it`);
-        return resolveOfflineExact(cacheRoot, selector, cached.manifest.version, publicKeyPem, base, cached.manifest.releaseManifestSha256, cached.manifest.sequence);
+        const release = resolveOfflineExact(cacheRoot, selector, cached.manifest.version, publicKeyPem, base, cached.manifest.releaseManifestSha256, cached.manifest.sequence);
+        return cached.manifest.expiresAt ? { ...release, channelExpiresAt: cached.manifest.expiresAt } : release;
     }
     const fetcher = authorize;
     if (!fetcher)
@@ -1071,7 +1125,8 @@ export async function resolveWebRelease(options = {}) {
     if (fetched.notModified) {
         cacheChannel(cacheRoot, prior.manifest, prior.bytes, prior.signatureBytes, prior.digest, fetched.validator);
         options.onDiagnostic?.({ resource: "channel", outcome: "conditional-hit", validator: prior.validator.etag ? "etag" : "last-modified" });
-        return fetchAndCacheRelease(base, fetcher, cacheRoot, selector, prior.manifest.version, publicKeyPem, prior.manifest.releaseManifestSha256, prior.manifest.sequence);
+        const release = await fetchAndCacheRelease(base, fetcher, cacheRoot, selector, prior.manifest.version, publicKeyPem, prior.manifest.releaseManifestSha256, prior.manifest.sequence);
+        return prior.manifest.expiresAt ? { ...release, channelExpiresAt: prior.manifest.expiresAt } : release;
     }
     const channelBytes = fetched.bytes;
     const channelSignatureBytes = await fetchBytes(fetcher, resourceUrl(base, `${channelPrefix}.sig`), `channel ${selector.value} signature`, MAX_SIGNATURE_BYTES);
@@ -1090,7 +1145,7 @@ export async function resolveWebRelease(options = {}) {
     const release = await fetchAndCacheRelease(base, fetcher, cacheRoot, selector, channel.version, publicKeyPem, channel.releaseManifestSha256, channel.sequence);
     cacheChannel(cacheRoot, channel, channelBytes, channelSignatureBytes, channelDigest, fetched.validator);
     options.onDiagnostic?.({ resource: "channel", outcome: prior?.validator ? "revalidated" : "unconditional", validator: fetched.validator?.etag ? "etag" : fetched.validator?.lastModified ? "last-modified" : "none" });
-    return release;
+    return channel.expiresAt ? { ...release, channelExpiresAt: channel.expiresAt } : release;
 }
 export async function fetchVerifiedRawResource(release, resourcePath, options = {}) {
     assertSafeRelativePath(resourcePath, "raw resource path");

package/dist/src/security/artifact-attestation.js

@@ -0,0 +1,117 @@
+import { createPrivateKey, createPublicKey, sign as signBytes, } from 'node:crypto';
+import { canonicalJson, dssePae, publicKeyFingerprint, sha256 } from './artifact-trust.js';
+export const ARTIFACT_ATTESTATION_MEDIA_TYPE = 'application/vnd.aiwg.artifact-attestation.v1+json';
+export const ARTIFACT_PROVENANCE_PREDICATE_TYPE = 'https://aiwg.io/attestations/artifact-provenance/v1';
+export const IN_TOTO_STATEMENT_V1 = 'https://in-toto.io/Statement/v1';
+export const DSSE_IN_TOTO_PAYLOAD_TYPE = 'application/vnd.in-toto+json';
+function assertNonEmpty(value, label) {
+    if (!value)
+        throw new Error(`${label} must not be empty`);
+}
+function assertTimestamp(value, label) {
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`${label} must be an RFC 3339 date-time`);
+    return parsed;
+}
+function assertSha256(value, label) {
+    if (!/^[a-f0-9]{64}$/.test(value))
+        throw new Error(`${label} must be a lowercase SHA-256 digest`);
+}
+function validateDescriptor(descriptor, label) {
+    assertNonEmpty(descriptor.name, `${label}.name`);
+    assertSha256(descriptor.digest.sha256, `${label}.digest.sha256`);
+}
+/** Build the exact canonical in-toto bytes that DSSE signs. */
+export function createArtifactProvenanceStatement(options) {
+    assertNonEmpty(options.artifact.name, 'artifact.name');
+    assertNonEmpty(options.assetType, 'assetType');
+    assertNonEmpty(options.publisher.id, 'publisher.id');
+    assertNonEmpty(options.publisher.namespace, 'publisher.namespace');
+    assertNonEmpty(options.publication.version, 'publication.version');
+    assertNonEmpty(options.publication.channel, 'publication.channel');
+    if (!Number.isSafeInteger(options.publication.sequence) || options.publication.sequence < 1) {
+        throw new Error('publication.sequence must be a positive safe integer');
+    }
+    const issuedAt = assertTimestamp(options.issuedAt, 'issuedAt');
+    const notBefore = options.notBefore ? assertTimestamp(options.notBefore, 'notBefore') : undefined;
+    const expiresAt = options.expiresAt ? assertTimestamp(options.expiresAt, 'expiresAt') : undefined;
+    if (notBefore !== undefined && expiresAt !== undefined && expiresAt <= notBefore) {
+        throw new Error('expiresAt must follow notBefore');
+    }
+    if (expiresAt !== undefined && expiresAt <= issuedAt)
+        throw new Error('expiresAt must follow issuedAt');
+    for (const [index, dependency] of (options.dependencies ?? []).entries()) {
+        validateDescriptor(dependency, `dependencies[${index}]`);
+    }
+    for (const [index, material] of (options.derivation?.materials ?? []).entries()) {
+        if (material.name !== undefined)
+            assertNonEmpty(material.name, `derivation.materials[${index}].name`);
+        assertNonEmpty(material.uri, `derivation.materials[${index}].uri`);
+        if (material.mediaType !== undefined)
+            assertNonEmpty(material.mediaType, `derivation.materials[${index}].mediaType`);
+        assertSha256(material.digest.sha256, `derivation.materials[${index}].digest.sha256`);
+    }
+    const subject = {
+        name: options.artifact.name,
+        ...(options.artifact.uri ? { uri: options.artifact.uri } : {}),
+        ...(options.artifact.mediaType ? { mediaType: options.artifact.mediaType } : {}),
+        digest: { sha256: sha256(options.artifact.bytes) },
+    };
+    return {
+        _type: IN_TOTO_STATEMENT_V1,
+        subject: [subject],
+        predicateType: ARTIFACT_PROVENANCE_PREDICATE_TYPE,
+        predicate: {
+            schemaVersion: 'aiwg.artifact-provenance.v1',
+            assetType: options.assetType,
+            publisher: options.publisher,
+            publication: options.publication,
+            issuedAt: options.issuedAt,
+            ...(options.notBefore ? { notBefore: options.notBefore } : {}),
+            ...(options.expiresAt ? { expiresAt: options.expiresAt } : {}),
+            ...(options.derivation ? { derivation: options.derivation } : {}),
+            ...(options.provenanceGraph ? { provenanceGraph: options.provenanceGraph } : {}),
+            ...(options.dependencies ? { dependencies: options.dependencies } : {}),
+        },
+    };
+}
+/** Create a portable public-key DSSE attestation over exact canonical payload bytes. */
+export function createArtifactAttestation(options) {
+    const privateKey = options.privateKey instanceof Object && 'type' in options.privateKey
+        ? options.privateKey
+        : createPrivateKey(options.privateKey);
+    if (privateKey.asymmetricKeyType !== 'ed25519')
+        throw new Error('artifact attestation key must be Ed25519');
+    const publicKey = createPublicKey(privateKey);
+    const publicKeyPem = publicKey.export({ type: 'spki', format: 'pem' }).toString();
+    const statement = createArtifactProvenanceStatement(options);
+    const payload = Buffer.from(canonicalJson(statement), 'utf8');
+    const signature = signBytes(null, dssePae(DSSE_IN_TOTO_PAYLOAD_TYPE, payload), privateKey);
+    return {
+        mediaType: ARTIFACT_ATTESTATION_MEDIA_TYPE,
+        envelope: {
+            payloadType: DSSE_IN_TOTO_PAYLOAD_TYPE,
+            payload: payload.toString('base64'),
+            signatures: [{ keyid: publicKeyFingerprint(publicKeyPem), sig: signature.toString('base64') }],
+        },
+        verificationMaterial: {
+            kind: 'public-key',
+            algorithm: 'ed25519',
+            publicKey: publicKeyPem,
+        },
+    };
+}
+export function serializeArtifactAttestation(attestation) {
+    return Buffer.from(`${canonicalJson(attestation)}\n`, 'utf8');
+}
+export function describeAttestationSidecar(artifactPath, attestationBytes) {
+    assertNonEmpty(artifactPath, 'artifactPath');
+    return {
+        path: `${artifactPath}.aiwg-attestation.json`,
+        sha256: sha256(attestationBytes),
+        bytes: attestationBytes.byteLength,
+        mediaType: ARTIFACT_ATTESTATION_MEDIA_TYPE,
+    };
+}
+//# sourceMappingURL=artifact-attestation.js.map