@a4anthony/proctorkit-vue 0.1.4 → 0.2.0

package/dist/browser-face-detector.d.ts

@@ -0,0 +1,59 @@
+/**
+ * In-browser face detector for preflight checks.
+ *
+ * The camera check, the candidate-intake headshot and the resume check
+ * only ask one question: is exactly one face in front of the camera?
+ * This answers it on the candidate's device with BlazeFace (short range)
+ * through MediaPipe Tasks Vision, so no frame is sent anywhere to be
+ * detected. The frame the camera check stores as evidence is still
+ * uploaded, with the browser's face count, by
+ * `createNestPreflightCameraCheck`.
+ *
+ * The runtime (WebAssembly) and model load once per asset location and
+ * are shared by every check on the page. `prefetchBrowserFaceDetector`
+ * starts that download early (the wizard calls it when it opens) so the
+ * first check does not wait. Loading is lazy: hosts that never run a
+ * camera check never download anything.
+ */
+/** The `@mediapipe/tasks-vision` version the API serves assets for. */
+export declare const VISION_ASSETS_VERSION = "1.0.1";
+/** Where the vision runtime and face model are served from. */
+export interface VisionAssets {
+    /** Directory holding the Tasks Vision WebAssembly files. */
+    wasmBasePath?: string;
+    /** URL of the BlazeFace short-range model. */
+    faceModelPath?: string;
+}
+interface FaceDetectorLike {
+    detect(image: HTMLImageElement): {
+        detections: readonly unknown[];
+    };
+}
+/** Injectable seams, for tests. */
+export interface BrowserFaceDetectorDeps {
+    loadDetector(assets: Required<VisionAssets>): Promise<FaceDetectorLike>;
+    decodeImage(dataUrl: string): Promise<HTMLImageElement>;
+}
+/** The versioned asset location the ProctorKit API serves. */
+export declare const visionAssetsFromApiBase: (apiBaseUrl: string) => Required<VisionAssets>;
+/** Forget loaded detectors (tests). */
+export declare function resetBrowserFaceDetectorCache(): void;
+/**
+ * Start downloading the runtime and model in the background. Never
+ * throws: a failure here only means the first check loads (or fails)
+ * on its own.
+ */
+export declare function prefetchBrowserFaceDetector(assets?: VisionAssets, deps?: BrowserFaceDetectorDeps): Promise<void>;
+/**
+ * A `detectFace` callback for the SDK's deep camera check, the intake
+ * headshot and the resume check. Resolves `{ faceCount }`; throws when
+ * the detector cannot load or run, which the SDK treats as a failed
+ * attempt and retries.
+ */
+export declare function createBrowserDetectFace(options?: {
+    assets?: VisionAssets;
+}, deps?: BrowserFaceDetectorDeps): (jpegDataUrl: string) => Promise<{
+    faceCount: number;
+}>;
+export {};
+//# sourceMappingURL=browser-face-detector.d.ts.map

package/dist/browser-face-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-face-detector.d.ts","sourceRoot":"","sources":["../src/browser-face-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,uEAAuE;AACvE,eAAO,MAAM,qBAAqB,UAAU,CAAC;AAI7C,+DAA+D;AAC/D,MAAM,WAAW,YAAY;IAC3B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,gBAAgB;IACxB,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG;QAAE,UAAU,EAAE,SAAS,OAAO,EAAE,CAAA;KAAE,CAAC;CACrE;AAED,mCAAmC;AACnC,MAAM,WAAW,uBAAuB;IACtC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACxE,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACzD;AAID,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB,GAAI,YAAY,MAAM,KAAG,QAAQ,CAAC,YAAY,CAGjF,CAAC;AA8CF,uCAAuC;AACvC,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD;AAED;;;;GAIG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,CAAC,EAAE,YAAY,EACrB,IAAI,GAAE,uBAAqC,GAC1C,OAAO,CAAC,IAAI,CAAC,CAMf;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,EACvC,IAAI,GAAE,uBAAqC,GAC1C,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAczD"}

package/dist/check-cards/system/DisplayPermissionDialog.vue.d.ts

