@amazon/vinyl 1.2.0 → 2.0.4

package/dist/unit/types/current/track/TrackFactory.test.js

@@ -13,32 +13,21 @@ describe('createTrackFactory', () => {
     class MockTrack3 extends MockTrack {
     }
     let trackFactory;
+    function factory(Ctor) {
+        return {
+            validate() { },
+            createTrack(options) {
+                const track = new Ctor();
+                track.uri = options.uri;
+                return track;
+            },
+        };
+    }
     beforeEach(() => {
         trackFactory = createTrackFactory({
-            key1: {
-                validate() { },
-                createTrack(options) {
-                    const track = new MockTrack1();
-                    track.uri = options.uri;
-                    return track;
-                },
-            },
-            key2: {
-                validate() { },
-                createTrack(options) {
-                    const track = new MockTrack2();
-                    track.uri = options.uri;
-                    return track;
-                },
-            },
-            key3: {
-                validate() { },
-                createTrack(options) {
-                    const track = new MockTrack3();
-                    track.uri = options.uri;
-                    return track;
-                },
-            },
+            key1: factory(MockTrack1),
+            key2: factory(MockTrack2),
+            key3: factory(MockTrack3),
         });
     });
     it('maps track type keys to their respective factories', () => {
@@ -60,7 +49,6 @@ describe('createTrackFactory', () => {
         createTrackFactory({
             key1: {
                 validate() { },
-                // valid, key1 is assignable to key1
                 createTrack(_options) {
                     return new MockTrack1();
                 },

package/dist/unit/types/current/track/dash/createDashContentStreamFactories.test.js

@@ -15,6 +15,7 @@ describe('createDashContentStreamFactories', () => {
     const emptyTimeline = {
         periods: [],
         minBufferTime: 0,
+        getAdBreaks: () => Promise.resolve([]),
         getDuration: () => Promise.resolve(Infinity),
     };
     beforeEach(() => {

package/dist/unit/types/current/track/dash/createDashFactories.test.js

@@ -2,8 +2,9 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createDashFactories, DashManifestControllerImpl, MediaSourceControllerImpl, pickFirstBaseUrlSelector, QualitySelectorImpl, } from '@amazon/vinyl';
+import { createDashFactories, ManifestControllerImpl, MediaSourceControllerImpl, pickFirstBaseUrlSelector, QualitySelectorImpl, } from '@amazon/vinyl';
 import { createMockVinylDependencies, mockDashManifest, } from '@amazon/vinyl/vinylTestUtil';
+import { parseDashManifest } from '@amazon/vinyl-mpd-parser';
 import { createContainer } from '@amazon/vinyl-di';
 import { MockMediaSource, MockMediaSourceGlobal, } from '@amazon/vinyl-util/browserTestUtil';
 import { clone } from '@amazon/vinyl-util';
@@ -50,7 +51,7 @@ describe('createDashFactories', () => {
             baseUrlSelector: pickFirstBaseUrlSelector,
             segmentRequestInit: undefined,
             manifestProvider: any(Function),
-            manifestController: any(DashManifestControllerImpl),
+            manifestController: any(ManifestControllerImpl),
             mediaSourceFactory: any(Function),
             mediaQualityMetadataResolver: any(Function),
             mediaSourceController: any(MediaSourceControllerImpl),
@@ -59,6 +60,20 @@ describe('createDashFactories', () => {
             qualitySelector: any(QualitySelectorImpl),
         }));
     });
+    it('wires per-track option observables from the player options', () => {
+        const factoryCreator = createDashFactories(null);
+        const factories = factoryCreator(dashFactoryDeps)({
+            uri: 'test://manifest.mpd',
+            type: 'dash',
+            manifestProvider,
+        });
+        const deps = createContainer(factories).dependencies;
+        const options = dashFactoryDeps.options.value;
+        expect(deps.preferredAudioLanguage.value).toBe(options.preferredAudioLanguage);
+        expect(deps.allowedContentTypes.value).toBe(options.allowedContentTypes);
+        expect(deps.preferDescriptiveAudio.value).toBe(options.preferDescriptiveAudio);
+        expect(deps.abr.value).toBe(options.abr);
+    });
     it('provides streaming options to createContentStreamFactories', () => {
         const factoryCreator = createDashFactories({
             streaming: {
@@ -75,4 +90,50 @@ describe('createDashFactories', () => {
         const deps = createContainer(factories).dependencies;
         expect(deps.contentStreamFactory('audio')).toEqual(any(Object));
     });
+    it('creates a sidecar text track controller and populates from manifest', async () => {
+        const factoryCreator = createDashFactories(null);
+        const subtitleManifestXml = `<?xml version="1.0" encoding="UTF-8"?>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" mediaPresentationDuration="PT60S" minBufferTime="PT2S">
+  <Period>
+    <AdaptationSet contentType="audio" mimeType="audio/mp4" codecs="mp4a.40.2">
+      <Representation id="aud" bandwidth="128000"/>
+    </AdaptationSet>
+    <AdaptationSet contentType="text" mimeType="text/vtt" lang="en">
+      <Representation id="en-sub" bandwidth="100">
+        <BaseURL>subs/en.vtt</BaseURL>
+      </Representation>
+    </AdaptationSet>
+  </Period>
+</MPD>`;
+        const manifest = parseDashManifest(subtitleManifestXml);
+        const provider = createSpy('subtitleProvider').and.resolveTo({
+            manifest,
+            baseUrl: 'https://example.com/dash/',
+        });
+        const factories = factoryCreator(dashFactoryDeps)({
+            uri: 'test://manifest.mpd',
+            type: 'dash',
+            manifestProvider: provider,
+        });
+        const deps = createContainer(factories).dependencies;
+        const ttc = deps.textTrackController;
+        await deps.manifestTransformed.value;
+        await new Promise((r) => setTimeout(r, 0));
+        expect(ttc).toBeDefined();
+        expect(ttc.textTracks.length).toBeGreaterThan(0);
+    });
+    it('text track controller swallows manifest fetch errors', async () => {
+        const factoryCreator = createDashFactories(null);
+        const provider = createSpy('failing').and.rejectWith(new Error('manifest down'));
+        const factories = factoryCreator(dashFactoryDeps)({
+            uri: 'test://manifest.mpd',
+            type: 'dash',
+            manifestProvider: provider,
+        });
+        const deps = createContainer(factories).dependencies;
+        const controller = deps.textTrackController;
+        await deps.manifestTransformed.value.catch(() => undefined);
+        await new Promise((r) => setTimeout(r, 0));
+        expect(controller.textTracks).toEqual([]);
+    });
 });

package/dist/unit/types/current/track/dash/createSegmentControllerFactory.test.js

@@ -12,6 +12,7 @@ describe('createSegmentControllerFactory', () => {
         const emptyTimeline = {
             periods: [],
             minBufferTime: 0,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(Infinity),
         };
         const factory = createSegmentControllerFactory({ playbackController }, 'audio', { prefetchActive: 100 });

package/dist/unit/types/current/track/dash/util/mpd.test.js

@@ -2,7 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { calculateDuration, calculatePeriodEnd, calculatePeriodStart, calculatePeriodTimeRange, flattenRepresentations, getPeriodAtTime, getRepresentationAncestry, getSegmentBase, getSegmentList, getSegmentTemplate, sampleToMpdTime, } from '@amazon/vinyl';
+import { calculateDuration, calculatePeriodEnd, calculatePeriodStart, calculatePeriodTimeRange, flattenMediaRepresentations, flattenRepresentations, getPeriodAtTime, getRepresentationAncestry, getSegmentBase, getSegmentList, getSegmentTemplate, sampleToMpdTime, } from '@amazon/vinyl';
 import { clone, toJson } from '@amazon/vinyl-util';
 import { parseDashManifest } from '@amazon/vinyl-mpd-parser';
 import { mockDashManifest } from '@amazon/vinyl/vinylTestUtil';
@@ -288,6 +288,29 @@ describe('mpd utils', () => {
             ]));
         });
     });
+    describe('flattenMediaRepresentations', () => {
+        it('excludes text adaptation sets, keeping audio and video', () => {
+            // language=XML
+            const manifest = parseDashManifest(`<?xml version="1.0" ?>
+                <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                    <Period>
+                        <AdaptationSet contentType="video" mimeType="video/mp4">
+                            <Representation bandwidth="3285092" codecs="avc1.640028" id="v0"/>
+                        </AdaptationSet>
+                        <AdaptationSet contentType="audio" mimeType="audio/mp4">
+                            <Representation bandwidth="128000" codecs="mp4a.40.2" id="a0"/>
+                        </AdaptationSet>
+                        <AdaptationSet contentType="text" mimeType="text/vtt" lang="en">
+                            <Representation bandwidth="100" id="text-en">
+                                <BaseURL>subs/en.vtt</BaseURL>
+                            </Representation>
+                        </AdaptationSet>
+                    </Period>
+                </MPD>`);
+            const ids = flattenMediaRepresentations(manifest.MPD.Period[0]).map((r) => r.id);
+            expect(ids).toEqual(['v0', 'a0']);
+        });
+    });
     describe('calculateDuration', () => {
         describe('when MPD.mediaPresentationDuration is set', () => {
             it('resolves to MPD.mediaPresentationDuration', () => {

package/dist/unit/types/current/track/hls/HlsManifestController.test.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Deferred } from '@amazon/vinyl-util';
-import { HlsManifestControllerImpl } from '@amazon/vinyl';
+import { ManifestControllerImpl } from '@amazon/vinyl';
 import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
 import { expectNothing, flushPromises, } from '@amazon/vinyl-util/browserTestUtil';
 var createSpy = jasmine.createSpy;
@@ -14,15 +14,15 @@ describe('HlsManifestController', () => {
         manifestProvider.and.resolveTo(mockHlsManifestData);
     });
     function createManifestController() {
-        return new HlsManifestControllerImpl(manifestProvider);
+        return new ManifestControllerImpl({ manifestProvider });
     }
     it('has a toStringTag', () => {
         const controller = createManifestController();
-        expect(String(controller)).toContain('HlsManifestControllerImpl');
+        expect(String(controller)).toContain('ManifestControllerImpl');
     });
     it('has a logPrefix', () => {
         const controller = createManifestController();
-        expect(controller.logPrefix).toBe('HlsManifestControllerImpl');
+        expect(controller.logPrefix).toBe('ManifestControllerImpl');
     });
     describe('refresh', () => {
         it('reloads the manifest', () => {

package/dist/unit/types/current/track/hls/HlsMediaQualityMetadataResolver.test.js

@@ -88,11 +88,13 @@ describe('HlsMediaQualityMetadataResolver', () => {
         const quality = resolver(variant({ frameRate: undefined }), []);
         expect(quality.frameRate).toBeNull();
     });
-    it('sets lang from matching audio rendition', () => {
+    it('does not set a language (audio language is resolved per rendition)', () => {
+        // The variant metadata is language-agnostic; buildHlsMediaTimeline
+        // creates one audio quality per rendition carrying its own language.
         const quality = resolver(variant({ audioGroup: 'aud1' }), [
             audioRendition({ groupId: 'aud1', language: 'fr' }),
         ]);
-        expect(quality.lang).toBe('fr');
+        expect(quality.lang).toBeNull();
     });
     it('sets lang to null when no matching rendition', () => {
         const quality = resolver(variant({ audioGroup: 'aud1' }), [

package/dist/unit/types/current/track/hls/buildHlsMediaTimeline.test.js

@@ -2,8 +2,10 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { buildHlsMediaTimeline, createEmptyMediaQualityMetadata, } from '@amazon/vinyl';
+import { buildHlsMediaTimeline, createDefaultMediaTimelineTransformer, createEmptyMediaQualityMetadata, } from '@amazon/vinyl';
 import { noop } from '@amazon/vinyl-util';
+import { data } from '@amazon/vinyl-observable';
+import { MockCapabilities, MockDrmController, } from '@amazon/vinyl/vinylTestUtil';
 describe('buildHlsMediaTimeline', () => {
     function createVariant(uri, bandwidth) {
         return {
@@ -99,23 +101,42 @@ describe('buildHlsMediaTimeline', () => {
         expect(timeline.periods[0].qualities.length).toBe(0);
         expect(timeline.periods[0].endTime).toBe(Infinity);
     });
-    it('uses variant URI for audio when variant is audio-only with audioGroup', async () => {
-        const variant = {
-            ...createVariant('flac.m3u8', 2_000_000),
-            codecs: 'flac',
-            audioGroup: 'audio-group',
-        };
+    it('creates one audio quality per rendition for an audio-only multi-language stream', async () => {
+        // Shaka's audio-only shape: each language is both an audio-only variant
+        // (referencing the group) and a rendition pointing at the same playlist.
+        // Demuxed audio is modeled per rendition, one quality per language.
         const playlist = createMediaPlaylist([5, 5]);
         const requestedUris = [];
         const manifestData = {
             mainPlaylist: {
-                variants: [variant],
+                variants: [
+                    {
+                        bandwidth: 128000,
+                        uri: 'audio_en.m3u8',
+                        codecs: 'mp4a.40.2',
+                        audioGroup: 'audio',
+                    },
+                    {
+                        bandwidth: 129000,
+                        uri: 'audio_fr.m3u8',
+                        codecs: 'mp4a.40.2',
+                        audioGroup: 'audio',
+                    },
+                ],
                 alternativeRenditions: [
                     {
                         type: 'AUDIO',
-                        groupId: 'audio-group',
-                        uri: 'aac.m3u8',
+                        groupId: 'audio',
+                        uri: 'audio_en.m3u8',
                         language: 'en',
+                        name: 'en',
+                    },
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'audio_fr.m3u8',
+                        language: 'fr',
+                        name: 'fr',
                     },
                 ],
             },
@@ -126,10 +147,144 @@ describe('buildHlsMediaTimeline', () => {
             },
         };
         const timeline = buildHlsMediaTimeline(deps, manifestData);
-        const segment = await timeline.periods[0].qualities[0].getSegment(2);
-        expect(segment).not.toBeNull();
-        expect(requestedUris).toContain('flac.m3u8');
-        expect(requestedUris).not.toContain('aac.m3u8');
+        const audio = timeline.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');
+        expect(audio
+            .map((q) => q.metadata.lang)
+            .sort((a, b) => String(a).localeCompare(String(b)))).toEqual(['en', 'fr']);
+        // Fetching an audio quality uses its own rendition playlist.
+        await audio.find((q) => q.metadata.lang === 'fr').getSegment(2);
+        expect(requestedUris).toContain('audio_fr.m3u8');
+    });
+    it('skips audio renditions with no URI, a duplicate URI, or an unreferenced group', () => {
+        const playlist = createMediaPlaylist([5, 5]);
+        const manifestData = {
+            mainPlaylist: {
+                variants: [
+                    {
+                        bandwidth: 5_000_000,
+                        uri: 'video.m3u8',
+                        codecs: 'avc1.640015,mp4a.40.2',
+                        audioGroup: 'audio',
+                    },
+                ],
+                alternativeRenditions: [
+                    // No URI: nothing to fetch, skipped.
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        language: 'en',
+                        name: 'en',
+                    },
+                    // First real rendition for this URI is kept.
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'audio.m3u8',
+                        language: 'en',
+                        name: 'en',
+                    },
+                    // Duplicate URI: deduped away.
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'audio.m3u8',
+                        language: 'en-dup',
+                        name: 'en-dup',
+                    },
+                    // Group referenced by no variant: no codec to play with.
+                    {
+                        type: 'AUDIO',
+                        groupId: 'orphan',
+                        uri: 'orphan.m3u8',
+                        language: 'de',
+                        name: 'de',
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const audio = timeline.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');
+        expect(audio.map((q) => q.metadata.lang)).toEqual(['en']);
+    });
+    it('gives same-language audio renditions distinct ids and carries characteristics', () => {
+        const playlist = createMediaPlaylist([5, 5]);
+        const manifestData = {
+            mainPlaylist: {
+                variants: [
+                    {
+                        bandwidth: 5_000_000,
+                        uri: 'video.m3u8',
+                        codecs: 'avc1.640015,mp4a.40.2',
+                        audioGroup: 'audio',
+                    },
+                ],
+                alternativeRenditions: [
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'main.m3u8',
+                        language: 'en-US',
+                        name: 'English',
+                    },
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'dvs.m3u8',
+                        language: 'en-US',
+                        name: 'English (DVS)',
+                        characteristics: [
+                            'public.accessibility.describes-video',
+                        ],
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const audio = timeline.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');
+        expect(audio.length).toBe(2);
+        // Same group + language would otherwise collide; names disambiguate.
+        expect(new Set(audio.map((q) => q.metadata.qualityId)).size).toBe(2);
+        const dvs = audio.find((q) => q.metadata.characteristics.includes('public.accessibility.describes-video'));
+        const main = audio.find((q) => q.metadata.characteristics.length === 0);
+        expect(dvs).toBeDefined();
+        expect(main).toBeDefined();
+    });
+    it('handles an audio rendition with no language and a variant with no audio codec', () => {
+        const playlist = createMediaPlaylist([5, 5]);
+        const manifestData = {
+            mainPlaylist: {
+                variants: [
+                    {
+                        bandwidth: 5_000_000,
+                        uri: 'video.m3u8',
+                        // Video-only codecs: the demuxed audio has no codec.
+                        codecs: 'avc1.640015',
+                        audioGroup: 'audio',
+                    },
+                ],
+                alternativeRenditions: [
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'audio.m3u8',
+                        // No language: the quality id falls back to the name and
+                        // lang is null.
+                        name: 'commentary',
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const audio = timeline.periods[0].qualities.find((q) => q.metadata.contentType === 'audio');
+        expect(audio.metadata.lang).toBeNull();
+        expect(audio.metadata.codecs).toBeNull();
+        expect(audio.metadata.qualityId).toBe('audio-audio-commentary');
     });
     it('uses rendition URI for audio when variant carries both video and audio', async () => {
         const variant = {
@@ -167,6 +322,97 @@ describe('buildHlsMediaTimeline', () => {
         await audioQuality.getSegment(2);
         expect(requestedUris).toEqual(['audio.m3u8']);
     });
+    // Shaka's mixed-codec shape: a single audio group whose renditions are
+    // different codecs (aac/opus/flac), each paired with an audio-only variant
+    // whose CODECS describes that one rendition. The flac variant is first, so
+    // resolving the codec from "the first variant of the group" would mislabel
+    // every rendition as flac.
+    function createMixedCodecAudioManifest(playlist) {
+        return {
+            mainPlaylist: {
+                variants: [
+                    {
+                        bandwidth: 141296,
+                        uri: 'flac.m3u8',
+                        codecs: 'flac',
+                        audioGroup: 'default-audio-group',
+                    },
+                    {
+                        bandwidth: 96017,
+                        uri: 'opus.m3u8',
+                        codecs: 'opus',
+                        audioGroup: 'default-audio-group',
+                    },
+                    {
+                        bandwidth: 51205,
+                        uri: 'aac.m3u8',
+                        codecs: 'mp4a.40.2',
+                        audioGroup: 'default-audio-group',
+                    },
+                ],
+                alternativeRenditions: [
+                    {
+                        type: 'AUDIO',
+                        groupId: 'default-audio-group',
+                        uri: 'flac.m3u8',
+                        name: 'stream_flac',
+                    },
+                    {
+                        type: 'AUDIO',
+                        groupId: 'default-audio-group',
+                        uri: 'opus.m3u8',
+                        name: 'stream_opus',
+                    },
+                    {
+                        type: 'AUDIO',
+                        groupId: 'default-audio-group',
+                        uri: 'aac.m3u8',
+                        name: 'stream_aac',
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+    }
+    it('assigns each rendition its own codec in a mixed-codec audio group', () => {
+        const manifestData = createMixedCodecAudioManifest(createMediaPlaylist([5, 5]));
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const byUri = (uri) => timeline.periods[0].qualities.find((q) => q.metadata.decoderId === uri).metadata;
+        expect(byUri('aac.m3u8').codecs).toBe('mp4a.40.2');
+        expect(byUri('aac.m3u8').mimeType).toBe('audio/mp4; codecs="mp4a.40.2"');
+        expect(byUri('opus.m3u8').codecs).toBe('opus');
+        expect(byUri('opus.m3u8').mimeType).toBe('audio/mp4; codecs="opus"');
+        expect(byUri('flac.m3u8').codecs).toBe('flac');
+        expect(byUri('flac.m3u8').mimeType).toBe('audio/mp4; codecs="flac"');
+    });
+    it('keeps the AAC rendition playable when the browser rejects opus and flac', async () => {
+        const capabilities = new MockCapabilities();
+        // Safari-like: only AAC is playable via MSE.
+        capabilities.canPlayTypeMse.and.callFake((type) => type.includes('mp4a'));
+        capabilities.sampleRate = 192_000;
+        const drmController = new MockDrmController();
+        drmController.isSupported.and.resolveTo({
+            supported: true,
+            persistentState: false,
+        });
+        const manifestData = createMixedCodecAudioManifest(createMediaPlaylist([5, 5]));
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const result = await createDefaultMediaTimelineTransformer({
+            capabilities,
+            drmController,
+            mediaTimeline: data(Promise.resolve(timeline)),
+            options: data({
+                preferredAudioLanguage: null,
+                codecOverrides: {},
+                preferDescriptiveAudio: false,
+            }),
+        }).value;
+        const audio = result.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');
+        // Only the AAC rendition survives; the period is not emptied, so no
+        // MediaUnsupportedError is thrown.
+        expect(audio.map((q) => q.metadata.codecs)).toEqual(['mp4a.40.2']);
+    });
     it('uses transmux path when no EXT-X-MAP is present', async () => {
         const variant = createVariant('v1.m3u8', 128000);
         const playlist = {

package/dist/unit/types/current/track/hls/createHlsContentStreamFactories.test.js

@@ -12,6 +12,7 @@ describe('createHlsContentStreamFactories', () => {
     const emptyTimeline = {
         periods: [],
         minBufferTime: 0,
+        getAdBreaks: () => Promise.resolve([]),
         getDuration: () => Promise.resolve(Infinity),
     };
     beforeEach(() => {