@missing-elements/h5p-offline-player 0.1.0 → 0.1.1

package/types/sw/package-reader.d.ts

@@ -1,6 +1,6 @@
 import { type FileEntry } from '@zip.js/zip.js';
 import { type MissingLibraries, type PrefetchEntry } from '../shared/protocol';
-import { type SourceHandle } from '../shared/source';
+import type { SourceHandle } from '../shared/source';
 import type { ByteRange } from '../shared/range';
 import type { ForwardIndexSnapshot } from '../shared/forward-index';
 /**
@@ -21,6 +21,9 @@ export type Strategy =
  | {
     kind: 'chunked';
 };
+/** Zip compression methods: the only two an H5P package is served with. */
+export declare const STORED = 0;
+export declare const DEFLATE = 8;
 /** The parts of `h5p.json` the player needs. Everything in it comes from an untrusted archive. */
 export interface PackageManifest {
     title?: string;
@@ -54,7 +57,8 @@ export interface LocatedEntry {
     entry: IndexedEntry;
 }
 export declare class PackageReader {
-    private readonly handle;
+    /** The archive this reader reads. Exposed for the Jobs worker's liveness reports. */
+    readonly handle: SourceHandle;
     readonly pkgId: string;
     readonly entries: Map<string, IndexedEntry>;
     readonly rejected: string[];

package/types/sw/watermark-wait.d.ts

@@ -0,0 +1,21 @@
+import { type ChunkMeta, type ChunkStore } from '../shared/chunk-store';
+/**
+ * Waits until the entry has at least `needed` bytes, is complete, or carries a recorded failure.
+ *
+ * The bound is a stall, not a wall clock: extraction of a large entry legitimately takes minutes,
+ * and a request for the tail of a 220 MB video cannot be answered until it finishes. What must
+ * not happen is waiting on a job that has died with the tab that owned it, so the job is expected
+ * to keep showing progress — when it stops, the job is asked for again, and only a second silent
+ * stretch gives up.
+ *
+ * Progress is two things. The watermark moving is the obvious one. The other is input: the Jobs
+ * worker announces the bytes it has taken from the network, and those count too, because on a
+ * slow or erratic host the inflate can be starved for longer than the stall bound before it has
+ * produced its first flush, while the job is perfectly alive. Measured against a 93 MB deflated
+ * video on a host with half-second latency, the first byte of output took 8.6 s on a fast link
+ * and past 30 s on a 4 Mbit/s one — and the old bound read the second as a dead job.
+ */
+export declare function waitForWatermark(store: ChunkStore, entry: string, needed: number, options?: {
+    stallMs?: number;
+    onStall?: () => Promise<void>;
+}): Promise<ChunkMeta | null>;