@@ -0,0 +1,24 @@
+import type { DisplayRecoveryMessages, PlatformUiMessages } from "@a4anthony/proctorkit-content";
+type __VLS_Props = {
+    open: boolean;
+    pending: boolean;
+    automatic: boolean;
+    feedback: "denied" | "unavailable" | null;
+    actionLabel: string;
+    loadingLabel: string;
+    dark: boolean;
+    messages: DisplayRecoveryMessages;
+    permissionMessages?: PlatformUiMessages["permissionDenied"];
+    helpLabel?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: () => any;
+    close: () => any;
+    help: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRetry?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onHelp?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=DisplayPermissionDialog.vue.d.ts.map

package/dist/check-cards/system/DisplayPermissionDialog.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DisplayPermissionDialog.vue.d.ts","sourceRoot":"","sources":["../../../src/check-cards/system/DisplayPermissionDialog.vue"],"names":[],"mappings":"AAoJA,OAAO,KAAK,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAKjG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,QAAQ,GAAG,aAAa,GAAG,IAAI,CAAC;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,uBAAuB,CAAC;IAClC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,kBAAkB,CAAC,CAAC;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;;;;;;;;;;AAyZF,wBAOG"}

package/dist/check-cards/system/DisplayRecovery.vue.d.ts

@@ -0,0 +1,25 @@
+import { type DisplayMonitor } from "@a4anthony/proctorkit-sdk";
+import type { DisplayRecoveryMessages, PlatformUiMessages } from "@a4anthony/proctorkit-content";
+import type { MediaHelpTopicId } from "../../i18n/media-help.js";
+type __VLS_Props = {
+    messages: DisplayRecoveryMessages;
+    permissionMessages?: PlatformUiMessages["permissionDenied"];
+    helpLabel?: string;
+    retryLabel?: string;
+    retryVisible?: boolean;
+    checking: boolean;
+    passed: boolean;
+    /** @internal Injectable browser adapter for stories and component tests. */
+    monitor?: DisplayMonitor;
+    /** @internal Avoid duplicate automatic probes when the preflight owner watches. */
+    displayChangesManaged?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    recheck: () => any;
+    help: (topic: MediaHelpTopicId) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRecheck?: (() => any) | undefined;
+    onHelp?: ((topic: MediaHelpTopicId) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=DisplayRecovery.vue.d.ts.map

package/dist/check-cards/system/DisplayRecovery.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DisplayRecovery.vue.d.ts","sourceRoot":"","sources":["../../../src/check-cards/system/DisplayRecovery.vue"],"names":[],"mappings":"AAqVA,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAKjG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,uBAAuB,CAAC;IAClC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,kBAAkB,CAAC,CAAC;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;;;;;;;;AA+iBF,wBAOG"}

package/dist/check-cards/system/SystemCheckCard.vue.d.ts

@@ -17,10 +17,15 @@ type __VLS_Props = {
     helpLabel?: string;
     indicatorOnly?: boolean;
     statusLabels?: PlatformUiMessages["status"];
+    showDivider?: boolean;
     headerId?: string;
     panelId?: string;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    'display-recovery'?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     retry: () => any;
     help: (topic: MediaHelpTopicId) => any;
     copyLink: (issueId: string) => any;
@@ -37,6 +42,7 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     expanded: boolean;
     headerId: string;
     panelId: string;
+    showDivider: boolean;
     issues: CheckCardIssue[];
     retryLabel: string;
     retrying: boolean;
@@ -46,5 +52,11 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     copiedLabel: string;
     indicatorOnly: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
 //# sourceMappingURL=SystemCheckCard.vue.d.ts.map

package/dist/check-cards/system/SystemCheckCard.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SystemCheckCard.vue.d.ts","sourceRoot":"","sources":["../../../src/check-cards/system/SystemCheckCard.vue"],"names":[],"mappings":"AAyKA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAoB,KAAK,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAE1F,KAAK,WAAW,GAAG;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;;;;;;;;;;WAjBQ,MAAM;iBAGA,MAAM;eASR,MAAM;gBAVL,MAAM;kBAYJ,kBAAkB,CAAC,QAAQ,CAAC;cAVhC,OAAO;cAWP,MAAM;aACP,MAAM;YAXP,cAAc,EAAE;gBACZ,MAAM;cACR,OAAO;kBACH,OAAO;mBACN,MAAM;mBACN,MAAM,GAAG,IAAI;iBACf,MAAM;mBAEJ,OAAO;;AA2U3B,wBAQG"}
+{"version":3,"file":"SystemCheckCard.vue.d.ts","sourceRoot":"","sources":["../../../src/check-cards/system/SystemCheckCard.vue"],"names":[],"mappings":"AA6KA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAoB,KAAK,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAE1F,KAAK,WAAW,GAAG;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AA6SJ,QAAA,IAAI,OAAO,IAAW,CAAE;AACxB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,CAAC;AAiC1D,QAAA,MAAM,eAAe;;;;;;;;;WAlWT,MAAM;iBAGA,MAAM;eASR,MAAM;gBAVL,MAAM;kBAYJ,kBAAkB,CAAC,QAAQ,CAAC;cAVhC,OAAO;cAYP,MAAM;aACP,MAAM;iBAFF,OAAO;YAVZ,cAAc,EAAE;gBACZ,MAAM;cACR,OAAO;kBACH,OAAO;mBACN,MAAM;mBACN,MAAM,GAAG,IAAI;iBACf,MAAM;mBAEJ,OAAO;6EA6VzB,CAAC;wBACkB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;AAAzE,wBAA0E;AAa1E,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/check-cards/system/display-progress-story.d.ts

@@ -0,0 +1,468 @@
+import type { DisplayMonitor } from "@a4anthony/proctorkit-sdk";
+/** Real checklist panels and progress controller with simulated equipment. */
+export declare function createDisplayProgressRender(identityCompleted?: boolean): () => {
+    components: {
+        ChecklistShell: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                title: string;
+                description: string;
+                activeIndex: number;
+                activeKey: string;
+                steps: import("../../wizard/wizard-steps.js").WizardStep[];
+                completedSteps?: import("../../wizard/wizard-steps.js").WizardStep[];
+                labels: Partial<Record<import("../../wizard/wizard-steps.js").WizardStep, string>>;
+                deviceLabels?: Partial<Record<"microphone" | "speaker" | "camera", string | null>>;
+                progressLabel?: string;
+                equipmentTitle?: string;
+                equipmentDescription?: string;
+                statusComplete?: string;
+                statusWaiting?: string;
+                statusLabels?: import("@a4anthony/proctorkit-content").PlatformUiMessages["status"];
+                systemCheckFailed?: boolean;
+                dark?: boolean;
+            }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                dark: boolean;
+                progressLabel: string;
+                statusLabels: import("@a4anthony/proctorkit-content").PlatformUiMessages["status"];
+                deviceLabels: Partial<Record<"microphone" | "speaker" | "camera", string | null>>;
+                equipmentTitle: string;
+                equipmentDescription: string;
+                statusComplete: string;
+                statusWaiting: string;
+                systemCheckFailed: boolean;
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                title: string;
+                description: string;
+                activeIndex: number;
+                activeKey: string;
+                steps: import("../../wizard/wizard-steps.js").WizardStep[];
+                completedSteps?: import("../../wizard/wizard-steps.js").WizardStep[];
+                labels: Partial<Record<import("../../wizard/wizard-steps.js").WizardStep, string>>;
+                deviceLabels?: Partial<Record<"microphone" | "speaker" | "camera", string | null>>;
+                progressLabel?: string;
+                equipmentTitle?: string;
+                equipmentDescription?: string;
+                statusComplete?: string;
+                statusWaiting?: string;
+                statusLabels?: import("@a4anthony/proctorkit-content").PlatformUiMessages["status"];
+                systemCheckFailed?: boolean;
+                dark?: boolean;
+            }> & Readonly<{}>, {}, {}, {}, {}, {
+                dark: boolean;
+                progressLabel: string;
+                statusLabels: import("@a4anthony/proctorkit-content").PlatformUiMessages["status"];
+                deviceLabels: Partial<Record<"microphone" | "speaker" | "camera", string | null>>;
+                equipmentTitle: string;
+                equipmentDescription: string;
+                statusComplete: string;
+                statusWaiting: string;
+                systemCheckFailed: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{
+            title: string;
+            description: string;
+            activeIndex: number;
+            activeKey: string;
+            steps: import("../../wizard/wizard-steps.js").WizardStep[];
+            completedSteps?: import("../../wizard/wizard-steps.js").WizardStep[];
+            labels: Partial<Record<import("../../wizard/wizard-steps.js").WizardStep, string>>;
+            deviceLabels?: Partial<Record<"microphone" | "speaker" | "camera", string | null>>;
+            progressLabel?: string;
+            equipmentTitle?: string;
+            equipmentDescription?: string;
+            statusComplete?: string;
+            statusWaiting?: string;
+            statusLabels?: import("@a4anthony/proctorkit-content").PlatformUiMessages["status"];
+            systemCheckFailed?: boolean;
+            dark?: boolean;
+        }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            dark: boolean;
+            progressLabel: string;
+            statusLabels: import("@a4anthony/proctorkit-content").PlatformUiMessages["status"];
+            deviceLabels: Partial<Record<"microphone" | "speaker" | "camera", string | null>>;
+            equipmentTitle: string;
+            equipmentDescription: string;
+            statusComplete: string;
+            statusWaiting: string;
+            systemCheckFailed: boolean;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                "microphone-completed"?: ((props: {
+                    step: "microphone" | "speaker" | "camera" | "candidate-intake" | "runtime-screen-share";
+                }) => any) | undefined;
+                "speaker-completed"?: ((props: {
+                    step: "microphone" | "speaker" | "camera" | "candidate-intake" | "runtime-screen-share";
+                }) => any) | undefined;
+                "camera-completed"?: ((props: {
+                    step: "microphone" | "speaker" | "camera" | "candidate-intake" | "runtime-screen-share";
+                }) => any) | undefined;
+                "candidate-intake-completed"?: ((props: {
+                    step: "microphone" | "speaker" | "camera" | "candidate-intake" | "runtime-screen-share";
+                }) => any) | undefined;
+                "runtime-screen-share-completed"?: ((props: {
+                    step: "microphone" | "speaker" | "camera" | "candidate-intake" | "runtime-screen-share";
+                }) => any) | undefined;
+            } & {
+                'top-left'?: (props: {}) => any;
+            } & {
+                'top-right'?: (props: {}) => any;
+            } & {
+                'system-card'?: (props: {
+                    active: boolean;
+                    complete: boolean;
+                    showDivider: boolean;
+                }) => any;
+            } & {
+                default?: (props: {}) => any;
+            } & {
+                default?: (props: {}) => any;
+            } & {
+                default?: (props: {}) => any;
+            };
+        });
+        SystemStep: import("vue").DefineComponent<{
+            rows: ReadonlyArray<import("@a4anthony/proctorkit-sdk").CheckRow>;
+            messages: import("@a4anthony/proctorkit-content").PreflightMessages;
+            autoStart: boolean;
+            minBandwidthMbps?: number;
+            minUploadBandwidthMbps?: number;
+            run: () => Promise<void>;
+            retry: () => Promise<void>;
+            recheckMonitor?: () => Promise<void>;
+            displayMonitor?: DisplayMonitor;
+            displayChangesManaged?: boolean;
+            embedded?: boolean;
+            showDivider?: boolean;
+            autoContinueOnPass?: boolean;
+        }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            help: (topic: import("@a4anthony/proctorkit-content").MediaHelpTopicId) => any;
+            continue: () => any;
+        }, string, import("vue").PublicProps, Readonly<{
+            rows: ReadonlyArray<import("@a4anthony/proctorkit-sdk").CheckRow>;
+            messages: import("@a4anthony/proctorkit-content").PreflightMessages;
+            autoStart: boolean;
+            minBandwidthMbps?: number;
+            minUploadBandwidthMbps?: number;
+            run: () => Promise<void>;
+            retry: () => Promise<void>;
+            recheckMonitor?: () => Promise<void>;
+            displayMonitor?: DisplayMonitor;
+            displayChangesManaged?: boolean;
+            embedded?: boolean;
+            showDivider?: boolean;
+            autoContinueOnPass?: boolean;
+        }> & Readonly<{
+            onHelp?: ((topic: import("@a4anthony/proctorkit-content").MediaHelpTopicId) => any) | undefined;
+            onContinue?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+        CandidateIntakeStep: import("vue").DefineComponent<{
+            config: import("../../candidate-intake.js").CandidateIntakeConfig;
+            draft?: import("../../wizard/candidate-intake-draft.js").CandidateIntakeDraft;
+            submitting?: boolean;
+            submitError?: string | null;
+            detectFace?: (jpegDataUrl: string) => Promise<{
+                faceCount: number;
+            }>;
+            headshotSimulationError?: string;
+            embedded?: boolean;
+            messages?: import("@a4anthony/proctorkit-content").PlatformUiMessages["candidateIntake"];
+        }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            submit: (submission: import("../../candidate-intake.js").CandidateIntakeSubmission) => any;
+        }, string, import("vue").PublicProps, Readonly<{
+            config: import("../../candidate-intake.js").CandidateIntakeConfig;
+            draft?: import("../../wizard/candidate-intake-draft.js").CandidateIntakeDraft;
+            submitting?: boolean;
+            submitError?: string | null;
+            detectFace?: (jpegDataUrl: string) => Promise<{
+                faceCount: number;
+            }>;
+            headshotSimulationError?: string;
+            embedded?: boolean;
+            messages?: import("@a4anthony/proctorkit-content").PlatformUiMessages["candidateIntake"];
+        }> & Readonly<{
+            onSubmit?: ((submission: import("../../candidate-intake.js").CandidateIntakeSubmission) => any) | undefined;
+        }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+        FinalStep: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                rows: ReadonlyArray<import("@a4anthony/proctorkit-sdk").CheckRow>;
+                messages: import("@a4anthony/proctorkit-content").PreflightMessages;
+                mode: import("@a4anthony/proctorkit-sdk").SystemCheckMode;
+                autoResumeSeconds: number;
+                starting?: boolean;
+                preparationError?: import("../../proctored-assessment/preparation-feedback.js").PreparationFeedback;
+                embedded?: boolean;
+            }> & Readonly<{
+                onResume?: (() => any) | undefined;
+                onHelp?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                resume: () => any;
+                help: () => any;
+            }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                rows: ReadonlyArray<import("@a4anthony/proctorkit-sdk").CheckRow>;
+                messages: import("@a4anthony/proctorkit-content").PreflightMessages;
+                mode: import("@a4anthony/proctorkit-sdk").SystemCheckMode;
+                autoResumeSeconds: number;
+                starting?: boolean;
+                preparationError?: import("../../proctored-assessment/preparation-feedback.js").PreparationFeedback;
+                embedded?: boolean;
+            }> & Readonly<{
+                onResume?: (() => any) | undefined;
+                onHelp?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{
+            rows: ReadonlyArray<import("@a4anthony/proctorkit-sdk").CheckRow>;
+            messages: import("@a4anthony/proctorkit-content").PreflightMessages;
+            mode: import("@a4anthony/proctorkit-sdk").SystemCheckMode;
+            autoResumeSeconds: number;
+            starting?: boolean;
+            preparationError?: import("../../proctored-assessment/preparation-feedback.js").PreparationFeedback;
+            embedded?: boolean;
+        }> & Readonly<{
+            onResume?: (() => any) | undefined;
+            onHelp?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            resume: () => any;
+            help: () => any;
+        }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                'footer-extras'?: (props: {}) => any;
+            };
+        });
+        ProctoringButton: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                variant?: "primary" | "link" | "secondary" | "brand" | "ghost" | "outline" | "danger-link" | "danger" | "success";
+                size?: "xs" | "sm" | "compact" | "dense" | "control" | "md" | "lg" | "inline" | "icon-xs" | "icon-sm" | "icon";
+                type?: "reset" | "submit" | "button";
+                disabled?: boolean;
+                loading?: boolean;
+                fullWidth?: boolean;
+                icon?: import("vue").Component;
+                iconPosition?: "prepend" | "append";
+                unstyled?: boolean;
+            }> & Readonly<{}>, {
+                focus: (options?: FocusOptions) => void | undefined;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                size: "xs" | "sm" | "compact" | "dense" | "control" | "md" | "lg" | "inline" | "icon-xs" | "icon-sm" | "icon";
+                variant: "primary" | "link" | "secondary" | "brand" | "ghost" | "outline" | "danger-link" | "danger" | "success";
+                type: "reset" | "submit" | "button";
+                disabled: boolean;
+                loading: boolean;
+                fullWidth: boolean;
+                iconPosition: "prepend" | "append";
+                unstyled: boolean;
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                variant?: "primary" | "link" | "secondary" | "brand" | "ghost" | "outline" | "danger-link" | "danger" | "success";
+                size?: "xs" | "sm" | "compact" | "dense" | "control" | "md" | "lg" | "inline" | "icon-xs" | "icon-sm" | "icon";
+                type?: "reset" | "submit" | "button";
+                disabled?: boolean;
+                loading?: boolean;
+                fullWidth?: boolean;
+                icon?: import("vue").Component;
+                iconPosition?: "prepend" | "append";
+                unstyled?: boolean;
+            }> & Readonly<{}>, {
+                focus: (options?: FocusOptions) => void | undefined;
+            }, {}, {}, {}, {
+                size: "xs" | "sm" | "compact" | "dense" | "control" | "md" | "lg" | "inline" | "icon-xs" | "icon-sm" | "icon";
+                variant: "primary" | "link" | "secondary" | "brand" | "ghost" | "outline" | "danger-link" | "danger" | "success";
+                type: "reset" | "submit" | "button";
+                disabled: boolean;
+                loading: boolean;
+                fullWidth: boolean;
+                iconPosition: "prepend" | "append";
+                unstyled: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{
+            variant?: "primary" | "link" | "secondary" | "brand" | "ghost" | "outline" | "danger-link" | "danger" | "success";
+            size?: "xs" | "sm" | "compact" | "dense" | "control" | "md" | "lg" | "inline" | "icon-xs" | "icon-sm" | "icon";
+            type?: "reset" | "submit" | "button";
+            disabled?: boolean;
+            loading?: boolean;
+            fullWidth?: boolean;
+            icon?: import("vue").Component;
+            iconPosition?: "prepend" | "append";
+            unstyled?: boolean;
+        }> & Readonly<{}>, {
+            focus: (options?: FocusOptions) => void | undefined;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            size: "xs" | "sm" | "compact" | "dense" | "control" | "md" | "lg" | "inline" | "icon-xs" | "icon-sm" | "icon";
+            variant: "primary" | "link" | "secondary" | "brand" | "ghost" | "outline" | "danger-link" | "danger" | "success";
+            type: "reset" | "submit" | "button";
+            disabled: boolean;
+            loading: boolean;
+            fullWidth: boolean;
+            iconPosition: "prepend" | "append";
+            unstyled: boolean;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                leading?: (props: {}) => any;
+            } & {
+                default?: (props: {}) => any;
+            } & {
+                trailing?: (props: {}) => any;
+            };
+        });
+    };
+    setup(): {
+        messages: import("vue").ComputedRef<import("@a4anthony/proctorkit-content").PreflightMessages>;
+        draft: import("vue").ShallowReactive<import("../../wizard/candidate-intake-draft.js").CandidateIntakeDraft>;
+        submitting: import("vue").Ref<boolean, boolean>;
+        submissionCount: import("vue").Ref<number, number>;
+        extraDisplay: import("vue").Ref<boolean, boolean>;
+        started: import("vue").Ref<boolean, boolean>;
+        monitor: DisplayMonitor;
+        setDisplay: (connected: boolean) => void;
+        submitIdentity: () => void;
+        recheck: () => Promise<void>;
+        config: {
+            title: string;
+            continueLabel: string;
+            nextLabel: string;
+            fields: ({
+                key: string;
+                type: string;
+                label: string;
+                required: boolean;
+                maxFiles?: undefined;
+                maxFileSizeBytes?: undefined;
+                accept?: undefined;
+            } | {
+                key: string;
+                type: string;
+                label: string;
+                required: boolean;
+                maxFiles: number;
+                maxFileSizeBytes: number;
+                accept: string[];
+            })[];
+            sections: {
+                id: string;
+                title: string;
+                fieldKeys: string[];
+            }[];
+        };
+        steps: import("vue").Ref<import("../../wizard/wizard-steps.js").WizardStep[], import("../../wizard/wizard-steps.js").WizardStep[]>;
+        activeStep: import("vue").ComputedRef<import("../../wizard/wizard-steps.js").WizardStep>;
+        activeIndex: import("vue").Ref<number, number>;
+        totalSteps: import("vue").ComputedRef<number>;
+        advance: () => void;
+        completeStep: (step: import("../../wizard/wizard-steps.js").WizardStep) => void;
+        completedSteps: import("vue").Ref<import("../../wizard/wizard-steps.js").WizardStep[], import("../../wizard/wizard-steps.js").WizardStep[]>;
+        goTo: (step: import("../../wizard/wizard-steps.js").WizardStep) => void;
+        reset: () => void;
+        verifyDisplaySetup: (trigger?: import("../../wizard/display-diagnostics.js").DisplayTrigger) => Promise<boolean>;
+        engine: import("vue").ShallowRef<import("@a4anthony/proctorkit-sdk").SystemCheck, import("@a4anthony/proctorkit-sdk").SystemCheck>;
+        rows: import("vue").Ref<{
+            kind: import("@a4anthony/proctorkit-sdk").CheckKind;
+            state: {
+                kind: "pending";
+            } | {
+                kind: "checking";
+                message?: string | undefined;
+            } | {
+                kind: "pass";
+                detail: string;
+            } | {
+                kind: "fail";
+                code: import("@a4anthony/proctorkit-sdk").FailCode;
+                detail: string;
+            } | {
+                kind: "skipped";
+            };
+            photo?: string | undefined;
+            mbps?: number | undefined;
+            uploadMbps?: number | undefined;
+            latencyMs?: number | undefined;
+            jitterMs?: number | undefined;
+            recordingUploadMode?: "direct" | "segments" | "post" | undefined;
+            readinessPayloadBytes?: number | undefined;
+            readinessMedianMs?: number | undefined;
+            readinessWindowMs?: number | undefined;
+            readinessSampleCount?: number | undefined;
+            band?: import("@a4anthony/proctorkit-sdk").ConnectionBand | undefined;
+        }[], import("@a4anthony/proctorkit-sdk").CheckRow[] | {
+            kind: import("@a4anthony/proctorkit-sdk").CheckKind;
+            state: {
+                kind: "pending";
+            } | {
+                kind: "checking";
+                message?: string | undefined;
+            } | {
+                kind: "pass";
+                detail: string;
+            } | {
+                kind: "fail";
+                code: import("@a4anthony/proctorkit-sdk").FailCode;
+                detail: string;
+            } | {
+                kind: "skipped";
+            };
+            photo?: string | undefined;
+            mbps?: number | undefined;
+            uploadMbps?: number | undefined;
+            latencyMs?: number | undefined;
+            jitterMs?: number | undefined;
+            recordingUploadMode?: "direct" | "segments" | "post" | undefined;
+            readinessPayloadBytes?: number | undefined;
+            readinessMedianMs?: number | undefined;
+            readinessWindowMs?: number | undefined;
+            readinessSampleCount?: number | undefined;
+            band?: import("@a4anthony/proctorkit-sdk").ConnectionBand | undefined;
+        }[]>;
+        isRunning: import("vue").Ref<boolean, boolean>;
+        isComplete: import("vue").Ref<boolean, boolean>;
+        allPassed: import("vue").ComputedRef<boolean>;
+        failures: import("vue").ComputedRef<{
+            kind: import("@a4anthony/proctorkit-sdk").CheckKind;
+            code: import("@a4anthony/proctorkit-sdk").FailCode;
+            detail: string;
+        }[]>;
+        report: import("vue").ShallowRef<import("@a4anthony/proctorkit-sdk").PreflightReport | null, import("@a4anthony/proctorkit-sdk").PreflightReport | null>;
+        runChecks: () => Promise<import("@a4anthony/proctorkit-sdk").PreflightReport>;
+        runSimulated: (results: import("@a4anthony/proctorkit-sdk").SimulatedCheckResult[]) => Promise<import("@a4anthony/proctorkit-sdk").PreflightReport>;
+        retry: () => Promise<import("@a4anthony/proctorkit-sdk").PreflightReport>;
+        runSystemClass: () => Promise<void>;
+        retrySystemClass: () => Promise<void>;
+        probeMonitor: () => Promise<void>;
+        probeMic: (deviceId?: string) => Promise<void>;
+        probeSpeaker: (options?: import("@a4anthony/proctorkit-sdk").SpeakerProbeOptions) => Promise<void>;
+        probeCamera: (deviceId?: string, existingStream?: {
+            videoElement: HTMLVideoElement;
+        }) => Promise<{
+            attempts: import("@a4anthony/proctorkit-sdk").DeepCameraAttempt[];
+        }>;
+        probeScreenShare: (attested?: boolean) => Promise<void>;
+    };
+    template: string;
+};
+//# sourceMappingURL=display-progress-story.d.ts.map

package/dist/check-cards/system/display-progress-story.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-progress-story.d.ts","sourceRoot":"","sources":["../../../src/check-cards/system/display-progress-story.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,2BAA2B,CAAC;AAWhF,8EAA8E;AAC9E,wBAAgB,2BAA2B,CAAC,iBAAiB,UAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA8ChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsF3C"}