@norskvideo/norsk-sdk 1.0.365 → 1.0.367

package/dist/norsk-sdk.d.ts

@@ -315,6 +315,7 @@ export declare class AudioBuildMultichannelNode extends AutoProcessorMediaNode<"
 export declare interface AudioBuildMultichannelSettings extends ProcessorNodeSettings<AudioBuildMultichannelNode> {
     /** The channel layout of the built outgoing stream */
     channelLayout: ChannelLayout;
+    /** The sample rate of the built outgoing stream */
     sampleRate: SampleRate;
     /**
      * Stream keys specifying the source for each channel, where the order is
@@ -422,6 +423,7 @@ export declare interface AudioMeasureLevelsSettings extends ProcessorNodeSetting
      * @eventProperty
      */
     onData: (levels: AudioMeasureLevels) => void;
+    /** Optionally control the sample frequency */
     intervalFrames?: number;
 }
 
@@ -637,7 +639,16 @@ export declare class AudioTranscribeAzureNode extends AutoProcessorMediaNode<"au
  * */
 export declare interface AudioTranscribeAzureSettings extends ProcessorNodeSettings<AudioTranscribeAzureNode> {
     outputStreamId: number;
+    /** The source language to recognise - an IETF BCP 47 language tag, eg en-US, en-GB, de-DE. Supported languages are
+     * found at https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=stt
+     */
     sourceLanguage: string;
+    /** The target output languages for translation - technically a BCP 47 language tag but but in most cases omitting region, e.g. en, de, zh-Hant.
+
+     * Leave this field absent/empty to use the transcription service without
+     * translation, while if any target languages are present the translation service will be used even if this is the same as the
+     * source language.
+     */
     targetLanguages?: string[];
     /** Key for the Azure Speech Service endpoint */
     azureKey: string;
@@ -672,8 +683,6 @@ export declare interface AudioTranscribeWhisperSettings extends ProcessorNodeSet
      * Default 3000ms.
      */
     stepMs?: number;
-    /** The full audio buffer size. Default 10000ms */
-    lengthMs?: number;
     /** Duration of audio to keep when clearing the buffer to allow for partial-word recognition. Default 400ms */
     keepMs?: number;
     /** Max tokens per segment */
@@ -1415,7 +1424,11 @@ export declare type DeckLinkVideoIOSupport = "capture" | "playback";
 /** @public */
 export declare type DeferredVideoComposeSettings<Pins extends string> = (streams: StreamMetadata[]) => VideoComposeSettings<Pins> | undefined;
 
+/** Various options for de-interlacing video either in software or hardware (where available) */
 export declare type DeinterlaceSettings = {
+    /** Use the CPU to perform deinterlace, Note: if the video has been decoded on hardware
+     * it will need to be transferred to system memory and reuploaded again
+     */
     type: 'software';
     algorithm: 'bwdif' | 'kerndeint' | 'nnedi' | 'w3fdif' | 'yadif';
 };
@@ -1443,6 +1456,10 @@ export declare interface DeltacastInputSettings extends InputSettings<DeltacastI
     deviceId: number;
     /** Which channel on the device to use */
     channelIndex: number;
+    /** Should video be captured?  Defaults to true, but for applications that only require the audio
+     * there is a small efficiency gain by setting to false
+     */
+    captureVideo?: boolean;
     /**
      * An SDI signal can contain up to 16 (3G) or 32 (6G / 12G) audio channels, which are
      * transmitted as groups of 4.  For example, a single stereo signal would typically be
@@ -1567,8 +1584,14 @@ export declare class FileMp4InputNode extends SourceMediaNode {
      * */
     nudge(nudge: number): void;
     updateSettings(settings: FileMp4InputSettingsUpdate): void;
+    /** Pause the MP4 playback. This may not take fully immediate effect, frames already in flight within the Mp4Input workflow will still be emitted */
     pause(): void;
+    /** Start/resume the MP4 playback */
     play(): void;
+    /** Start MP4 playback, pausing once the given offset is reached */
+    playUntil(offsetMs: number): void;
+    /** Seek to a given point, without starting playback. When the stream is played/resumed, it will start from (about) this offset */
+    seek(offsetMs: number): void;
 }
 
 /**
@@ -1583,6 +1606,10 @@ export declare interface FileMp4InputSettings extends SourceNodeSettings<FileMp4
     fileName: string;
     /** Callback to be notified when the file ends */
     onEof?: () => void;
+    /** Callback to be notified when the file loops on hitting the end */
+    onLoop?: () => void;
+    /** Callback to be notified when the file reaches the specified stop position */
+    onStopPosition?: () => void;
     /** Callback to be notified when the file is initially read */
     onInfo?: (info: FileMp4Info) => void;
     /** Whether to loop back to the start of the file after reaching the end (default false) */
@@ -1812,6 +1839,10 @@ export declare interface HlsPushDestinationSettings {
      this should take into account the end to end latency from source capture, to the part and playlist being published
      */
     partHoldBackSeconds?: number;
+    /** Whether the server supports gzip *request* compression for PUT/POST requests */
+    supportsGzip?: boolean;
+    /** Whether to use TLS or plain TCP transport, by default TLS used if port is 443 */
+    tlsTransport?: boolean;
 }
 
 /** @public */
@@ -2038,12 +2069,6 @@ export declare interface Interval {
     d: bigint;
 }
 
-/** @public */
-export declare interface IntervalTimestamp {
-    n: bigint;
-    d: bigint;
-}
-
 /** @public */
 export declare function isAdMarker(seg: MediaPlaylistPart): seg is AdMarker;
 
