@learncard/credential-library 2.0.4 → 2.1.0

package/src/__tests__/curated-examples.test.ts

@@ -0,0 +1,248 @@
+import { describe, expect, it } from 'vitest';
+import { UnsignedAchievementCredentialValidator } from '@learncard/types';
+
+import {
+    ALL_FIXTURES,
+    obv3FoodAllergenPractice,
+    obv3FoodAllergenFacilitator,
+    obv3FoodAllergenPracticeFr,
+    obv3PhishingTransfer,
+    customCourseEnrollment,
+    customExamAccommodation,
+    clrMixedRolePortfolio,
+} from '../fixtures';
+import { prepareFixture } from '../prepare';
+
+type JsonRecord = Record<string, unknown>;
+
+const asRecord = (value: unknown): JsonRecord => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Expected a credential object');
+    }
+    return value as JsonRecord;
+};
+const asRecords = (value: unknown): JsonRecord[] => {
+    if (!Array.isArray(value)) throw new Error('Expected a credential array');
+    return value.map(asRecord);
+};
+const subjectOf = (credential: JsonRecord): JsonRecord => asRecord(credential.credentialSubject);
+const achievementOf = (credential: JsonRecord): JsonRecord =>
+    asRecord(subjectOf(credential).achievement);
+
+const fixtures = [
+    obv3FoodAllergenPractice,
+    obv3FoodAllergenFacilitator,
+    obv3FoodAllergenPracticeFr,
+    obv3PhishingTransfer,
+    customCourseEnrollment,
+    customExamAccommodation,
+    clrMixedRolePortfolio,
+];
+
+const expectResultReferences = (credential: JsonRecord): void => {
+    const descriptions = asRecords(achievementOf(credential).resultDescription);
+    const byId = new Map(descriptions.map(description => [description.id, description]));
+    expect(byId.size).toBe(descriptions.length);
+    for (const result of asRecords(subjectOf(credential).result)) {
+        const description = byId.get(result.resultDescription);
+        expect(description).toBeDefined();
+        if (!description) throw new Error('Missing result description');
+        if (result.achievedLevel || description.requiredLevel) {
+            const levels = asRecords(description.rubricCriterionLevel);
+            if (result.achievedLevel) {
+                expect(levels.some(level => level.id === result.achievedLevel)).toBe(true);
+            }
+            if (description.requiredLevel) {
+                expect(levels.some(level => level.id === description.requiredLevel)).toBe(true);
+            }
+        }
+    }
+};
+
+describe('Curated example coverage', () => {
+    it.each(fixtures)('$id is registered once, validated, and unsigned', fixture => {
+        expect(ALL_FIXTURES.filter(entry => entry.id === fixture.id)).toEqual([fixture]);
+        expect(fixture.source).toBe('synthetic');
+        expect(fixture.signed).toBe(false);
+        expect(fixture.validity).toBe('valid');
+        expect(fixture.validator).toBeDefined();
+        expect(fixture.validator?.safeParse(fixture.credential).success).toBe(true);
+        expect(fixture.credential.proof).toBeUndefined();
+    });
+
+    it('uses named issuer profiles while preserving shared and distinct issuer groups', () => {
+        const issuers = fixtures.map(fixture => asRecord(fixture.credential.issuer));
+        for (const issuer of issuers) {
+            expect(issuer.id).toMatch(/^did:/);
+            expect(issuer.type).toEqual(['Profile']);
+            expect(issuer.name).toBeTruthy();
+            expect(issuer.name).not.toMatch(/^https?:/);
+        }
+        expect(new Set(issuers.map(issuer => issuer.id)).size).toBe(5);
+        expect(obv3FoodAllergenPracticeFr.credential.issuer).toEqual(
+            obv3FoodAllergenPractice.credential.issuer
+        );
+        expect(obv3FoodAllergenFacilitator.credential.issuer).toEqual(
+            obv3FoodAllergenPractice.credential.issuer
+        );
+        for (const child of asRecords(
+            subjectOf(clrMixedRolePortfolio.credential).verifiableCredential
+        )) {
+            expect(child.issuer).toEqual(clrMixedRolePortfolio.credential.issuer);
+        }
+    });
+
+    it.each([obv3FoodAllergenPractice, obv3FoodAllergenPracticeFr])(
+        '$id expresses RubricScore within the declared range',
+        fixture => {
+            const subject = subjectOf(fixture.credential);
+            const [description] = asRecords(achievementOf(fixture.credential).resultDescription);
+            const [result] = asRecords(subject.result);
+            expect(description.resultType).toBe('RubricScore');
+            expect(description).toMatchObject({ valueMin: '0', valueMax: '4', requiredValue: '3' });
+            expect(result).toMatchObject({ value: '4', status: 'Completed' });
+            expect(Number(result.value)).toBeGreaterThanOrEqual(Number(description.requiredValue));
+            expect(Number(result.value)).toBeLessThanOrEqual(Number(description.valueMax));
+            expect(subject.role).toBe('learner');
+            expectResultReferences(fixture.credential);
+        }
+    );
+
+    it('keeps French text, scoring, alignment, and counterpart identities consistent', () => {
+        const english = achievementOf(obv3FoodAllergenPractice.credential);
+        const french = achievementOf(obv3FoodAllergenPracticeFr.credential);
+        expect(french.inLanguage).toBe('fr');
+        expect(french.name).toContain('Prévention');
+        expect(asRecord(french.criteria).narrative).toContain('Repère');
+        expect(french.alignment).toEqual(english.alignment);
+        const [englishScore] = asRecords(english.resultDescription);
+        const [frenchScore] = asRecords(french.resultDescription);
+        expect(frenchScore).toMatchObject({
+            resultType: englishScore.resultType,
+            valueMin: englishScore.valueMin,
+            valueMax: englishScore.valueMax,
+            requiredValue: englishScore.requiredValue,
+        });
+        expect(french.id).not.toBe(english.id);
+        expect(frenchScore.id).not.toBe(englishScore.id);
+        expect(obv3FoodAllergenPracticeFr.credential.id).not.toBe(
+            obv3FoodAllergenPractice.credential.id
+        );
+        expect(subjectOf(obv3FoodAllergenPracticeFr.credential).id).toBe(
+            subjectOf(obv3FoodAllergenPractice.credential).id
+        );
+    });
+
+    it('assesses the matched facilitator as an instructor, separately from learner practice', () => {
+        const instructor = subjectOf(obv3FoodAllergenFacilitator.credential);
+        const learner = subjectOf(obv3FoodAllergenPractice.credential);
+        const achievement = asRecord(instructor.achievement);
+        expect(instructor.id).toBe(learner.id);
+        expect(instructor.role).toBe('instructor');
+        expect(achievement.description).toContain('Assesses teaching performance');
+        expect(asRecords(achievement.alignment).map(alignment => alignment.targetName)).toEqual([
+            'Instructing',
+        ]);
+        expect(asRecords(achievement.resultDescription)[0].resultType).toBe('PerformanceLevel');
+        expectResultReferences(obv3FoodAllergenFacilitator.credential);
+    });
+
+    it('preserves achieved-level-only and raw-score branches in the same project', () => {
+        const [level, score] = asRecords(subjectOf(obv3PhishingTransfer.credential).result);
+        expect(level.achievedLevel).toBeDefined();
+        expect(level).not.toHaveProperty('value');
+        expect(score.value).toBe('9');
+        expect(score).not.toHaveProperty('achievedLevel');
+        expect(
+            asRecords(achievementOf(obv3PhishingTransfer.credential).resultDescription).map(
+                description => description.resultType
+            )
+        ).toEqual(['RubricCriterionLevel', 'RawScore']);
+        expectResultReferences(obv3PhishingTransfer.credential);
+    });
+
+    it.each([customCourseEnrollment, customExamAccommodation])(
+        '$id remains a custom administrative claim with no achievement',
+        fixture => {
+            const subject = subjectOf(fixture.credential);
+            expect(fixture.spec).toBe('custom');
+            expect(fixture.profile).toBe('generic');
+            expect(subject.designation).toBeDefined();
+            expect(subject.claimRole).toBeDefined();
+            expect(subject.claimScope).toBeDefined();
+            expect(subject).not.toHaveProperty('achievement');
+            expect(subject).not.toHaveProperty('result');
+            expect(subject).not.toHaveProperty('diagnosis');
+            const context = fixture.credential['@context'];
+            expect(Array.isArray(context)).toBe(true);
+            if (!Array.isArray(context)) throw new Error('Expected inline context');
+            const terms = asRecord(context[1]);
+            expect(terms[fixture.credential.type[1]]).toBeDefined();
+        }
+    );
+
+    it('keeps mixed CLR roles, mirrored definitions, and canonical achievement references', () => {
+        expect(clrMixedRolePortfolio.credential['@context']).toEqual([
+            'https://www.w3.org/ns/credentials/v2',
+            'https://purl.imsglobal.org/spec/clr/v2p0/context.json',
+            'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json',
+        ]);
+        const subject = subjectOf(clrMixedRolePortfolio.credential);
+        const children = asRecords(subject.verifiableCredential);
+        expect(children).toHaveLength(3);
+        expect(new Set(children.map(child => child.id)).size).toBe(3);
+        expect(children.map(child => subjectOf(child).role)).toEqual([
+            'learner',
+            'learner',
+            'instructor',
+        ]);
+        expect(subject.achievement).toEqual(children.map(achievementOf));
+        const achievementIds = new Set(children.map(child => achievementOf(child).id));
+        const credentialIds = new Set(children.map(child => child.id));
+        for (const association of asRecords(subject.association)) {
+            expect(association.type).toBe('Association');
+            expect(achievementIds.has(association.sourceId)).toBe(true);
+            expect(achievementIds.has(association.targetId)).toBe(true);
+            expect(credentialIds.has(association.sourceId)).toBe(false);
+            expect(credentialIds.has(association.targetId)).toBe(false);
+        }
+        for (const child of children) {
+            expect(subjectOf(child).id).toBe(subject.id);
+            expect(child.proof).toBeUndefined();
+            expect(UnsignedAchievementCredentialValidator.safeParse(child).success).toBe(true);
+            expectResultReferences(child);
+        }
+    });
+
+    it('prepares CLR children together without changing source data or child issuer claims', () => {
+        const before = JSON.stringify(clrMixedRolePortfolio.credential);
+        const originalSubject = subjectOf(clrMixedRolePortfolio.credential);
+        const originalChildren = asRecords(originalSubject.verifiableCredential);
+        const prepared = prepareFixture(clrMixedRolePortfolio, {
+            issuerDid: 'did:example:portfolio-test-issuer',
+            subjectDid: 'did:example:portfolio-test-subject',
+            validFrom: '2026-10-04T12:00:00Z',
+            freshIds: true,
+        });
+        expect(asRecord(prepared.issuer).id).toBe('did:example:portfolio-test-issuer');
+        expect(asRecord(prepared.issuer).name).toBe(
+            asRecord(clrMixedRolePortfolio.credential.issuer).name
+        );
+        expect(prepared.validFrom).toBe('2026-10-04T12:00:00Z');
+        const subject = subjectOf(prepared);
+        expect(subject.id).toBe('did:example:portfolio-test-subject');
+        expect(prepared.id).not.toBe(clrMixedRolePortfolio.credential.id);
+        const children = asRecords(subject.verifiableCredential);
+        for (const [index, child] of children.entries()) {
+            expect(subjectOf(child).id).toBe(subject.id);
+            expect(child.id).not.toBe(originalChildren[index].id);
+            expect(child.issuer).toEqual(originalChildren[index].issuer);
+            expect(child.validFrom).toBe(originalChildren[index].validFrom);
+            expect(child.proof).toBeUndefined();
+            expectResultReferences(child);
+        }
+        expect(subject.achievement).toEqual(children.map(achievementOf));
+        expect(subject.association).toEqual(originalSubject.association);
+        expect(JSON.stringify(clrMixedRolePortfolio.credential)).toBe(before);
+    });
+});

