video-fps-probe 0.2.0 → 0.3.0

package/dist/worker/serve.js

@@ -0,0 +1,97 @@
+import { errorMessage, isAbortError } from "../core/dispatch.js";
+import { containerFamily } from "../core/sniff.js";
+import { PROTOCOL_VERSION } from "./protocol.js";
+const PROGRESS_INTERVAL_MS = 50;
+const failure = (message, code) => Object.assign(new Error(message), { code });
+const isFamily = (c) => c === 'isobmff' || c === 'matroska';
+export function serveProbeWorker(engines) {
+    const ctx = self;
+    const loaded = new Map();
+    const running = new Map();
+    const post = (reply) => ctx.postMessage({ v: PROTOCOL_VERSION, ...reply });
+    const load = (id) => {
+        let module = loaded.get(id);
+        if (!module) {
+            const source = Object.hasOwn(engines, id) ? engines[id] : undefined;
+            if (!source)
+                return Promise.reject(failure(`unknown engine ${id}`, 'unknown-engine'));
+            module = (typeof source === 'function' ? Promise.all([source(), import("../core/stats.js")]).then(([m]) => m) : Promise.resolve(source)).catch((e) => {
+                loaded.delete(id);
+                throw e;
+            });
+            loaded.set(id, module);
+        }
+        return module;
+    };
+    const fail = (id, e, aborted = false, loading = false) => {
+        const code = e?.code;
+        const known = code === 'unknown-engine' || code === 'protocol';
+        post({
+            type: 'error',
+            id,
+            message: errorMessage(e),
+            aborted: aborted || isAbortError(e),
+            ...(known ? { code } : loading && { reason: 'load' }),
+        });
+    };
+    const analyzeJob = async (job) => {
+        const controller = new AbortController();
+        running.set(job.id, controller);
+        let lastProgress = 0;
+        let loading = true;
+        try {
+            if (!(job.file instanceof Blob))
+                throw failure('malformed analyze request', 'protocol');
+            const engine = await load(job.engine);
+            loading = false;
+            if (engine.containers !== 'any') {
+                const family = await containerFamily(job.file);
+                if (!family || !engine.containers.includes(family))
+                    return post({ type: 'skipped', id: job.id, reason: 'unsupported-container', family });
+            }
+            const result = await engine.run(job.file, job.name, {
+                ...job.options,
+                signal: controller.signal,
+                onProgress: (progress) => {
+                    const now = performance.now();
+                    if (now - lastProgress < PROGRESS_INTERVAL_MS)
+                        return;
+                    lastProgress = now;
+                    post({ type: 'progress', id: job.id, progress });
+                },
+            });
+            post({ type: 'result', id: job.id, result });
+        }
+        catch (e) {
+            fail(job.id, e, controller.signal.aborted, loading);
+        }
+        finally {
+            running.delete(job.id);
+        }
+    };
+    const warmJob = async (job) => {
+        try {
+            if (![job.engines, job.containers].every(Array.isArray) || !job.containers.every(isFamily))
+                throw failure('malformed warm request', 'protocol');
+            await Promise.all(job.engines.map(async (id) => (await load(id)).warm?.(job.containers)));
+            post({ type: 'warmed', id: job.id });
+        }
+        catch (e) {
+            fail(job.id, e, false, true);
+        }
+    };
+    ctx.onmessage = ({ data }) => {
+        if (data?.v !== PROTOCOL_VERSION)
+            return fail(data?.id ?? 0, failure(`unsupported protocol version ${data?.v}`, 'protocol'));
+        if (data.type === 'cancel')
+            running.get(data.id)?.abort();
+        else if (data.type === 'analyze')
+            void analyzeJob(data);
+        else if (data.type === 'warm')
+            void warmJob(data);
+        else {
+            const unknown = data;
+            fail(unknown.id, failure(`unknown request type ${unknown.type}`, 'protocol'));
+        }
+    };
+}

package/dist/worker/single.js