@@ -2303,9 +2328,10 @@ export declare interface MediaSegment {
 export declare class MediaStoreActiveCut {
     /**
      * @public
-     * Promise that resolves when the asset import is complete
+     * Promise that resolves when the cut is complete
      */
     complete(): Promise<bigint>;
+    cancel(): void;
 }
 
 /**
@@ -2313,48 +2339,70 @@ export declare class MediaStoreActiveCut {
  * see: {@link NorskOutput.mediaStore}
  */
 export declare class MediaStoreAsset {
-    /**
-     * @public
-     * Promise that resolves when the asset import is complete
-     */
-    ready(): Promise<{
-        durationMs: bigint;
-        size: bigint;
-    }>;
+    /** @public */
+    durationMs?: bigint;
+    /** @public */
+    size?: bigint;
+    cutListEntry(settings: MediaStoreAssetCut): MediaStoreCut;
 }
 
 /** @public */
-export declare type MediaStoreAssetSettings = {
-    name: string;
-    file: string;
-    path: string;
-    progressCb?: (progress: number) => void;
-};
-
-/** @public */
-export declare type MediaStoreCut = {
+export declare class MediaStoreAssetCut {
     /**
-     * Required: Name of the media store instance that this cut is from
+     * Required: The streams you want to select from the asset
      */
-    mediaStoreName: string;
+    streamSelection: MediaStoreStreamSelection[];
     /**
-     * Required: The streams you want to playback from the media store
+     * Optional: The start point for the cut in milliseconds - defaults to zero
      */
-    streamSelection: MediaStoreStreamSelection[];
+    startTimeMs?: number;
     /**
-     * Required: The start date/time for the cut.  For a local recoder or a remote view,
-     * this is UTC.  For an asset store, this starts at zero
+     * Optional: The duration of the cut in milliseconds - defaults to the entire asset
      */
-    startDateTime: Date;
+    durationMs?: number | "all";
     /**
-     * Required: The duration of the cut in milliseconds
+     * Optional: How many times to repeat the cut - defaults to 1
      */
-    durationMs: number;
+    repeatCount?: number | "infinity";
     /**
      * Required: In a video stream, if a start time or end time falls mid-gop, should the gop be trimmed to be frame accurate?
      */
     trimPartialGops: boolean;
-    sessionNum?: number;
+}
+
+/** @public */
+export declare type MediaStoreAssetFile = {
+    file: string;
+    errorOnHashMismatch?: boolean;
+};
+
+/** @public */
+export declare type MediaStoreAssetFileWithHash = {
+    file: string;
+    hash: string;
+    errorOnHashMismatch?: boolean;
+};
+
+/** @public */
+export declare type MediaStoreAssetSettings = {
+    name: string;
+    source?: MediaStoreAssetSource;
+    path: string;
+    progressCb?: (progress: number) => void;
+};
+
+/** @public */
+export declare type MediaStoreAssetSource = MediaStoreAssetFileWithHash | MediaStoreAssetFile;
+
+declare type MediaStoreCut = {
+    mediaStoreName: string;
+    cut: {
+        type: "asset";
+        cut: MediaStoreAssetCut;
+    } | {
+        type: "recorder";
+        cut: MediaStoreRecorderCut;
+    };
 };
 
 /** @public */
@@ -2402,11 +2450,38 @@ export declare interface MediaStorePlayerSettings extends InputSettings<MediaSto
     onEof?: () => void;
 }
 
+/** @public */
+export declare class MediaStoreRecorderCut {
+    /**
+     * Required: The streams you want to select from the asset
+     */
+    streamSelection: MediaStoreStreamSelection[];
+    /**
+     * Required: The start point for the cut in UTC
+     */
+    startDateTime: Date;
+    /**
+     * Required: The duration of the cut in milliseconds
+     */
+    durationMs: number;
+    /**
+     * Required: In a video stream, if a start time or end time falls mid-gop, should the gop be trimmed to be frame accurate?
+     */
+    trimPartialGops: boolean;
+    /**
+     * Optional: If it's ambiguous which session contains the start time (for example, due to a system clock change), then
+     * specify the correct session
+     */
+    sessionNum?: number;
+}
+
 /**
  * @public
  * see: {@link NorskOutput.mediaStore}
  */
 export declare class MediaStoreRecorderNode extends AutoSinkMediaNode<"audio" | "video"> {
+    metadata(): Promise<MediaStoreSession[]>;
+    cutListEntry(settings: MediaStoreRecorderCut): MediaStoreCut;
 }
 
 /**
@@ -2439,6 +2514,32 @@ export declare type MediaStoreSession = {
     streams: MediaStoreStream[];
 };
 
+/**
+ * @public
+ * see: {@link NorskOutput.mediaStore}
+ */
+export declare class MediaStoreSnapshot {
+    update(): Promise<void>;
+    metadata(): Promise<MediaStoreSession[]>;
+    cutListEntry(settings: MediaStoreRecorderCut): MediaStoreCut;
+}
+
+/**
+ * @public
+ * Settings to configure a media store snapshot
+ * see {@link NorskOutput.mediaStore}
+ */
+export declare interface MediaStoreSnapshotSettings {
+    /**
+     * Required: Name of this media store instance.
+     */
+    name: string;
+    /**
+     * Required: Path for the media store database.
+     */
+    path: string;
+}
+
 /** @public */
 export declare type MediaStoreStream = {
     streamKey: StreamKey;
@@ -2806,17 +2907,15 @@ export declare interface NorskMediaStore {
      *
      * @param cut request - Configuration for the cut
      */
-    makeCut(request: MediaStoreCutRequest): Promise<MediaStoreActiveCut>;
+    makeCut(request: MediaStoreCutRequest): MediaStoreActiveCut;
     /**
-     * Get the metadata for a store
-     *
-     * @param Media Store name
+     * Create a Media Store for an on-disk MP4 asset
      */
-    metadata(mediaStoreName: string): Promise<MediaStoreSession[]>;
+    asyncLoadAsset(settings: MediaStoreAssetSettings): Promise<MediaStoreAsset>;
     /**
-     * Create a Media Store for an on-disk MP4 asset
+     * Create a Media Store snapshot on an exist store
      */
-    asset(settings: MediaStoreAssetSettings): Promise<MediaStoreAsset>;
+    snapshot(settings: MediaStoreSnapshotSettings): Promise<MediaStoreSnapshot>;
 }
 
 /**
@@ -4847,6 +4946,7 @@ export declare class StreamTimestampNudgeNode extends AutoProcessorMediaNode<"au
  * see: {@link NorskTransform.streamTimestampNudge}
  * */
 export declare interface StreamTimestampNudgeSettings extends ProcessorNodeSettings<StreamTimestampNudgeNode> {
+    /** the initial nudge to apply, in milliseconds */
     nudge?: number;
 }
 
@@ -4863,7 +4963,7 @@ export declare class StreamTimestampReportNode extends AutoSinkMediaNode<string>
  * see {@link NorskOutput.fileMp4}
  */
 export declare interface StreamTimestampReportSettings extends SinkNodeSettings<StreamTimestampReportNode> {
-    onTimestamp?: (streamKey: StreamKey, timestamp: IntervalTimestamp) => Promise<void>;
+    onTimestamp?: (streamKey: StreamKey, timestamp: Interval) => Promise<void>;
 }
 
 /**

package/lib/src/media_nodes/debug.d.ts

@@ -1,12 +1,12 @@
 import { AutoSinkMediaNode, SinkNodeSettings } from "./common";
-import { IntervalTimestamp, StreamKey } from "./types";
+import { Interval, StreamKey } from "./types";
 /**
  * @public
  * Settings to control MP4 file output
  * see {@link NorskOutput.fileMp4}
  */
 export interface StreamTimestampReportSettings extends SinkNodeSettings<StreamTimestampReportNode> {
-    onTimestamp?: (streamKey: StreamKey, timestamp: IntervalTimestamp) => Promise<void>;
+    onTimestamp?: (streamKey: StreamKey, timestamp: Interval) => Promise<void>;
 }
 /**
  * @public

package/lib/src/media_nodes/debug.js

@@ -43,7 +43,7 @@ class StreamTimestampReportNode extends common_1.AutoSinkMediaNode {
                     case "report": {
                         if (settings.onTimestamp) {
                             if (data.message.value.pts && data.message.value.stream)
-                                settings.onTimestamp((0, types_1.fromStreamKey)(data.message.value.stream), data.message.value.pts);
+                                settings.onTimestamp((0, types_1.fromStreamKey)(data.message.value.stream), (0, types_1.fromInterval)(data.message.value.pts));
                         }
                         break;
                     }

package/lib/src/media_nodes/input.d.ts

@@ -281,6 +281,10 @@ export interface DeltacastInputSettings extends InputSettings<DeltacastInputNode
     deviceId: number;
     /** Which channel on the device to use */
     channelIndex: number;
+    /** Should video be captured?  Defaults to true, but for applications that only require the audio
+     * there is a small efficiency gain by setting to false
+     */
+    captureVideo?: boolean;
     /**
      * An SDI signal can contain up to 16 (3G) or 32 (6G / 12G) audio channels, which are
      * transmitted as groups of 4.  For example, a single stereo signal would typically be
@@ -672,6 +676,10 @@ export interface FileMp4InputSettings extends SourceNodeSettings<FileMp4InputNod
     fileName: string;
     /** Callback to be notified when the file ends */
     onEof?: () => void;
+    /** Callback to be notified when the file loops on hitting the end */
+    onLoop?: () => void;
+    /** Callback to be notified when the file reaches the specified stop position */
+    onStopPosition?: () => void;
     /** Callback to be notified when the file is initially read */
     onInfo?: (info: FileMp4Info) => void;
     /** Whether to loop back to the start of the file after reaching the end (default false) */
@@ -704,8 +712,14 @@ export declare class FileMp4InputNode extends SourceMediaNode {
      * */
     nudge(nudge: number): void;
     updateSettings(settings: FileMp4InputSettingsUpdate): void;
+    /** Pause the MP4 playback. This may not take fully immediate effect, frames already in flight within the Mp4Input workflow will still be emitted */
     pause(): void;
+    /** Start/resume the MP4 playback */
     play(): void;
+    /** Start MP4 playback, pausing once the given offset is reached */
+    playUntil(offsetMs: number): void;
+    /** Seek to a given point, without starting playback. When the stream is played/resumed, it will start from (about) this offset */
+    seek(offsetMs: number): void;
 }
 /**
  * @public

package/lib/src/media_nodes/input.js

@@ -8,6 +8,7 @@ const types_3 = require("../types");
 const utils_1 = require("../shared/utils");
 const common_1 = require("./common");
 const protobuf_1 = require("@bufbuild/protobuf");
+const common_pb_1 = require("@norskvideo/norsk-api/lib/shared/common_pb");
 /**
  * @public
  * see: {@link NorskInput.rtp}
@@ -515,6 +516,7 @@ class DeltacastInputNode extends common_1.SourceMediaNode {
             sourceName: settings.sourceName,
             deviceId: settings.deviceId,
             channelIndex: settings.channelIndex,
+            captureVideo: (!('captureVideo' in settings) || settings.captureVideo === undefined) ? true : settings.captureVideo,
             audioChannelMask: settings.audioChannelMask ? settings.audioChannelMask : 0xffffffff,
             statsSampling: settings.statsSampling
                 ? (0, utils_1.provideFull)(media_pb_1.StreamStatisticsSampling, settings.statsSampling)
@@ -1165,7 +1167,8 @@ class VideoTestcardGeneratorNode extends common_1.SourceMediaNode {
             ? (0, utils_1.provideFull)(media_pb_1.MediaNodeId, { id: settings.id })
             : undefined;
         const config = (0, utils_1.provideFull)(media_pb_1.TestCardVideoConfiguration, {
-            numberOfFrames: settings.numberOfFrames ?? 0,
+            numberOfFrames: settings.numberOfFrames ? (0, utils_1.provideFull)(common_pb_1.UInt32OrInfinity, (0, utils_1.mkMessageCase)({ intValue: settings.numberOfFrames }))
+                : (0, utils_1.provideFull)(common_pb_1.UInt32OrInfinity, (0, utils_1.mkMessageCase)({ infinity: new protobuf_1.Empty() })),
             realtime: true,
             sourceName: settings.sourceName,
             frameRate: (0, utils_1.provideFull)(media_pb_1.FrameRate, settings.frameRate),
@@ -1318,10 +1321,16 @@ class FileMp4InputNode extends common_1.SourceMediaNode {
                         break;
                     }
                     case "status": {
-                        if (data.message.value.state ==
-                            media_pb_1.FileMp4InputStatus_State.INPUT_STATUS_EOF &&
-                            settings.onEof) {
-                            settings.onEof();
+                        switch (data.message.value.state) {
+                            case media_pb_1.FileMp4InputStatus_State.INPUT_STATUS_EOF:
+                                settings.onEof && settings.onEof();
+                                break;
+                            case media_pb_1.FileMp4InputStatus_State.INPUT_STATUS_EOF_LOOPING:
+                                settings.onLoop && settings.onLoop();
+                                break;
+                            case media_pb_1.FileMp4InputStatus_State.INPUT_STATUS_STOP_POSITION:
+                                settings.onStopPosition && settings.onStopPosition();
+                                break;
                         }
                         break;
                     }
@@ -1363,12 +1372,22 @@ class FileMp4InputNode extends common_1.SourceMediaNode {
     updateSettings(settings) {
         this.grpcStream.write((0, utils_1.provideFull)(media_pb_1.FileMp4InputMessage, (0, utils_1.mkMessageCase)({ updateConfig: (0, utils_1.provideFull)(media_pb_1.FileMp4InputConfigurationUpdate, { loop: settings.loop !== undefined ? (0, types_1.mkOptBool)(settings.loop) : undefined }) })));
     }
+    /** Pause the MP4 playback. This may not take fully immediate effect, frames already in flight within the Mp4Input workflow will still be emitted */
     pause() {
         this.grpcStream.write((0, utils_1.provideFull)(media_pb_1.FileMp4InputMessage, (0, utils_1.mkMessageCase)({ pause: (0, utils_1.provideFull)(protobuf_1.Empty, {}) })));
     }
+    /** Start/resume the MP4 playback */
     play() {
         this.grpcStream.write((0, utils_1.provideFull)(media_pb_1.FileMp4InputMessage, (0, utils_1.mkMessageCase)({ play: (0, utils_1.provideFull)(protobuf_1.Empty, {}) })));
     }
+    /** Start MP4 playback, pausing once the given offset is reached */
+    playUntil(offsetMs) {
+        this.grpcStream.write((0, utils_1.provideFull)(media_pb_1.FileMp4InputMessage, (0, utils_1.mkMessageCase)({ playUntil: (0, utils_1.provideFull)(media_pb_1.FileMp4InputPlayUntil, { offsetMs }) })));
+    }
+    /** Seek to a given point, without starting playback. When the stream is played/resumed, it will start from (about) this offset */
+    seek(offsetMs) {
+        this.grpcStream.write((0, utils_1.provideFull)(media_pb_1.FileMp4InputMessage, (0, utils_1.mkMessageCase)({ seek: (0, utils_1.provideFull)(media_pb_1.FileMp4InputSeek, { offsetMs }) })));
+    }
 }
 exports.FileMp4InputNode = FileMp4InputNode;
 //# sourceMappingURL=input.js.map

package/lib/src/media_nodes/mediaStore.d.ts

@@ -1,6 +1,6 @@
 import { AutoSinkMediaNode, SinkNodeSettings, SourceMediaNode, StreamStatisticsMixin } from "./common";
 import { InputSettings } from "./input";
-import { MediaStoreCut, StreamKey, StreamMetadata } from "./types";
+import { MediaStoreStreamSelection, StreamKey, StreamMetadata } from "./types";
 /** @public */
 export declare type MediaStoreExpireByTime = {
     expire: "byTime";
@@ -40,11 +40,61 @@ export declare type MediaStoreSession = {
     streams: MediaStoreStream[];
 };
 /** @public */
-export declare type MediaStoreAssetSettings = {
-    name: string;
-    file: string;
-    path: string;
-    progressCb?: (progress: number) => void;
+export declare class MediaStoreAssetCut {
+    /**
+      * Required: The streams you want to select from the asset
+      */
+    streamSelection: MediaStoreStreamSelection[];
+    /**
+     * Optional: The start point for the cut in milliseconds - defaults to zero
+     */
+    startTimeMs?: number;
+    /**
+     * Optional: The duration of the cut in milliseconds - defaults to the entire asset
+     */
+    durationMs?: number | "all";
+    /**
+     * Optional: How many times to repeat the cut - defaults to 1
+     */
+    repeatCount?: number | "infinity";
+    /**
+     * Required: In a video stream, if a start time or end time falls mid-gop, should the gop be trimmed to be frame accurate?
+     */
+    trimPartialGops: boolean;
+}
+/** @public */
+export declare class MediaStoreRecorderCut {
+    /**
+     * Required: The streams you want to select from the asset
+     */
+    streamSelection: MediaStoreStreamSelection[];
+    /**
+     * Required: The start point for the cut in UTC
+     */
+    startDateTime: Date;
+    /**
+     * Required: The duration of the cut in milliseconds
+     */
+    durationMs: number;
+    /**
+     * Required: In a video stream, if a start time or end time falls mid-gop, should the gop be trimmed to be frame accurate?
+     */
+    trimPartialGops: boolean;
+    /**
+     * Optional: If it's ambiguous which session contains the start time (for example, due to a system clock change), then
+     * specify the correct session
+     */
+    sessionNum?: number;
+}
+declare type MediaStoreCut = {
+    mediaStoreName: string;
+    cut: {
+        type: "asset";
+        cut: MediaStoreAssetCut;
+    } | {
+        type: "recorder";
+        cut: MediaStoreRecorderCut;
+    };
 };
 /**
  * @public
@@ -74,6 +124,8 @@ export interface MediaStoreRecorderSettings extends SinkNodeSettings<MediaStoreR
  * see: {@link NorskOutput.mediaStore}
  */
 export declare class MediaStoreRecorderNode extends AutoSinkMediaNode<"audio" | "video"> {
+    metadata(): Promise<MediaStoreSession[]>;
+    cutListEntry(settings: MediaStoreRecorderCut): MediaStoreCut;
 }
 /**
  * @public
@@ -101,23 +153,65 @@ export declare class MediaStorePlayerNode extends SourceMediaNode {
 export declare class MediaStoreActiveCut {
     /**
      * @public
-     * Promise that resolves when the asset import is complete
+     * Promise that resolves when the cut is complete
      */
     complete(): Promise<bigint>;
+    cancel(): void;
 }
+/** @public */
+export declare type MediaStoreAssetFileWithHash = {
+    file: string;
+    hash: string;
+    errorOnHashMismatch?: boolean;
+};
+/** @public */
+export declare type MediaStoreAssetFile = {
+    file: string;
+    errorOnHashMismatch?: boolean;
+};
+/** @public */
+export declare type MediaStoreAssetSource = MediaStoreAssetFileWithHash | MediaStoreAssetFile;
+/** @public */
+export declare type MediaStoreAssetSettings = {
+    name: string;
+    source?: MediaStoreAssetSource;
+    path: string;
+    progressCb?: (progress: number) => void;
+};
 /**
  * @public
  * see: {@link NorskOutput.mediaStore}
  */
 export declare class MediaStoreAsset {
+    /** @public */
+    durationMs?: bigint;
+    /** @public */
+    size?: bigint;
+    cutListEntry(settings: MediaStoreAssetCut): MediaStoreCut;
+}
+/**
+ * @public
+ * Settings to configure a media store snapshot
+ * see {@link NorskOutput.mediaStore}
+ */
+export interface MediaStoreSnapshotSettings {
     /**
-     * @public
-     * Promise that resolves when the asset import is complete
+     * Required: Name of this media store instance.
+     */
+    name: string;
+    /**
+     * Required: Path for the media store database.
      */
-    ready(): Promise<{
-        durationMs: bigint;
-        size: bigint;
-    }>;
+    path: string;
+}
+/**
+ * @public
+ * see: {@link NorskOutput.mediaStore}
+ */
+export declare class MediaStoreSnapshot {
+    update(): Promise<void>;
+    metadata(): Promise<MediaStoreSession[]>;
+    cutListEntry(settings: MediaStoreRecorderCut): MediaStoreCut;
 }
 /**
  * @public
@@ -139,16 +233,15 @@ export interface NorskMediaStore {
      *
      * @param cut request - Configuration for the cut
      */
-    makeCut(request: MediaStoreCutRequest): Promise<MediaStoreActiveCut>;
+    makeCut(request: MediaStoreCutRequest): MediaStoreActiveCut;
     /**
-     * Get the metadata for a store
-     *
-     * @param Media Store name
+     * Create a Media Store for an on-disk MP4 asset
      */
-    metadata(mediaStoreName: string): Promise<MediaStoreSession[]>;
+    asyncLoadAsset(settings: MediaStoreAssetSettings): Promise<MediaStoreAsset>;
     /**
-     * Create a Media Store for an on-disk MP4 asset
+     * Create a Media Store snapshot on an exist store
      */
-    asset(settings: MediaStoreAssetSettings): Promise<MediaStoreAsset>;
+    snapshot(settings: MediaStoreSnapshotSettings): Promise<MediaStoreSnapshot>;
 }
+export {};
 //# sourceMappingURL=mediaStore.d.ts.map

package/lib/src/media_nodes/mediaStore.js

@@ -23,11 +23,70 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mediaStoreMetadata = exports.MediaStoreAsset = exports.MediaStoreActiveCut = exports.MediaStorePlayerNode = exports.MediaStoreRecorderNode = void 0;
+exports.mediaStoreMetadata = exports.MediaStoreSnapshot = exports.MediaStoreAsset = exports.MediaStoreActiveCut = exports.MediaStorePlayerNode = exports.MediaStoreRecorderNode = exports.MediaStoreRecorderCut = exports.MediaStoreAssetCut = void 0;
 const media_pb_1 = require("@norskvideo/norsk-api/lib/media_pb");
 const common_1 = require("./common");
 const types_1 = require("./types");
 const util = __importStar(require("util"));
+const protobuf_1 = require("@bufbuild/protobuf");
+const common_pb_1 = require("@norskvideo/norsk-api/lib/shared/common_pb");
+/** @public */
+class MediaStoreAssetCut {
+}
+exports.MediaStoreAssetCut = MediaStoreAssetCut;
+/** @public */
+class MediaStoreRecorderCut {
+}
+exports.MediaStoreRecorderCut = MediaStoreRecorderCut;
+function toSingleCuts(cuts) {
+    return cuts.map(({ mediaStoreName, cut }) => {
+        const cutType = cut.type;
+        let streamSelection;
+        let startDateTime;
+        let durationMs;
+        let trimPartialGops;
+        let sessionNum;
+        let repeatCount;
+        switch (cutType) {
+            case "asset": {
+                const cut2 = cut.cut;
+                streamSelection = cut2.streamSelection;
+                startDateTime = new Date(cut2.startTimeMs ? cut2.startTimeMs : 0);
+                durationMs = cut2.durationMs ? (cut2.durationMs == "all" ? 0 : cut2.durationMs) : 0; // this looks dumb, but by cutListEntry in asset store will already have fixed it
+                trimPartialGops = cut2.trimPartialGops;
+                repeatCount = cut2.repeatCount ? (cut2.repeatCount == "infinity"
+                    ? (0, common_1.provideFull)(common_pb_1.UInt32OrInfinity, (0, common_1.mkMessageCase)({ infinity: new protobuf_1.Empty() }))
+                    : (0, common_1.provideFull)(common_pb_1.UInt32OrInfinity, (0, common_1.mkMessageCase)({ intValue: cut2.repeatCount })))
+                    : (0, common_1.provideFull)(common_pb_1.UInt32OrInfinity, (0, common_1.mkMessageCase)({ intValue: 1 }));
+                break;
+            }
+            case "recorder": {
+                const cut2 = cut.cut;
+                streamSelection = cut2.streamSelection;
+                startDateTime = cut2.startDateTime;
+                durationMs = cut2.durationMs;
+                trimPartialGops = cut2.trimPartialGops;
+                sessionNum = cut2.sessionNum;
+                repeatCount = (0, common_1.provideFull)(common_pb_1.UInt32OrInfinity, (0, common_1.mkMessageCase)({ intValue: 1 }));
+                break;
+            }
+            default:
+                (0, common_1.exhaustiveCheck)(cutType);
+        }
+        return (0, common_1.provideFull)(media_pb_1.SingleCut, {
+            mediaStoreName: mediaStoreName,
+            streamSelection: streamSelection.map(([sourceStreamKey, outputStreamKey]) => (0, common_1.provideFull)(media_pb_1.StreamSelection, {
+                sourceStreamKey: (0, types_1.mkStreamKey)(sourceStreamKey),
+                outputStreamKey: (0, types_1.mkStreamKey)(outputStreamKey)
+            })),
+            startDateTime: protobuf_1.Timestamp.fromDate(startDateTime),
+            durationMs,
+            trimPartialGops: trimPartialGops,
+            sessionNum: sessionNum ? (0, common_1.provideFull)(common_pb_1.OptionalInt, { value: sessionNum }) : undefined,
+            repeatCount: repeatCount
+        });
+    });
+}
 /**
  * @public
  * see: {@link NorskOutput.mediaStore}
@@ -37,6 +96,8 @@ class MediaStoreRecorderNode extends common_1.AutoSinkMediaNode {
     constructor(settings, client, unregisterNode) {
         super(client, () => this.grpcStream, async (subscription) => this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStoreRecorderMessage, (0, common_1.mkMessageCase)({ subscription }))), settings.onSubscriptionError);
         let expiryPb = undefined;
+        this.client = client;
+        this.settings = settings;
         if (settings.expiry) {
             const expiryType = settings.expiry.expire;
             switch (expiryType) {
@@ -58,8 +119,8 @@ class MediaStoreRecorderNode extends common_1.AutoSinkMediaNode {
             expiry: expiryPb
         });
         this.grpcStream = this.client.media.createMediaStoreRecorder();
-        this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStoreRecorderMessage, (0, common_1.mkMessageCase)({ configuration: config })));
         this.initialised = new Promise((resolve, reject) => {
+            this.grpcStream.on("error", (err) => reject(err));
             this.grpcStream.on("data", (data) => {
                 const messageCase = data.message.case;
                 switch (messageCase) {
@@ -71,7 +132,7 @@ class MediaStoreRecorderNode extends common_1.AutoSinkMediaNode {
                     case "nodeId": {
                         this.id = data.message.value.id;
                         settings.onCreate && settings.onCreate(this);
-                        resolve();
+                        resolve(this);
                         break;
                     }
                     case "inboundContext": {
@@ -85,12 +146,25 @@ class MediaStoreRecorderNode extends common_1.AutoSinkMediaNode {
             });
             (0, common_1.registerStreamHandlers)(this.grpcStream, () => unregisterNode(this), "mediaStoreRecorder", reject, settings);
         });
+        this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStoreRecorderMessage, (0, common_1.mkMessageCase)({ configuration: config })));
     }
     /** @internal */
     static async create(settings, client, unregisterNode) {
         const node = new MediaStoreRecorderNode(settings, client, unregisterNode);
-        await node.initialised;
-        return node;
+        return node.initialised;
+    }
+    async metadata() {
+        const fn = util
+            .promisify(this.client.media.mediaStoreMetadata)
+            .bind(this.client.media);
+        return fn((0, common_1.provideFull)(media_pb_1.MediaStoreMetadataRequest, { mediaStoreName: this.settings.name }))
+            .then(fromMediaStoreMetadataResponse);
+    }
+    cutListEntry(settings) {
+        return {
+            mediaStoreName: this.settings.name,
+            cut: { type: "recorder", cut: settings }
+        };
     }
 }
 exports.MediaStoreRecorderNode = MediaStoreRecorderNode;