package/src/__tests__/issuance.test.ts

@@ -60,6 +60,41 @@ describe('Credential issuance', () => {
         );
     });
 
+    describe('curated examples issue without remote contexts', () => {
+        // A deterministic, in-memory test identity; no account or persistent key writes.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let offlineWallet: any;
+
+        beforeAll(async () => {
+            offlineWallet = await initLearnCard({
+                seed: 'd'.repeat(64),
+                didkit,
+                allowRemoteContexts: false,
+            });
+        }, 30_000);
+
+        it.each([
+            'obv3/food-allergen-practice',
+            'obv3/food-allergen-facilitator',
+            'obv3/food-allergen-practice-fr',
+            'obv3/phishing-transfer',
+            'custom/course-enrollment',
+            'custom/exam-accommodation',
+            'clr/mixed-role-portfolio',
+        ])(
+            '%s',
+            async id => {
+                const prepared = prepareFixture(getFixture(id), {
+                    issuerDid: offlineWallet.id.did(),
+                    subjectDid: 'did:example:curated-test-subject',
+                });
+                const signed = await offlineWallet.invoke.issueCredential(prepared);
+                expect(signed.proof).toBeDefined();
+            },
+            15_000
+        );
+    });
+
     it('issues the full CLR fixture without remote contexts', async () => {
         const offlineWallet = await initLearnCard({
             seed: 'b'.repeat(64),

package/src/__tests__/registry.test.ts

@@ -582,6 +582,37 @@ describe('prepareFixture', () => {
         expect(subject.id).toBe(subjectDid);
     });
 
+    it('preserves signed credentials nested in a CLR', () => {
+        const fixture = getFixture('vc-v2/basic');
+        const signedEmbeddedCredential = {
+            '@context': ['https://www.w3.org/ns/credentials/v2'],
+            id: fixture.credential.id,
+            type: ['VerifiableCredential'],
+            issuer: 'did:example:nested-issuer',
+            validFrom: '2025-01-01T00:00:00Z',
+            credentialSubject: { id: 'did:example:signed-subject' },
+            proof: { type: 'DataIntegrityProof', proofValue: 'signed-value' },
+        };
+        const prepared = prepareFixture(
+            {
+                ...fixture,
+                credential: {
+                    ...fixture.credential,
+                    credentialSubject: {
+                        id: 'did:example:old-root',
+                        verifiableCredential: [signedEmbeddedCredential],
+                    },
+                },
+            },
+            { issuerDid, subjectDid }
+        );
+        const subject = prepared.credentialSubject as UnknownRecord;
+        const embedded = subject.verifiableCredential as UnknownRecord[];
+
+        expect(subject.id).toBe(subjectDid);
+        expect(embedded[0]).toEqual(signedEmbeddedCredential);
+    });
+
     it('generates fresh UUIDs for id fields by default', () => {
         const fixture = getFixture('obv3/minimal-badge');
         const prepared = prepareFixture(fixture, { issuerDid });

package/src/bundles/index.ts

@@ -0,0 +1,19 @@
+import type { CredentialBundle } from './types';
+import { studentBundle } from './student';
+
+const BUNDLES: Readonly<Record<string, CredentialBundle>> = {
+    [studentBundle.id]: studentBundle,
+};
+
+export const getBundle = (id: string): CredentialBundle => {
+    const bundle = BUNDLES[id];
+
+    if (!bundle) {
+        throw new Error(`Unknown credential bundle: ${id}`);
+    }
+
+    return bundle;
+};
+
+export { studentBundle } from './student';
+export type { CredentialBundle, CredentialBundleEntry, CredentialBundleIssuer } from './types';

package/src/bundles/student.ts

@@ -0,0 +1,251 @@
+import type { CredentialBundle, CredentialBundleIssuer } from './types';
+
+const ISSUERS = {
+    hillValleyHigh: {
+        profileId: 'sample-hill-valley-high',
+        displayName: 'Hill Valley High School',
+        image: 'https://cdn.filestackcontent.com/rko7HmtCQ5aI5gfS3r1o',
+    },
+    worldScouting: {
+        profileId: 'sample-world-scouting',
+        displayName: 'World Scouting',
+        image: 'https://cdn.filestackcontent.com/tY9KCX5T4mQK9GERTGhf',
+    },
+    royCharleston: {
+        profileId: 'sample-roy-charleston',
+        displayName: 'Roy Charleston',
+    },
+    toefl: {
+        profileId: 'sample-toefl',
+        displayName: 'TOEFL',
+        image: 'https://cdn.filestackcontent.com/s6P4u2TVSaeHDVS64UKw',
+    },
+    collegeBoard: {
+        profileId: 'sample-college-board',
+        displayName: 'College Board',
+        image: 'https://cdn.filestackcontent.com/TMTJ1xuKSKWuPOxMc2fQ',
+    },
+    arcadiaMediaLabs: {
+        profileId: 'sample-arcadia-media-labs',
+        displayName: 'Arcadia Media Labs',
+        image: 'https://cdn.filestackcontent.com/bfPLw9dQfWhpVYorZVfA',
+    },
+    codeRiseAcademy: {
+        profileId: 'sample-code-rise-academy',
+        displayName: 'CodeRise Academy',
+        image: 'https://cdn.filestackcontent.com/nHMhLsvFQmKU2TGKYzHK',
+    },
+    redwoodValleyUniversity: {
+        profileId: 'sample-redwood-valley-university',
+        displayName: 'Redwood Valley University',
+        image: 'https://cdn.filestackcontent.com/kok4oellRhKa2mWRllZS',
+    },
+    learningEconomy: {
+        profileId: 'sample-learning-economy',
+        displayName: 'Learning Economy',
+        image: 'https://cdn.filestackcontent.com/iLpqAJWYTDCxARqo6LN4',
+    },
+    oliviaTrujillo: {
+        profileId: 'sample-olivia-trujillo',
+        displayName: 'Olivia Trujillo',
+        image: 'https://cdn.filestackcontent.com/OKefWUSvTnuHELTSGH0z',
+    },
+    summitAccessibilityOffice: {
+        profileId: 'sample-summit-accessibility-office',
+        displayName: 'Summit Accessibility Office',
+        image: 'https://cdn.filestackcontent.com/JEAA9HfUSNa8SPp8nQiU',
+    },
+    kikuhanaInternationalUniversity: {
+        profileId: 'sample-kikuhana-international-university',
+        displayName: 'Kikuhana International University',
+        image: 'https://cdn.filestackcontent.com/HLQCIyRMQgSnxZtKmevv',
+    },
+    campTallPines: {
+        profileId: 'sample-camp-tall-pines',
+        displayName: 'Camp Tall Pines',
+        image: 'https://cdn.filestackcontent.com/frBHDn7SV2f8HKcxkGrj',
+    },
+    summitMarketing: {
+        profileId: 'sample-summit-marketing',
+        displayName: 'Summit Marketing',
+        image: 'https://cdn.filestackcontent.com/Q5BWlBiRJevkBlBlYaN2',
+    },
+    motlowStateCollege: {
+        profileId: 'sample-motlow-state-college',
+        displayName: 'Motlow State College',
+        image: 'https://cdn.filestackcontent.com/rjXzVVEjRVu0RSb8gYPZ',
+    },
+} as const satisfies Record<string, CredentialBundleIssuer>;
+
+export const studentBundle: CredentialBundle = {
+    id: 'student',
+    displayName: 'Student',
+    blurb: 'Explore academic, creative, leadership, service, and work credentials in a LearnCard.',
+    entries: [
+        {
+            fixtureId: 'obv3/student-afterschool-program-mentor',
+            validFromOffsetDays: -79,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-environment-badge',
+            validFromOffsetDays: -79,
+            issuer: ISSUERS.worldScouting,
+        },
+        {
+            fixtureId: 'obv3/student-rock-climbing-mentor',
+            validFromOffsetDays: -79,
+            issuer: ISSUERS.royCharleston,
+        },
+        {
+            fixtureId: 'obv3/student-park-cleanup-helper',
+            validFromOffsetDays: -79,
+            issuer: ISSUERS.royCharleston,
+        },
+        {
+            fixtureId: 'obv3/student-first-place-science-fair',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-toefl-certification',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.toefl,
+        },
+        {
+            fixtureId: 'obv3/student-senior-capstone-project',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-sat-score',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.collegeBoard,
+        },
+        {
+            fixtureId: 'obv3/student-hill-valley-high-school-diploma',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-biology-101',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-ai-fundamentals',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.arcadiaMediaLabs,
+        },
+        {
+            fixtureId: 'obv3/student-technical-bootcamp',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.codeRiseAcademy,
+        },
+        {
+            fixtureId: 'clr/student-official-academic-transcript',
+            validFromOffsetDays: -494,
+            issuer: ISSUERS.redwoodValleyUniversity,
+        },
+        {
+            fixtureId: 'obv3/student-ba-interactive-media-design',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.redwoodValleyUniversity,
+        },
+        {
+            fixtureId: 'obv3/student-ap-math-course',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-animated-short',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.learningEconomy,
+        },
+        {
+            fixtureId: 'obv3/student-capstone-project',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-skyway-magazine',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.learningEconomy,
+        },
+        {
+            fixtureId: 'obv3/student-photo-contest-award',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.oliviaTrujillo,
+        },
+        {
+            fixtureId: 'obv3/student-design-portfolio',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.oliviaTrujillo,
+        },
+        {
+            fixtureId: 'obv3/student-workplace-ergonomic-assessment',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.summitAccessibilityOffice,
+        },
+        {
+            fixtureId: 'obv3/student-iep-documentation',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.summitAccessibilityOffice,
+        },
+        {
+            fixtureId: 'obv3/student-accessibility-services-registration',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.summitAccessibilityOffice,
+        },
+        {
+            fixtureId: 'obv3/student-extended-time-on-exams-approval',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.summitAccessibilityOffice,
+        },
+        {
+            fixtureId: 'obv3/student-mental-health-accommodation-letter',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.summitAccessibilityOffice,
+        },
+        {
+            fixtureId: 'obv3/student-study-abroad-program',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.kikuhanaInternationalUniversity,
+        },
+        {
+            fixtureId: 'obv3/student-camp-counselor',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.campTallPines,
+        },
+        {
+            fixtureId: 'obv3/student-president-of-class',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-resume',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.oliviaTrujillo,
+        },
+        {
+            fixtureId: 'obv3/student-internship',
+            validFromOffsetDays: -80,
+            issuer: ISSUERS.summitMarketing,
+        },
+        {
+            fixtureId: 'obv3/student-world-scouting-troop-id',
+            validFromOffsetDays: -431,
+            issuer: ISSUERS.worldScouting,
+        },
+        {
+            fixtureId: 'obv3/student-hill-valley-high-school-student-id',
+            validFromOffsetDays: -431,
+            issuer: ISSUERS.hillValleyHigh,
+        },
+        {
+            fixtureId: 'obv3/student-motlow-college-id',
+            validFromOffsetDays: -431,
+            issuer: ISSUERS.motlowStateCollege,
+        },
+    ],
+};

package/src/bundles/types.ts

@@ -0,0 +1,25 @@
+export interface CredentialBundleIssuer {
+    /** Namespaced profile ID created and owned by the sample seeder. */
+    profileId: `sample-${string}`;
+    /** Issuer name shown on the rendered credential. */
+    displayName: string;
+    /** Optional issuer avatar copied to the safe sample profile. */
+    image?: string;
+}
+
+export interface CredentialBundleEntry {
+    fixtureId: string;
+    /** Shift the fixture's issue date relative to the seed run. */
+    validFromOffsetDays: number;
+    /** Safe sample issuer used when publishing this credential. */
+    issuer: CredentialBundleIssuer;
+    /** Override the credential's display name after fixture preparation. */
+    name?: string;
+}
+
+export interface CredentialBundle {
+    id: string;
+    displayName: string;
+    blurb: string;
+    entries: readonly CredentialBundleEntry[];
+}