feat: integrate authored nightdrive soundtrack

tests/integration/materialize-empty-asset-set.test.mjs

@@ -57,6 +57,36 @@ describe('approved asset publication closure', () => {
     await expect(verifyApprovedAssetSet(root)).resolves.toBeUndefined();
   });
 
+  it('includes every soundtrack codec variant in the approved publication closure', async () => {
+    const root = await createScratchRepository();
+    const assets = [
+      ['soundtrack-intro-opus', 'nightdrive-intro.opus'],
+      ['soundtrack-intro-mp3', 'nightdrive-intro.mp3'],
+      ['soundtrack-main-opus', 'nightdrive-main.opus'],
+      ['soundtrack-main-mp3', 'nightdrive-main.mp3'],
+    ].map(([id, fileName], index) => {
+      const bytes = Buffer.from(`approved soundtrack asset ${index}`);
+      return { id, fileName, bytes, sha256: createHash('sha256').update(bytes).digest('hex') };
+    });
+    await writeFile(join(root, 'content/public/asset-manifest.json'), JSON.stringify({
+      assets: assets.map(({ id, fileName, sha256 }) => ({ id, fileName, sha256 })),
+    }));
+    await writeFile(join(root, 'content/public/portfolio-content.json'), JSON.stringify({
+      projects: { selected: [], additional: [] },
+      toolkit: [],
+      metadata: {},
+      soundtrack: {
+        intro: { opusAssetId: 'soundtrack-intro-opus', mp3AssetId: 'soundtrack-intro-mp3' },
+        main: { opusAssetId: 'soundtrack-main-opus', mp3AssetId: 'soundtrack-main-mp3' },
+      },
+    }));
+    await mkdir(join(root, 'inputs/prepared-assets'), { recursive: true });
+    await Promise.all(assets.map(({ fileName, bytes }) =>
+      writeFile(join(root, 'inputs/prepared-assets', fileName), bytes)));
+
+    await expect(verifyApprovedAssetSet(root)).resolves.toBeUndefined();
+  });
+
   it('rejects a symbolic-link prepared-asset directory', async () => {
     const root = await createScratchRepository();
     const target = join(root, 'outside');

tests/integration/nginx-config.test.ts

@@ -88,7 +88,7 @@ describe('generated Nginx static-host contract', () => {
 
     expect(config).toContain("default-src 'self'; script-src 'self' 'sha256-");
     expect(config).toContain("img-src 'self' data:");
-    expect(config).toContain("connect-src 'none'");
+    expect(config).toContain("connect-src 'self'");
     expect(config).toContain('add_header Strict-Transport-Security "max-age=31536000" always;');
     expect(config).toContain(`add_header X-Portfolio-Manifest-Digest "${releaseManifestDigest}" always;`);
     expect(config).toContain('gzip on;');

tests/integration/public-content.test.ts

@@ -42,6 +42,12 @@ describe('approved public portfolio projection', () => {
       ...content.toolkit.flatMap((group) => group.technologies.flatMap((technology) =>
         technology.assetId === undefined ? [] : [technology.assetId])),
       ...(content.metadata.socialPreviewAssetId === undefined ? [] : [content.metadata.socialPreviewAssetId]),
+      ...(content.soundtrack === undefined ? [] : [
+        content.soundtrack.intro.opusAssetId,
+        content.soundtrack.intro.mp3AssetId,
+        content.soundtrack.main.opusAssetId,
+        content.soundtrack.main.mp3AssetId,
+      ]),
     ];
     expect([...publishedReferences].sort()).toEqual(manifest.assets.map((asset) => asset.id).sort());
     expect(site).toEqual({

tests/integration/verify-artifacts.test.ts

@@ -57,6 +57,16 @@ const writeValidArtifacts = async (site?: SiteConfig) => {
   await mkdir(join(directory, 'assets'));
   const html = assemblePrerenderedHtml(template, manifest, await render('/', inputs), inputs);
   const hostArtifacts = createStaticHostArtifacts(createPageMetadata(inputs.content, inputs.manifest, inputs.site), inputs.site);
+  const publicAssets = inputs.manifest.assets
+    .map((asset) => ({
+      path: `assets/${asset.fileName}`,
+      bytesPath: resolve(repositoryRoot, 'inputs/prepared-assets', asset.fileName),
+    }))
+    .sort((left, right) => left.path.localeCompare(right.path));
+  const publicAssetBytes = await Promise.all(publicAssets.map(async (asset) => ({
+    ...asset,
+    bytes: await readFile(asset.bytesPath),
+  })));
   const contract = {
     schema: 'portfolio-artifact-contract/v1',
     buildId: inputs.site.buildId,
@@ -65,10 +75,14 @@ const writeValidArtifacts = async (site?: SiteConfig) => {
     modulePreloads: ['assets/index-test.js'],
     styles: ['assets/index-test.css'],
     viteAssets: [],
-    publicAssets: [],
+    publicAssets: publicAssets.map((asset) => asset.path),
     files: [
       { path: 'assets/index-test.css', sha256: sha256(clientStylesheet) },
       { path: 'assets/index-test.js', sha256: sha256(clientJavaScript) },
+      ...publicAssetBytes.map((asset) => ({
+        path: asset.path,
+        sha256: createHash('sha256').update(asset.bytes).digest('hex'),
+      })),
     ],
   } as const;
   await Promise.all([
@@ -78,6 +92,7 @@ const writeValidArtifacts = async (site?: SiteConfig) => {
     writeFile(join(directory, '_redirects.example'), hostArtifacts.redirects),
     writeFile(join(directory, 'assets/index-test.js'), clientJavaScript),
     writeFile(join(directory, 'assets/index-test.css'), clientStylesheet),
+    ...publicAssetBytes.map((asset) => writeFile(join(directory, asset.path), asset.bytes)),
     ...(hostArtifacts.sitemap === undefined
       ? []
       : [writeFile(join(directory, 'sitemap.xml'), hostArtifacts.sitemap)]),