@@ -107,11 +181,11 @@ class MediaStorePlayerNode extends common_1.SourceMediaNode {
                 ? (0, common_1.provideFull)(media_pb_1.MediaNodeId, { id: settings.id })
                 : undefined,
             sourceName: settings.sourceName,
-            cuts: (0, types_1.toSingleCuts)(settings.cuts)
+            cuts: toSingleCuts(settings.cuts)
         });
         this.grpcStream = client.media.createMediaStorePlayer();
-        this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStorePlayerMessage, (0, common_1.mkMessageCase)({ initialConfig: config })));
         this.initialised = new Promise((resolve, reject) => {
+            this.grpcStream.on("error", (err) => reject(err));
             this.grpcStream.on("data", (data) => {
                 const messageCase = data.message.case;
                 switch (messageCase) {
@@ -120,7 +194,7 @@ class MediaStorePlayerNode extends common_1.SourceMediaNode {
                     case "nodeId": {
                         this.id = data.message.value.id;
                         settings.onCreate && settings.onCreate(this);
-                        resolve();
+                        resolve(this);
                         break;
                     }
                     case "outboundContext": {
@@ -138,12 +212,12 @@ class MediaStorePlayerNode extends common_1.SourceMediaNode {
             });
             (0, common_1.registerStreamHandlers)(this.grpcStream, () => unregisterNode(this), "mediaStorePlayer", reject, settings);
         });
+        this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStorePlayerMessage, (0, common_1.mkMessageCase)({ initialConfig: config })));
     }
     /** @internal */
     static async create(settings, client, unregisterNode) {
         const node = new MediaStorePlayerNode(settings, client, unregisterNode);
-        await node.initialised;
-        return node;
+        return node.initialised;
     }
 }
 exports.MediaStorePlayerNode = MediaStorePlayerNode;
