@camstack/addon-benchmark 0.1.12 → 0.1.14

package/dist/@mf-types/compiled-types/benchmark-schemas.d.ts

@@ -0,0 +1,580 @@
+/**
+ * Zod schemas for the benchmark customActions catalog.
+ *
+ * Moved from `@camstack/types/capabilities/pipeline-executor.cap.ts` (2026-04-14)
+ * — benchmark shapes belong to the addon that implements them, not the
+ * pipeline-executor cap. `PipelineEngineChoiceSchema` and
+ * `PipelineStepInputSchema` are still imported from `@camstack/types`
+ * because they describe pipeline-executor concepts the benchmark only
+ * consumes (engine identity + step tree).
+ */
+import { z } from 'zod';
+import type { PipelineStepInputOutput } from '@camstack/types';
+export type { PipelineStepInputOutput };
+/**
+ * Pipeline benchmark history entry — output of a single `runPipelineTest`
+ * (or parallel aggregate). Stored with `kind: 'pipeline'` discriminator so
+ * the history list can mix decoder-perf entries without schema collisions.
+ */
+export declare const PipelineBenchmarkHistoryEntrySchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodLiteral<"pipeline">>;
+    id: z.ZodString;
+    date: z.ZodString;
+    stepId: z.ZodString;
+    modelId: z.ZodString;
+    runtime: z.ZodString;
+    iterations: z.ZodNumber;
+    warmup: z.ZodNumber;
+    fps: z.ZodNumber;
+    avgMs: z.ZodNumber;
+    medianMs: z.ZodNumber;
+    p95Ms: z.ZodNumber;
+    p99Ms: z.ZodNumber;
+    minMs: z.ZodNumber;
+    maxMs: z.ZodNumber;
+    avgDetections: z.ZodNumber;
+    referenceImage: z.ZodOptional<z.ZodString>;
+    parallelRuns: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const PipelineBenchmarkHistoryEntryInputSchema: z.ZodObject<{
+    runtime: z.ZodString;
+    modelId: z.ZodString;
+    referenceImage: z.ZodOptional<z.ZodString>;
+    stepId: z.ZodString;
+    fps: z.ZodNumber;
+    p95Ms: z.ZodNumber;
+    avgDetections: z.ZodNumber;
+    iterations: z.ZodNumber;
+    warmup: z.ZodNumber;
+    avgMs: z.ZodNumber;
+    medianMs: z.ZodNumber;
+    p99Ms: z.ZodNumber;
+    minMs: z.ZodNumber;
+    maxMs: z.ZodNumber;
+    parallelRuns: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Legacy aliases — kept to avoid breaking imports from pre-v2 consumers.
+ * Both resolve to the discriminated pipeline variant.
+ */
+export declare const BenchmarkHistoryEntrySchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodLiteral<"pipeline">>;
+    id: z.ZodString;
+    date: z.ZodString;
+    stepId: z.ZodString;
+    modelId: z.ZodString;
+    runtime: z.ZodString;
+    iterations: z.ZodNumber;
+    warmup: z.ZodNumber;
+    fps: z.ZodNumber;
+    avgMs: z.ZodNumber;
+    medianMs: z.ZodNumber;
+    p95Ms: z.ZodNumber;
+    p99Ms: z.ZodNumber;
+    minMs: z.ZodNumber;
+    maxMs: z.ZodNumber;
+    avgDetections: z.ZodNumber;
+    referenceImage: z.ZodOptional<z.ZodString>;
+    parallelRuns: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const BenchmarkHistoryEntryInputSchema: z.ZodObject<{
+    runtime: z.ZodString;
+    modelId: z.ZodString;
+    referenceImage: z.ZodOptional<z.ZodString>;
+    stepId: z.ZodString;
+    fps: z.ZodNumber;
+    p95Ms: z.ZodNumber;
+    avgDetections: z.ZodNumber;
+    iterations: z.ZodNumber;
+    warmup: z.ZodNumber;
+    avgMs: z.ZodNumber;
+    medianMs: z.ZodNumber;
+    p99Ms: z.ZodNumber;
+    minMs: z.ZodNumber;
+    maxMs: z.ZodNumber;
+    parallelRuns: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const DecoderFixtureCodecSchema: z.ZodEnum<{
+    h264: "h264";
+    h265: "h265";
+}>;
+export declare const DecoderFixtureSchema: z.ZodObject<{
+    filename: z.ZodString;
+    codec: z.ZodEnum<{
+        h264: "h264";
+        h265: "h265";
+    }>;
+    resolutionLabel: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const CamProfileSchema: z.ZodEnum<{
+    high: "high";
+    mid: "mid";
+    low: "low";
+}>;
+export declare const DecoderPerfSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"sample">;
+    fixtureFilename: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"stream">;
+    deviceId: z.ZodNumber;
+    profile: z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+    }>;
+}, z.core.$strip>], "kind">;
+export declare const DecoderPerfModeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"duration">;
+    durationSec: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"iterations">;
+    iterations: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+export declare const DecoderPerfFormatSchema: z.ZodEnum<{
+    jpeg: "jpeg";
+    gray: "gray";
+}>;
+export declare const DecoderPerfHwaccelSchema: z.ZodEnum<{
+    none: "none";
+    auto: "auto";
+    videotoolbox: "videotoolbox";
+    cuda: "cuda";
+    nvdec: "nvdec";
+    vaapi: "vaapi";
+    qsv: "qsv";
+    d3d11va: "d3d11va";
+    dxva2: "dxva2";
+    amf: "amf";
+    vdpau: "vdpau";
+    drm: "drm";
+}>;
+export declare const DecoderPerfThresholdsSchema: z.ZodObject<{
+    warnMBMin: z.ZodDefault<z.ZodNumber>;
+    failMBMin: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const DecoderPerfInputSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    cameras: z.ZodNumber;
+    mode: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"duration">;
+        durationSec: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"iterations">;
+        iterations: z.ZodNumber;
+    }, z.core.$strip>], "kind">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"sample">;
+        fixtureFilename: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"stream">;
+        deviceId: z.ZodNumber;
+        profile: z.ZodEnum<{
+            high: "high";
+            mid: "mid";
+            low: "low";
+        }>;
+    }, z.core.$strip>], "kind">;
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+        gray: "gray";
+    }>;
+    fps: z.ZodNumber;
+    toggleMs: z.ZodDefault<z.ZodNumber>;
+    warmupSec: z.ZodDefault<z.ZodNumber>;
+    sampleIntervalMs: z.ZodDefault<z.ZodNumber>;
+    hwaccel: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        auto: "auto";
+        videotoolbox: "videotoolbox";
+        cuda: "cuda";
+        nvdec: "nvdec";
+        vaapi: "vaapi";
+        qsv: "qsv";
+        d3d11va: "d3d11va";
+        dxva2: "dxva2";
+        amf: "amf";
+        vdpau: "vdpau";
+        drm: "drm";
+    }>>;
+    thresholds: z.ZodDefault<z.ZodObject<{
+        warnMBMin: z.ZodDefault<z.ZodNumber>;
+        failMBMin: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DecoderPerfSampleSchema: z.ZodObject<{
+    tSec: z.ZodNumber;
+    rssMB: z.ZodNumber;
+    heapMB: z.ZodNumber;
+    externalMB: z.ZodNumber;
+    arrayBuffersMB: z.ZodNumber;
+    cpuPct: z.ZodNumber;
+    framesTotal: z.ZodNumber;
+}, z.core.$strip>;
+export declare const DecoderPerfVerdictSchema: z.ZodEnum<{
+    error: "error";
+    warn: "warn";
+    aborted: "aborted";
+    pass: "pass";
+    fail: "fail";
+}>;
+export declare const DecoderPerfResultSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    verdict: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        aborted: "aborted";
+        pass: "pass";
+        fail: "fail";
+    }>;
+    aborted: z.ZodDefault<z.ZodBoolean>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    samples: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        tSec: z.ZodNumber;
+        rssMB: z.ZodNumber;
+        heapMB: z.ZodNumber;
+        externalMB: z.ZodNumber;
+        arrayBuffersMB: z.ZodNumber;
+        cpuPct: z.ZodNumber;
+        framesTotal: z.ZodNumber;
+    }, z.core.$strip>>>;
+    slopes: z.ZodObject<{
+        rssMBMin: z.ZodNumber;
+        heapMBMin: z.ZodNumber;
+        externalMBMin: z.ZodNumber;
+    }, z.core.$strip>;
+    totals: z.ZodObject<{
+        wallSec: z.ZodNumber;
+        framesEmitted: z.ZodNumber;
+        fpsPerCamera: z.ZodNumber;
+        cpuAvgPct: z.ZodNumber;
+        droppedFrames: z.ZodNumber;
+    }, z.core.$strip>;
+    config: z.ZodObject<{
+        sessionId: z.ZodString;
+        cameras: z.ZodNumber;
+        mode: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"duration">;
+            durationSec: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"iterations">;
+            iterations: z.ZodNumber;
+        }, z.core.$strip>], "kind">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"sample">;
+            fixtureFilename: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"stream">;
+            deviceId: z.ZodNumber;
+            profile: z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>;
+        }, z.core.$strip>], "kind">;
+        format: z.ZodEnum<{
+            jpeg: "jpeg";
+            gray: "gray";
+        }>;
+        fps: z.ZodNumber;
+        toggleMs: z.ZodDefault<z.ZodNumber>;
+        warmupSec: z.ZodDefault<z.ZodNumber>;
+        sampleIntervalMs: z.ZodDefault<z.ZodNumber>;
+        hwaccel: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            auto: "auto";
+            videotoolbox: "videotoolbox";
+            cuda: "cuda";
+            nvdec: "nvdec";
+            vaapi: "vaapi";
+            qsv: "qsv";
+            d3d11va: "d3d11va";
+            dxva2: "dxva2";
+            amf: "amf";
+            vdpau: "vdpau";
+            drm: "drm";
+        }>>;
+        thresholds: z.ZodDefault<z.ZodObject<{
+            warnMBMin: z.ZodDefault<z.ZodNumber>;
+            failMBMin: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Progress event payload emitted on `benchmark.progress` category during a
+ * decoder perf run. Discriminated via `kind: 'decoder-perf'` so the
+ * existing pipeline benchmark progress listeners ignore these.
+ */
+export declare const DecoderPerfProgressSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"decoder-perf">;
+    sessionId: z.ZodString;
+    phase: z.ZodEnum<{
+        running: "running";
+        error: "error";
+        complete: "complete";
+        aborted: "aborted";
+        init: "init";
+        warmup: "warmup";
+    }>;
+    tSec: z.ZodOptional<z.ZodNumber>;
+    sample: z.ZodOptional<z.ZodObject<{
+        tSec: z.ZodNumber;
+        rssMB: z.ZodNumber;
+        heapMB: z.ZodNumber;
+        externalMB: z.ZodNumber;
+        arrayBuffersMB: z.ZodNumber;
+        cpuPct: z.ZodNumber;
+        framesTotal: z.ZodNumber;
+    }, z.core.$strip>>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DecoderPerfHistoryEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"decoder-perf">;
+    id: z.ZodString;
+    date: z.ZodString;
+    sessionId: z.ZodString;
+    verdict: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        aborted: "aborted";
+        pass: "pass";
+        fail: "fail";
+    }>;
+    cameras: z.ZodNumber;
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+        gray: "gray";
+    }>;
+    sourceLabel: z.ZodString;
+    modeLabel: z.ZodString;
+    rssSlopeMBMin: z.ZodNumber;
+    heapSlopeMBMin: z.ZodNumber;
+    externalSlopeMBMin: z.ZodNumber;
+    framesEmitted: z.ZodNumber;
+    fpsPerCamera: z.ZodNumber;
+    cpuAvgPct: z.ZodNumber;
+    droppedFrames: z.ZodNumber;
+    wallSec: z.ZodNumber;
+    hwaccel: z.ZodEnum<{
+        none: "none";
+        auto: "auto";
+        videotoolbox: "videotoolbox";
+        cuda: "cuda";
+        nvdec: "nvdec";
+        vaapi: "vaapi";
+        qsv: "qsv";
+        d3d11va: "d3d11va";
+        dxva2: "dxva2";
+        amf: "amf";
+        vdpau: "vdpau";
+        drm: "drm";
+    }>;
+}, z.core.$strip>;
+export declare const DecoderPerfHistoryEntryInputSchema: z.ZodObject<{
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+        gray: "gray";
+    }>;
+    hwaccel: z.ZodEnum<{
+        none: "none";
+        auto: "auto";
+        videotoolbox: "videotoolbox";
+        cuda: "cuda";
+        nvdec: "nvdec";
+        vaapi: "vaapi";
+        qsv: "qsv";
+        d3d11va: "d3d11va";
+        dxva2: "dxva2";
+        amf: "amf";
+        vdpau: "vdpau";
+        drm: "drm";
+    }>;
+    sessionId: z.ZodString;
+    droppedFrames: z.ZodNumber;
+    cameras: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        aborted: "aborted";
+        pass: "pass";
+        fail: "fail";
+    }>;
+    wallSec: z.ZodNumber;
+    framesEmitted: z.ZodNumber;
+    fpsPerCamera: z.ZodNumber;
+    cpuAvgPct: z.ZodNumber;
+    sourceLabel: z.ZodString;
+    modeLabel: z.ZodString;
+    rssSlopeMBMin: z.ZodNumber;
+    heapSlopeMBMin: z.ZodNumber;
+    externalSlopeMBMin: z.ZodNumber;
+}, z.core.$strip>;
+export declare const HistoryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodDefault<z.ZodLiteral<"pipeline">>;
+    id: z.ZodString;
+    date: z.ZodString;
+    stepId: z.ZodString;
+    modelId: z.ZodString;
+    runtime: z.ZodString;
+    iterations: z.ZodNumber;
+    warmup: z.ZodNumber;
+    fps: z.ZodNumber;
+    avgMs: z.ZodNumber;
+    medianMs: z.ZodNumber;
+    p95Ms: z.ZodNumber;
+    p99Ms: z.ZodNumber;
+    minMs: z.ZodNumber;
+    maxMs: z.ZodNumber;
+    avgDetections: z.ZodNumber;
+    referenceImage: z.ZodOptional<z.ZodString>;
+    parallelRuns: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"decoder-perf">;
+    id: z.ZodString;
+    date: z.ZodString;
+    sessionId: z.ZodString;
+    verdict: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        aborted: "aborted";
+        pass: "pass";
+        fail: "fail";
+    }>;
+    cameras: z.ZodNumber;
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+        gray: "gray";
+    }>;
+    sourceLabel: z.ZodString;
+    modeLabel: z.ZodString;
+    rssSlopeMBMin: z.ZodNumber;
+    heapSlopeMBMin: z.ZodNumber;
+    externalSlopeMBMin: z.ZodNumber;
+    framesEmitted: z.ZodNumber;
+    fpsPerCamera: z.ZodNumber;
+    cpuAvgPct: z.ZodNumber;
+    droppedFrames: z.ZodNumber;
+    wallSec: z.ZodNumber;
+    hwaccel: z.ZodEnum<{
+        none: "none";
+        auto: "auto";
+        videotoolbox: "videotoolbox";
+        cuda: "cuda";
+        nvdec: "nvdec";
+        vaapi: "vaapi";
+        qsv: "qsv";
+        d3d11va: "d3d11va";
+        dxva2: "dxva2";
+        amf: "amf";
+        vdpau: "vdpau";
+        drm: "drm";
+    }>;
+}, z.core.$strip>], "kind">;
+export interface PipelineRunInputShape {
+    readonly steps: readonly PipelineStepInputOutput[];
+    readonly imageBase64?: string;
+    readonly referenceImage?: string;
+    /**
+     * Optional cached-frame id obtained from `cacheBenchFrame`. When set,
+     * the bench addon forwards the cached raw RGB buffer to
+     * `pipelineExecutor.runPipeline` via the `frame` field — bypasses
+     * per-call JPEG decode + base64 transfer.
+     */
+    readonly frameId?: string;
+    readonly nodeId?: string;
+    readonly sessionId?: string;
+    /**
+     * Per-run engine override. When present, the target addon builds a
+     * one-shot engine for this bench call WITHOUT mutating its saved
+     * `currentEngine`. Drives the "change engine in bench and see the
+     * swap take effect" flow.
+     */
+    readonly engine?: {
+        readonly runtime: 'python' | 'node';
+        readonly backend: string;
+        readonly format: 'onnx' | 'coreml' | 'openvino';
+        readonly device?: string;
+    };
+}
+export declare const PipelineRunInputSchema: z.ZodType<PipelineRunInputShape>;
+/**
+ * Batched pipeline test — sends N copies of the same image as one
+ * `runPipelineBatch` cap call. The benchmark addon decodes the JPEG
+ * once into RGB on the hub, then ships N FrameInputs in a single
+ * MsgPack hop to the target node where the Python pool collapses
+ * them into one `MSG_INFER_BATCH = 0x03` IPC frame. Used by the
+ * Image tab when `batchSize > 1` to amortise per-call overhead.
+ */
+export interface PipelineRunBatchInputShape {
+    readonly steps: readonly PipelineStepInputOutput[];
+    readonly imageBase64: string;
+    readonly batchSize: number;
+    /**
+     * Resize the decoded RGB to this square size before shipping the
+     * batch over Moleculer. Stays under the cluster transporter's
+     * `maxPacketSize` cap (default 10 MB) — at 640×640 a 4-frame batch
+     * is ~4.9 MB. Defaults to 640.
+     */
+    readonly targetSize?: number;
+    readonly nodeId?: string;
+    readonly sessionId?: string;
+    readonly engine?: PipelineRunInputShape['engine'];
+}
+export declare const PipelineRunBatchInputSchema: z.ZodType<PipelineRunBatchInputShape>;
+/**
+ * Output of a batched pipeline test. Carries one `FrameResult` per
+ * input frame plus aggregate timing (total cap call wall-clock and
+ * the last batch's reported inference time).
+ */
+export declare const PipelineRunBatchResultSchema: z.ZodObject<{
+    results: z.ZodReadonly<z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    callMs: z.ZodNumber;
+    inferMs: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Multi-camera stress tester input.
+ *
+ * Replicates a sustained multi-camera inference workload in-process
+ * so we can measure the pool's true detections-per-second ceiling
+ * without paying tRPC + JPEG decode + JSON marshalling on every call.
+ *
+ * Workflow inside the addon:
+ *   1. Decode + sharp-resize the input JPEG ONCE to `targetSize`×raw RGB.
+ *   2. Pre-build the FrameInput[] templates for batched + single calls.
+ *   3. Launch `simulatedCameras` parallel "cameras" that each loop
+ *      `batchesPerCamera` times. Per round, dispatch:
+ *      - 1× `runPipelineBatch.mutate(frames=N)` (counted as `+= batchSize`)
+ *      - `extraSinglesPerRound`× `runPipelineBatch.mutate(frames=1)` (side-load)
+ *   4. Aggregate detsPerSec = (simulatedCameras × batchesPerCamera × batchSize) / totalMs.
+ *
+ * If detection-pipeline is co-located on the same node, the cap calls
+ * short-circuit through `localProviderLink` (no JSON, no TLS, no IPC).
+ * This isolates the pure pool throughput so we can compare against
+ * external detector-engine benchmarks.
+ */
+export interface MultiCameraStressInputShape {
+    readonly steps: readonly PipelineStepInputOutput[];
+    readonly imageBase64: string;
+    readonly targetSize?: number;
+    readonly simulatedCameras?: number;
+    readonly batchesPerCamera?: number;
+    readonly batchSize?: number;
+    readonly extraSinglesPerRound?: number;
+    readonly nodeId?: string;
+    readonly sessionId?: string;
+}
+export declare const MultiCameraStressInputSchema: z.ZodType<MultiCameraStressInputShape>;
+export declare const MultiCameraStressResultSchema: z.ZodObject<{
+    totalMs: z.ZodNumber;
+    countedDetections: z.ZodNumber;
+    detsPerSec: z.ZodNumber;
+    totalCalls: z.ZodNumber;
+    totalFrames: z.ZodNumber;
+    callMsP50: z.ZodNumber;
+    callMsP95: z.ZodNumber;
+    callMsP99: z.ZodNumber;
+    inferMsMean: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=benchmark-schemas.d.ts.map

package/dist/@mf-types/compiled-types/benchmark-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark-schemas.d.ts","sourceRoot":"","sources":["../../../src/benchmark-schemas.ts"],"names":[],"mappings":"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"}

package/dist/@mf-types/compiled-types/components/NodeSelector.d.ts

@@ -0,0 +1,7 @@
+interface NodeSelectorProps {
+    readonly selectedNodeId: string;
+    readonly onSelect: (nodeId: string) => void;
+}
+export declare function NodeSelector({ selectedNodeId, onSelect }: NodeSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=NodeSelector.d.ts.map

package/dist/@mf-types/compiled-types/components/NodeSelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeSelector.d.ts","sourceRoot":"","sources":["../../../../src/components/NodeSelector.tsx"],"names":[],"mappings":"AASA,UAAU,iBAAiB;IACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CAC5C;AAED,wBAAgB,YAAY,CAAC,EAAE,cAAc,EAAE,QAAQ,EAAE,EAAE,iBAAiB,2CAE3E"}

package/dist/@mf-types/compiled-types/page.d.ts

@@ -0,0 +1,4 @@
+import './index.css';
+import { type AddonPageProps } from '@camstack/ui-library';
+export default function BenchmarkPage({ trpc }: AddonPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=page.d.ts.map

package/dist/@mf-types/compiled-types/page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../src/page.tsx"],"names":[],"mappings":"AACA,OAAO,aAAa,CAAA;AAEpB,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAgB1E,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,EAAE,IAAI,EAAE,EAAE,cAAc,2CAuC7D"}

package/dist/@mf-types/compiled-types/tabs/AudioTab.d.ts

@@ -0,0 +1,6 @@
+import type { AddonPageProps } from '@camstack/ui-library';
+export declare function AudioTab({ trpc, nodeId }: {
+    trpc: AddonPageProps['trpc'];
+    nodeId: string;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AudioTab.d.ts.map

package/dist/@mf-types/compiled-types/tabs/AudioTab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioTab.d.ts","sourceRoot":"","sources":["../../../../src/tabs/AudioTab.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AA8G1D,wBAAgB,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAAE,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,2CAuiB1F"}

package/dist/@mf-types/compiled-types/tabs/DecoderTab.d.ts

@@ -0,0 +1,8 @@
+import type { AddonPageProps } from '@camstack/ui-library';
+interface TabProps {
+    trpc: AddonPageProps['trpc'];
+    nodeId: string;
+}
+export declare function DecoderTab({ trpc, nodeId }: TabProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=DecoderTab.d.ts.map

package/dist/@mf-types/compiled-types/tabs/DecoderTab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecoderTab.d.ts","sourceRoot":"","sources":["../../../../src/tabs/DecoderTab.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAiB1D,UAAU,QAAQ;IAChB,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAA;IAC5B,MAAM,EAAE,MAAM,CAAA;CACf;AAkBD,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,2CA2VpD"}

package/dist/@mf-types/compiled-types/tabs/HistoryTab.d.ts

@@ -0,0 +1,6 @@
+import type { AddonPageProps } from '@camstack/ui-library';
+export declare function HistoryTab({ trpc }: {
+    trpc: AddonPageProps['trpc'];
+    nodeId: string;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=HistoryTab.d.ts.map

package/dist/@mf-types/compiled-types/tabs/HistoryTab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HistoryTab.d.ts","sourceRoot":"","sources":["../../../../src/tabs/HistoryTab.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAkB1D,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,2CAuGpF"}

package/dist/@mf-types/compiled-types/tabs/ImageTab.d.ts

@@ -0,0 +1,6 @@
+import type { AddonPageProps } from '@camstack/ui-library';
+export declare function ImageTab({ trpc, nodeId }: {
+    trpc: AddonPageProps['trpc'];
+    nodeId: string;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ImageTab.d.ts.map

package/dist/@mf-types/compiled-types/tabs/ImageTab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageTab.d.ts","sourceRoot":"","sources":["../../../../src/tabs/ImageTab.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAwK1D,wBAAgB,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAAE,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,2CAuoB1F"}

package/dist/@mf-types/compiled-types/tabs/PipelineTab.d.ts

@@ -0,0 +1,5 @@
+import type { AddonPageProps } from '@camstack/ui-library';
+export declare function PipelineTab({ trpc }: {
+    trpc: AddonPageProps['trpc'];
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=PipelineTab.d.ts.map

package/dist/@mf-types/compiled-types/tabs/PipelineTab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PipelineTab.d.ts","sourceRoot":"","sources":["../../../../src/tabs/PipelineTab.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AA6pC1D,wBAAgB,WAAW,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAA;CAAE,2CAwXrE"}