@@ -0,0 +1,13 @@
+import { analyzeWith } from "../core/dispatch.js";
+const LABEL = { isobmff: 'ISO BMFF', matroska: 'Matroska' };
+export const wrongFamily = (served, found) => `the own ${LABEL[served]} worker does not read ${LABEL[found]}`;
+export function singleContainerEngine(kind, analyzer) {
+    return {
+        containers: 'any',
+        run: (blob, name, opts) => analyzeWith(blob, name, opts, (found) => {
+            if (found !== kind)
+                throw new Error(wrongFamily(kind, found));
+            return analyzer;
+        }),
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "video-fps-probe",
   "private": false,
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Video frame rate, frame count and VFR detection from MP4/MOV/WebM/MKV container headers in a Web Worker. Matches ffprobe 8.1.1 on the test corpus (0 mismatches), no decoding.",
   "type": "module",
   "license": "MIT",
@@ -54,6 +54,9 @@
       "presets": [
         "dist/presets/index.d.ts"
       ],
+      "presets/sources.json": [
+        "dist/presets/sources.json"
+      ],
       "mp4box": [
         "dist/plugins/mp4box.d.ts"
       ],
@@ -103,6 +106,7 @@
       "types": "./dist/presets/index.d.ts",
       "default": "./dist/presets/index.js"
     },
+    "./presets/sources.json": "./dist/presets/sources.json",
     "./mp4box": {
       "types": "./dist/plugins/mp4box.d.ts",
       "default": "./dist/plugins/mp4box.js"
@@ -128,6 +132,8 @@
       "default": "./dist/engines/mediabunny.js"
     },
     "./standalone/own.worker.js": "./dist/standalone/own.worker.js",
+    "./standalone/own-isobmff.worker.js": "./dist/standalone/own-isobmff.worker.js",
+    "./standalone/own-matroska.worker.js": "./dist/standalone/own-matroska.worker.js",
     "./package.json": "./package.json"
   },
   "peerDependencies": {
@@ -160,7 +166,7 @@
     "build:demo": "tsc -b && vite build --config demo/vite.config.ts",
     "preview": "vite preview --config demo/vite.config.ts",
     "check:package": "publint --strict && node scripts/check-dist.mjs",
-    "check:types": "npx --yes @arethetypeswrong/cli@0.18.5 --pack . --ignore-rules cjs-resolves-to-esm --exclude-entrypoints ./standalone/own.worker.js",
+    "check:types": "npx --yes @arethetypeswrong/cli@0.18.5 --pack . --ignore-rules cjs-resolves-to-esm --exclude-entrypoints ./standalone/own.worker.js ./standalone/own-isobmff.worker.js ./standalone/own-matroska.worker.js",
     "prepack": "npm run build:lib && node scripts/check-dist.mjs",
     "check:aliases": "node scripts/src-aliases.mjs --check",
     "check:stable-chunks": "node scripts/check-stable-chunks.mjs",

package/dist/client/inline.d.ts

@@ -1,19 +0,0 @@
-import type { AnalyzeProgress, EngineId, FileResult } from '../core/types.js';
-import type { ContainerFamily, EngineModule } from '../plugins/types.js';
-import type { SkipReason, WireOptions } from '../worker/protocol.js';
-export interface InlineRun {
-    engine: EngineId;
-    signals: readonly (AbortSignal | null | undefined)[];
-    timeoutMs?: number;
-    onProgress?: (progress: AnalyzeProgress) => void;
-    host?: HTMLElement;
-}
-export type InlineReply = {
-    type: 'result';
-    result: FileResult;
-} | {
-    type: 'skipped';
-    reason: SkipReason;
-    family: ContainerFamily | null;
-};
-export declare function runInline(load: () => Promise<EngineModule>, file: Blob, name: string, options: WireOptions, run: InlineRun): Promise<InlineReply>;

package/dist/client/pool.d.ts

@@ -1,29 +0,0 @@
-import { ProbeError } from '../api/errors.js';
-import type { AnalyzeProgress, EngineId } from '../core/types.js';
-import { type JobRequest, type WorkerResponse } from '../worker/protocol.js';
-export declare const KILL_AFTER_MS = 1500;
-export declare const DEFAULT_IDLE_TIMEOUT_MS = 30000;
-export declare const LOAD_FAILED = "worker script failed to load or parse; the app may have been redeployed";
-export declare const workerFailed: (message: string, reason: NonNullable<ProbeError["reason"]>, engine?: EngineId | null, cause?: unknown) => ProbeError;
-export interface PoolOptions {
-    create: () => Worker;
-    size?: number;
-    idleTimeoutMs?: number;
-}
-export interface RunOptions {
-    signal?: AbortSignal | null;
-    timeoutMs?: number;
-    onProgress?: (progress: AnalyzeProgress) => void;
-    engine?: EngineId | null;
-}
-export type PoolReply = Extract<WorkerResponse, {
-    type: 'result' | 'skipped' | 'warmed';
-}>;
-export declare class WorkerPool {
-    #private;
-    constructor(options: PoolOptions);
-    get workers(): number;
-    run(request: JobRequest, options?: RunOptions): Promise<PoolReply>;
-    dispose(): void;
-    destroy(): void;
-}

package/dist/client/probe.d.ts

@@ -1,29 +0,0 @@
-import { ProbeError } from '../api/errors.js';
-import type { EngineId } from '../core/types.js';
-import type { EngineDescriptor, EngineModule, WorkerEngineId } from '../plugins/types.js';
-import type { WireOptions } from '../worker/protocol.js';
-import type { InlineReply } from './inline.js';
-import { WorkerPool } from './pool.js';
-import type { BaseOptions, CallOptions, ClientOptions, CustomWorker, IdOf, Probe } from './types.js';
-export interface CoreOptions extends BaseOptions<EngineId> {
-    worker?: CustomWorker<WorkerEngineId> | 'inline';
-    engines?: readonly EngineDescriptor[];
-}
-export type Route = {
-    kind: string;
-    pool: () => WorkerPool;
-} | {
-    load: () => Promise<EngineModule>;
-} | {
-    error: ProbeError;
-};
-export type Run = (id: EngineId, file: Blob, name: string, wire: WireOptions, call: CallOptions<EngineId>) => Promise<InlineReply>;
-export interface CompareContext {
-    engines: readonly EngineId[];
-    routes: ReadonlyMap<EngineId, Route>;
-    run: Run;
-    defaults?: WireOptions;
-}
-export declare const nameOf: (file: Blob) => string;
-export declare function createProbeCore(options: CoreOptions): Probe<EngineId>;
-export declare function createProbeClient<const E extends readonly EngineDescriptor[] = [], const W extends WorkerEngineId = never>(options: ClientOptions<E, W>): Probe<W | IdOf<E[number]> | 'own'>;