@@ -157,7 +231,7 @@ class MediaStoreActiveCut {
         let fileFormat;
         switch (cutRequest.fileFormat) {
             case "mp4": {
-                fileFormat = media_pb_1.MediaStoreCutRequest_FileFormat.CUT_MP4;
+                fileFormat = media_pb_1.StartMediaStoreCut_FileFormat.CUT_MP4;
                 break;
             }
             default:
@@ -165,12 +239,10 @@ class MediaStoreActiveCut {
         }
         this.client = client;
         this.cutRequest = cutRequest;
-        this.grpcStream = this.client.media.createMediaStoreCut((0, common_1.provideFull)(media_pb_1.MediaStoreCutRequest, {
-            ...cutRequest,
-            fileFormat: fileFormat,
-            cuts: (0, types_1.toSingleCuts)(cutRequest.cuts),
-        }));
+        this.grpcStream = this.client.media.createMediaStoreCut();
+        this._isComplete = false;
         this._complete = new Promise((resolve, reject) => {
+            this.grpcStream.on("error", (err) => { reject(err); });
             this.grpcStream.on("data", (data) => {
                 const messageCase = data.message.case;
                 switch (messageCase) {
@@ -180,7 +252,13 @@ class MediaStoreActiveCut {
                         this.cutRequest.progressCb && this.cutRequest.progressCb(data.message.value.progress);
                         break;
                     }
+                    case "cutCancelled": {
+                        this._isComplete = true;
+                        reject(new Error("cancelled"));
+                        break;
+                    }
                     case "cutComplete": {
+                        this._isComplete = true;
                         resolve(data.message.value.size);
                         break;
                     }
@@ -189,21 +267,35 @@ class MediaStoreActiveCut {
                 }
             });
         });
+        this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStoreCutRequest, (0, common_1.mkMessageCase)({
+            startCut: (0, common_1.provideFull)(media_pb_1.StartMediaStoreCut, {
+                ...cutRequest,
+                fileFormat: fileFormat,
+                cuts: toSingleCuts(cutRequest.cuts),
+            })
+        })));
     }
     /** @internal */
-    static async create(cutRequest, client) {
-        const cut = new MediaStoreActiveCut(cutRequest, client);
-        return cut;
+    static create(cutRequest, client) {
+        return new MediaStoreActiveCut(cutRequest, client);
     }
     /**
      * @public
-     * Promise that resolves when the asset import is complete
+     * Promise that resolves when the cut is complete
      */
     async complete() {
         return this._complete;
     }
+    cancel() {
+        if (!this._isComplete) {
+            this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStoreCutRequest, (0, common_1.mkMessageCase)({ cancelCut: (0, common_1.provideFull)(media_pb_1.CancelMediaStoreCut, {}) })));
+        }
+    }
 }
 exports.MediaStoreActiveCut = MediaStoreActiveCut;
+function isMediaStoreAssetFileWithHash(asset) {
+    return 'file' in asset && 'hash' in asset;
+}
 /**
  * @public
  * see: {@link NorskOutput.mediaStore}
@@ -213,11 +305,27 @@ class MediaStoreAsset {
     constructor(settings, client) {
         this.client = client;
         this.settings = settings;
-        this.grpcStream = this.client.media.createMediaStoreAsset((0, common_1.provideFull)(media_pb_1.MediaStoreAssetSettings, { mediaStoreName: settings.name,
-            fileName: settings.file,
+        this.grpcStream = this.client.media.createMediaStoreAsset((0, common_1.provideFull)(media_pb_1.MediaStoreAssetSettings, {
+            mediaStoreName: settings.name,
+            assetSource: (0, common_1.provideFull)(media_pb_1.MediaStoreAssetSource, settings.source ?
+                (isMediaStoreAssetFileWithHash(settings.source) ?
+                    (0, common_1.mkMessageCase)({
+                        fileWithHash: (0, common_1.provideFull)(media_pb_1.MediaStoreAssetFileWithHash, {
+                            file: settings.source.file,
+                            hash: settings.source.hash,
+                            errorOnHashMismatch: settings.source.errorOnHashMismatch ?? true
+                        })
+                    }) :
+                    (0, common_1.mkMessageCase)({
+                        file: (0, common_1.provideFull)(media_pb_1.MediaStoreAssetFile, {
+                            file: settings.source.file,
+                            errorOnHashMismatch: settings.source.errorOnHashMismatch ?? true
+                        })
+                    })) : (0, common_1.mkMessageCase)({ noLoad: (0, common_1.provideFull)(protobuf_1.Empty, {}) })),
             path: settings.path
         }));
         this._ready = new Promise((resolve, reject) => {
+            this.grpcStream.on("error", (err) => reject(err));
             this.grpcStream.on("data", (data) => {
                 const messageCase = data.message.case;
                 switch (messageCase) {
@@ -228,7 +336,9 @@ class MediaStoreAsset {
                         break;
                     }
                     case "importComplete": {
-                        resolve({ durationMs: data.message.value.durationMs, size: data.message.value.size });
+                        this.durationMs = data.message.value.durationMs;
+                        this.size = data.message.value.size;
+                        resolve(this);
                         break;
                     }
                     default:
@@ -239,20 +349,95 @@ class MediaStoreAsset {
     }
     /** @internal */
     static async create(settings, client) {
-        return new MediaStoreAsset(settings, client);
+        const asset = new MediaStoreAsset(settings, client);
+        return asset._ready;
     }
-    /**
-     * @public
-     * Promise that resolves when the asset import is complete
-     */
-    async ready() {
-        return this._ready;
+    cutListEntry(settings) {
+        if (this.durationMs == null) {
+            throw new Error("Attempt to cut from an asset that isn't yet loaded");
+        }
+        if (this.durationMs < Number.MIN_SAFE_INTEGER || this.durationMs > Number.MAX_SAFE_INTEGER) {
+            (0, common_1.debuglog)('The asset duration is longer than the maximum cut, you may not get a cut file of the duration that you expected');
+        }
+        settings.durationMs = settings.durationMs ? (settings.durationMs == "all" ? Number(this.durationMs) : settings.durationMs) : Number(this.durationMs);
+        return {
+            mediaStoreName: this.settings.name,
+            cut: { type: "asset", cut: settings }
+        };
     }
 }
 exports.MediaStoreAsset = MediaStoreAsset;
+/**
+ * @public
+ * see: {@link NorskOutput.mediaStore}
+ */
+class MediaStoreSnapshot {
+    /** @internal */
+    constructor(settings, client) {
+        this.client = client;
+        this.settings = settings;
+        this.grpcStream = this.client.media.createMediaStoreSnapshot();
+        this._ready = new Promise((resolve, reject) => {
+            this.grpcStream.on("error", (err) => reject(err));
+            this.grpcStream.on("data", (data) => {
+                const messageCase = data.message.case;
+                switch (messageCase) {
+                    case undefined:
+                        break;
+                    case "snapshotLoaded":
+                        resolve(this);
+                        break;
+                    case "snapshotUpdated":
+                        this._updated?.resolve();
+                        this._updated = undefined;
+                        break;
+                    case "snapshotUpdateFailed":
+                        this._updated?.reject(new Error("Update failed"));
+                        this._updated = undefined;
+                        break;
+                    default:
+                        (0, common_1.exhaustiveCheck)(messageCase);
+                }
+            });
+        });
+        this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStoreSnapshotMessage, (0, common_1.mkMessageCase)({
+            configuration: (0, common_1.provideFull)(media_pb_1.MediaStoreSnapshotConfiguration, {
+                name: settings.name,
+                path: settings.path
+            })
+        })));
+    }
+    /** @internal */
+    static async create(settings, client) {
+        const snapshot = new MediaStoreSnapshot(settings, client);
+        return snapshot._ready;
+    }
+    async update() {
+        if (this._updated) {
+            return new Promise((_resolve, reject) => { reject(new Error("Update in progress")); });
+        }
+        this.grpcStream.write((0, common_1.provideFull)(media_pb_1.MediaStoreSnapshotMessage, (0, common_1.mkMessageCase)({ update: (0, common_1.provideFull)(protobuf_1.Empty, {}) })));
+        return new Promise((resolve, reject) => { this._updated = { resolve, reject }; });
+    }
+    async metadata() {
+        const fn = util
+            .promisify(this.client.media.mediaStoreMetadata)
+            .bind(this.client.media);
+        return fn((0, common_1.provideFull)(media_pb_1.MediaStoreMetadataRequest, { mediaStoreName: this.settings.name }))
+            .then(fromMediaStoreMetadataResponse);
+    }
+    cutListEntry(settings) {
+        return {
+            mediaStoreName: this.settings.name,
+            cut: { type: "recorder", cut: settings }
+        };
+    }
+}
+exports.MediaStoreSnapshot = MediaStoreSnapshot;
 /** @internal */
 function fromMediaStoreStreamVersion(version) {
-    return { versionNum: version.versionNum,
+    return {
+        versionNum: version.versionNum,
         startDateTime: version.startDateTime,
         durationMs: version.durationMs,
         metadata: (0, types_1.fromStreamMetadata)((0, common_1.mandatory)(version.metadata)),
@@ -261,13 +446,15 @@ function fromMediaStoreStreamVersion(version) {
 }
 /** @internal */
 function fromMediaStoreStream(stream) {
-    return { streamKey: (0, types_1.fromStreamKey)(stream.streamKey),
+    return {
+        streamKey: (0, types_1.fromStreamKey)(stream.streamKey),
         versions: stream.versions.map(fromMediaStoreStreamVersion)
     };
 }
 /** @internal */
 function fromMediaStoreSession(session) {
-    return { sessionNum: session.sessionNum,
+    return {
+        sessionNum: session.sessionNum,
         streams: session.streams.map(fromMediaStoreStream)
     };
 }

package/lib/src/media_nodes/output.d.ts

@@ -270,6 +270,10 @@ export interface HlsPushDestinationSettings {
     this should take into account the end to end latency from source capture, to the part and playlist being published
     */
     partHoldBackSeconds?: number;
+    /** Whether the server supports gzip *request* compression for PUT/POST requests */
+    supportsGzip?: boolean;
+    /** Whether to use TLS or plain TCP transport, by default TLS used if port is 443 */
+    tlsTransport?: boolean;
 }
 /**
  * @public

package/lib/src/media_nodes/output.js

@@ -1448,6 +1448,8 @@ function mkCmafDestination(dest) {
             holdBackSeconds: dest.holdBackSeconds ?? 0.0,
             partHoldBackSeconds: dest.partHoldBackSeconds ?? 0.0,
             sessionId: dest.sessionId ? dest.sessionId : "", defaultSegmentCount: dest.defaultSegmentCount ? (0, utils_1.provideFull)(common_pb_1.OptionalInt, { value: dest.defaultSegmentCount }) : undefined,
+            supportsGzip: !!dest.supportsGzip,
+            tlsTransport: (0, types_1.toOptBool)(dest.tlsTransport)
         };
         return (0, utils_1.provideFull)(media_pb_1.CMAFDestination, (0, utils_1.mkMessageCase)({ hlsPushDestination: (0, utils_1.provideFull)(media_pb_1.HlsPushDestination, conf) }));
     }

package/lib/src/media_nodes/processor.d.ts

@@ -131,6 +131,7 @@ export interface AudioMeasureLevelsSettings extends ProcessorNodeSettings<AudioM
      * @eventProperty
      */
     onData: (levels: AudioMeasureLevels) => void;
+    /** Optionally control the sample frequency */
     intervalFrames?: number;
 }
 /**
@@ -145,6 +146,7 @@ export declare class AudioMeasureLevelsNode extends AutoProcessorMediaNode<"audi
  * see: {@link NorskTransform.streamTimestampNudge}
  * */
 export interface StreamTimestampNudgeSettings extends ProcessorNodeSettings<StreamTimestampNudgeNode> {
+    /** the initial nudge to apply, in milliseconds */
     nudge?: number;
 }
 /**
@@ -714,6 +716,7 @@ export declare class AudioSplitMultichannelNode extends AutoProcessorMediaNode<"
 export interface AudioBuildMultichannelSettings extends ProcessorNodeSettings<AudioBuildMultichannelNode> {
     /** The channel layout of the built outgoing stream */
     channelLayout: ChannelLayout;
+    /** The sample rate of the built outgoing stream */
     sampleRate: SampleRate;
     /**
      * Stream keys specifying the source for each channel, where the order is
@@ -845,7 +848,16 @@ export declare class SubtitleConvertNode extends AutoProcessorMediaNode<"subtitl
  * */
 export interface AudioTranscribeAzureSettings extends ProcessorNodeSettings<AudioTranscribeAzureNode> {
     outputStreamId: number;
+    /** The source language to recognise - an IETF BCP 47 language tag, eg en-US, en-GB, de-DE. Supported languages are
+     * found at https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=stt
+     */
     sourceLanguage: string;
+    /** The target output languages for translation - technically a BCP 47 language tag but but in most cases omitting region, e.g. en, de, zh-Hant.
+    
+     * Leave this field absent/empty to use the transcription service without
+     * translation, while if any target languages are present the translation service will be used even if this is the same as the
+     * source language.
+     */
     targetLanguages?: string[];
     /** Key for the Azure Speech Service endpoint */
     azureKey: string;
@@ -878,8 +890,6 @@ export interface AudioTranscribeWhisperSettings extends ProcessorNodeSettings<Au
      * Default 3000ms.
      */
     stepMs?: number;
-    /** The full audio buffer size. Default 10000ms */
-    lengthMs?: number;
     /** Duration of audio to keep when clearing the buffer to allow for partial-word recognition. Default 400ms */
     keepMs?: number;
     /** Max tokens per segment */

package/lib/src/media_nodes/processor.js

@@ -1918,7 +1918,6 @@ class AudioTranscribeWhisperNode extends AutoProcessorMediaNode {
                 : undefined,
             outputStreamId: settings.outputStreamId,
             stepMs: (0, types_2.toOptInt)(settings.stepMs),
-            lengthMs: (0, types_2.toOptInt)(settings.lengthMs),
             keepMs: (0, types_2.toOptInt)(settings.keepMs),
             maxTokens: (0, types_2.toOptInt)(settings.maxTokens),
             speedUp: (0, types_2.toOptBool)(settings.speedUp),

package/lib/src/media_nodes/types.d.ts

@@ -2,11 +2,6 @@ import { ExplicitChannel, AudioCodec, FrameRate, VideoTransformConfiguration } f
 /** @public */
 export declare type MediaNodeId = string;
 /** @public */
-export interface IntervalTimestamp {
-    n: bigint;
-    d: bigint;
-}
-/** @public */
 export interface StreamKey {
     streamId: number;
     programNumber: number;
@@ -113,7 +108,11 @@ export interface Resolution {
     width: number;
     height: number;
 }
+/** Various options for de-interlacing video either in software or hardware (where available) */
 export declare type DeinterlaceSettings = {
+    /** Use the CPU to perform deinterlace, Note: if the video has been decoded on hardware
+     * it will need to be transferred to system memory and reuploaded again
+     */
     type: 'software';
     algorithm: 'bwdif' | 'kerndeint' | 'nnedi' | 'w3fdif' | 'yadif';
 };
@@ -1338,29 +1337,4 @@ export declare type Scte35GenericDescriptor = {
 };
 /** @public */
 export declare type MediaStoreStreamSelection = [StreamKey, StreamKey];
-/** @public */
-export declare type MediaStoreCut = {
-    /**
-     * Required: Name of the media store instance that this cut is from
-     */
-    mediaStoreName: string;
-    /**
-     * Required: The streams you want to playback from the media store
-     */
-    streamSelection: MediaStoreStreamSelection[];
-    /**
-     * Required: The start date/time for the cut.  For a local recoder or a remote view,
-     * this is UTC.  For an asset store, this starts at zero
-     */
-    startDateTime: Date;
-    /**
-     * Required: The duration of the cut in milliseconds
-     */
-    durationMs: number;
-    /**
-     * Required: In a video stream, if a start time or end time falls mid-gop, should the gop be trimmed to be frame accurate?
-     */
-    trimPartialGops: boolean;
-    sessionNum?: number;
-};
 //# sourceMappingURL=types.d.ts.map

package/lib/src/media_nodes/types.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toSrtMode = exports.fromSrtInputState = exports.fromRtmpServerInputState = exports.toBitDepth = exports.toAmdMA35DHevc = exports.toAmdMA35DH264 = exports.toTrinary = exports.toAmdMA35DEncodeCommon = exports.toAmdMA35DH264Profile = exports.toAmdMA35DHevcProfile = exports.toAmdMA35DHevcTier = exports.toAmdU30Hevc = exports.toAmdU30H264 = exports.toAmdU30H264Profile = exports.toAmdU30HevcProfile = exports.toAmdU30HevcTier = exports.toQuadraHevc = exports.toQuadraH264 = exports.toQuadraH264Profile = exports.toQuadraHevcProfile = exports.toQuadraHevcTier = exports.toLoganHevc = exports.toLoganH264 = exports.toLoganH264Profile = exports.toLoganHevcProfile = exports.toLoganHevcTier = exports.toNvidiaH264 = exports.toNvidiaHevc = exports.toNvidiaH264Profile = exports.toNvidiaHevcProfile = exports.toNvidiaHevcTier = exports.toNvidiaPreset = exports.toNvidiaRateControl = exports.toNvidiaRateControlMode = exports.toX265Codec = exports.toX265Tune = exports.toX264Codec = exports.toDeinterlaceSettings = exports.fromContext = exports.fromStreamMetadata = exports.metadataForStreamKey = exports.fromStreamKey = exports.mkStreamKey = exports.toMediaNodeId = exports.toOptString = exports.mkOptString = exports.toOptBool = exports.mkOptBool = exports.toOptInt = exports.mkOptInt = void 0;
-exports.toSingleCuts = exports.fromScte35PB = exports.toScte35PB = exports.mkWebrtcServerSettings = exports.mkEncryptionSettings = exports.fromSourceSubscriptionError = exports.fromSubscriptionError = exports.fromStreamStatistics = exports.fromAudioMeasureLevels = exports.mkDb = exports.toInterval = exports.fromInterval = exports.addInterval = exports.fromChannelName = exports.toChannelName = exports.getAmountOfChannels = exports.fromChannelLayout = exports.toChannelLayout = exports.fromSampleRate = exports.toSampleRate = exports.toSampleFormat = exports.toSsHardwareAcceleration = exports.toComposeHardwareAcceleration = exports.toComposeMissingStreamBehaviour = exports.toPixelFormat = exports.toSimpleEasing = exports.toAacProfile = exports.toImageFormat = exports.toStabilizationMode = exports.toSentenceBuildMode = exports.fromBrowserEvent = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
+exports.fromScte35PB = exports.toScte35PB = exports.mkWebrtcServerSettings = exports.mkEncryptionSettings = exports.fromSourceSubscriptionError = exports.fromSubscriptionError = exports.fromStreamStatistics = exports.fromAudioMeasureLevels = exports.mkDb = exports.toInterval = exports.fromInterval = exports.addInterval = exports.fromChannelName = exports.toChannelName = exports.getAmountOfChannels = exports.fromChannelLayout = exports.toChannelLayout = exports.fromSampleRate = exports.toSampleRate = exports.toSampleFormat = exports.toSsHardwareAcceleration = exports.toComposeHardwareAcceleration = exports.toComposeMissingStreamBehaviour = exports.toPixelFormat = exports.toSimpleEasing = exports.toAacProfile = exports.toImageFormat = exports.toStabilizationMode = exports.toSentenceBuildMode = exports.fromBrowserEvent = void 0;
 const media_pb_1 = require("@norskvideo/norsk-api/lib/media_pb");
 const common_pb_1 = require("@norskvideo/norsk-api/lib/shared/common_pb");
 const utils_1 = require("../shared/utils");
 const media_pb_2 = require("@norskvideo/norsk-api/lib/media_pb");
-const protobuf_2 = require("@bufbuild/protobuf");
+const protobuf_1 = require("@bufbuild/protobuf");
 /** @internal */
 function mkOptInt(i) {
     return (0, utils_1.provideFull)(common_pb_1.OptionalInt, { value: i });
@@ -2105,9 +2104,9 @@ function toScte35PB(scte35) {
         const t = cmd.type;
         switch (t) {
             case "null":
-                return (0, utils_1.provideFull)(media_pb_2.Scte35SpliceCommand, (0, utils_1.mkMessageCase)({ null: (0, utils_1.provideFull)(protobuf_2.Empty, {}) }));
+                return (0, utils_1.provideFull)(media_pb_2.Scte35SpliceCommand, (0, utils_1.mkMessageCase)({ null: (0, utils_1.provideFull)(protobuf_1.Empty, {}) }));
             case "bandwidthReservation":
-                return (0, utils_1.provideFull)(media_pb_2.Scte35SpliceCommand, (0, utils_1.mkMessageCase)({ bandwidthReservation: (0, utils_1.provideFull)(protobuf_2.Empty, {}) }));
+                return (0, utils_1.provideFull)(media_pb_2.Scte35SpliceCommand, (0, utils_1.mkMessageCase)({ bandwidthReservation: (0, utils_1.provideFull)(protobuf_1.Empty, {}) }));
             case "privateCommand":
                 return (0, utils_1.provideFull)(media_pb_2.Scte35SpliceCommand, (0, utils_1.mkMessageCase)({ privateCommand: (0, utils_1.provideFull)(media_pb_2.Scte35PrivateCommand, cmd.value) }));
             case "timeSignal":
@@ -2316,7 +2315,7 @@ function fromScte35PB(infoPB) {
                     }
                     const fromBreakDuration = (breakDuration) => {
                         if (breakDuration) {
-                            return breakDuration;
+                            return { autoReturn: breakDuration.autoReturn, duration: breakDuration.duration };
                         }
                         else {
                             console.warn("Break duration was missing in splice_insert", spliceCommand);
@@ -2371,19 +2370,4 @@ function fromScte35PB(infoPB) {
     return { ...infoPB, spliceCommand, descriptors: infoPB.descriptors.map(mkDescriptor).filter((x) => x !== undefined) };
 }
 exports.fromScte35PB = fromScte35PB;
-/** @internal */
-function toSingleCuts(cuts) {
-    return cuts.map(({ mediaStoreName, streamSelection, startDateTime, durationMs, trimPartialGops, sessionNum }) => (0, utils_1.provideFull)(media_pb_1.SingleCut, {
-        mediaStoreName: mediaStoreName,
-        streamSelection: streamSelection.map(([sourceStreamKey, outputStreamKey]) => (0, utils_1.provideFull)(media_pb_1.StreamSelection, {
-            sourceStreamKey: mkStreamKey(sourceStreamKey),
-            outputStreamKey: mkStreamKey(outputStreamKey)
-        })),
-        startDateTime: protobuf_1.Timestamp.fromDate(startDateTime),
-        durationMs,
-        trimPartialGops: trimPartialGops,
-        sessionNum: sessionNum ? (0, utils_1.provideFull)(common_pb_1.OptionalInt, { value: sessionNum }) : undefined
-    }));
-}
-exports.toSingleCuts = toSingleCuts;
 //# sourceMappingURL=types.js.map

package/lib/src/sdk.js

@@ -124,9 +124,9 @@ class Norsk {
         this.mediaStore = {
             player: async (settings) => mediaStore_1.MediaStorePlayerNode.create(settings, this._client(), unregisterNode).then(registerNode),
             recorder: async (settings) => mediaStore_1.MediaStoreRecorderNode.create(settings, this._client(), unregisterNode).then(registerNode),
-            makeCut: async (cutRequest) => mediaStore_1.MediaStoreActiveCut.create(cutRequest, this._client()),
-            metadata: async (mediaStoreName) => (0, mediaStore_1.mediaStoreMetadata)(mediaStoreName, this._client()),
-            asset: async (settings) => mediaStore_1.MediaStoreAsset.create(settings, this._client())
+            makeCut: (cutRequest) => mediaStore_1.MediaStoreActiveCut.create(cutRequest, this._client()),
+            asyncLoadAsset: async (settings) => mediaStore_1.MediaStoreAsset.create(settings, this._client()),
+            snapshot: async (settings) => mediaStore_1.MediaStoreSnapshot.create(settings, this._client())
         };
         this.debug = {
             streamTimestampReport: async (settings) => debug_1.StreamTimestampReportNode.create(settings, this._client(), unregisterNode).then(registerNode),

package/package.json

@@ -1,11 +1,11 @@
 {
   "license": "MIT",
   "name": "@norskvideo/norsk-sdk",
-  "version": "1.0.365",
+  "version": "1.0.367",
   "dependencies": {
     "@bufbuild/protobuf": "^0.3.0",
     "@grpc/grpc-js": "^1.2.2",
-    "@norskvideo/norsk-api": "1.0.365",
+    "@norskvideo/norsk-api": "1.0.367",
     "lodash": "^4.17.21",
     "typescript-nullable": "^0.6.0"
   },

package/src/sdk.ts

@@ -104,10 +104,10 @@ import {
   MediaStoreRecorderSettings,
   MediaStoreCutRequest,
   MediaStoreActiveCut,
-  MediaStoreSession,
-  mediaStoreMetadata,
   MediaStoreAssetSettings,
   MediaStoreAsset,
+  MediaStoreSnapshotSettings,
+  MediaStoreSnapshot,
 } from "./media_nodes/mediaStore";
 
 export * from "./types";
@@ -577,12 +577,12 @@ export class Norsk {
         MediaStorePlayerNode.create(settings, this._client(), unregisterNode).then(registerNode),
       recorder: async (settings: MediaStoreRecorderSettings) =>
         MediaStoreRecorderNode.create(settings, this._client(), unregisterNode).then(registerNode),
-      makeCut: async (cutRequest: MediaStoreCutRequest) =>
+      makeCut: (cutRequest: MediaStoreCutRequest) =>
         MediaStoreActiveCut.create(cutRequest, this._client()),
-      metadata: async (mediaStoreName: string) : Promise<MediaStoreSession[]> =>
-        mediaStoreMetadata(mediaStoreName, this._client()),
-      asset: async(settings: MediaStoreAssetSettings) =>
-        MediaStoreAsset.create(settings, this._client())
+      asyncLoadAsset: async(settings: MediaStoreAssetSettings) =>
+        MediaStoreAsset.create(settings, this._client()),
+      snapshot: async(settings: MediaStoreSnapshotSettings) =>
+        MediaStoreSnapshot.create(settings, this._client())
     }
     this.debug = {
       streamTimestampReport: async (settings: StreamTimestampReportSettings) =>