@smileid/usesmileid_vision_face 12.0.0-beta01

package/plugin/src/lib/podfile.ts

@@ -0,0 +1,209 @@
+// Injects an idempotent Ruby block into the Expo-generated Podfile's
+// `post_install` hook. The block runs at `pod install` time and wires
+// the Smile ID Swift Package into the autogenerated Pods.xcodeproj
+// for a specific bridge pod target — Pods.xcodeproj only exists at
+// pod-install time, so this is the only hook that can mutate it.
+
+import type { SpmPackage, SpmRequirement } from "./spm";
+
+const BEGIN_PREFIX = "# === BEGIN smileid-spm:";
+const END_PREFIX = "# === END smileid-spm:";
+
+export interface PodfileLinkOptions {
+  /** Marker key — distinct per bridge so each plugin owns its own block. */
+  marker: string;
+  package: SpmPackage;
+  /** Pod target name (e.g. `UseSmileIDVisionFaceExpo`). */
+  podTarget: string;
+  /** SPM library product names to link to the pod target. */
+  products: string[];
+}
+
+/**
+ * Idempotently injects an SPM-linking Ruby block into the Podfile's
+ * top-level `post_install` block. Re-running on an already-injected
+ * Podfile rewrites the same marker block in place (so version /
+ * product changes flow through cleanly on the next prebuild).
+ */
+export function injectPodfileSpmBlock(
+  podfile: string,
+  options: PodfileLinkOptions,
+): string {
+  validateRubySafe(options);
+
+  const block = renderBlock(options);
+  const beginMarker = `${BEGIN_PREFIX} ${options.marker} ===`;
+  const endMarker = `${END_PREFIX} ${options.marker} ===`;
+
+  const blockRegex = new RegExp(
+    `${escapeRegExp(beginMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}`,
+    "m",
+  );
+  if (blockRegex.test(podfile)) {
+    return podfile.replace(blockRegex, block);
+  }
+
+  // Inject at the *start* of the post_install body — right after
+  // `post_install do |installer|`. We tried matching the closing
+  // `end` pair instead, but a second plugin running on a Podfile
+  // already mutated by the first sees a non-flat body and the
+  // non-greedy `end…end` match latches onto inner block ends,
+  // nesting the second injection inside the first. Anchoring on
+  // the opening line removes that failure mode entirely. Order
+  // relative to `react_native_post_install` doesn't matter because
+  // CocoaPods persists the Pods project at the end of pod install
+  // regardless of what we explicitly save mid-block.
+  const headerRegex = /(post_install\s+do\s*\|\s*installer\s*\|)\r?\n/;
+  const headerMatch = podfile.match(headerRegex);
+  if (!headerMatch || headerMatch.index === undefined) {
+    throw new Error(
+      "[smileid-spm] Could not locate `post_install do |installer|` in Podfile. " +
+        "Refusing to append a top-level post_install hook because CocoaPods only honors one — adding a second " +
+        "would silently override the React Native post-install plumbing. Restore the Expo Podfile template " +
+        "or wire the SPM block in manually.",
+    );
+  }
+  const insertAt = headerMatch.index + headerMatch[0].length;
+  const indented =
+    block
+      .split("\n")
+      .map((line) => (line.length > 0 ? `    ${line}` : line))
+      .join("\n") + "\n";
+  return podfile.slice(0, insertAt) + indented + podfile.slice(insertAt);
+}
+
+// All injected strings flow into single-quoted Ruby literals. We
+// reject characters that could break out of those literals so a
+// typo in the bridge plugin can't produce code that runs during
+// `pod install`. Rejected: single-quote, backslash, control chars.
+function validateRubySafe(options: PodfileLinkOptions): void {
+  const fields: Array<[string, string]> = [
+    ["marker", options.marker],
+    ["package.url", options.package.url],
+    ["podTarget", options.podTarget],
+  ];
+  for (const product of options.products) {
+    fields.push(["products[*]", product]);
+  }
+  switch (options.package.requirement.kind) {
+    case "upToNextMajorVersion":
+    case "upToNextMinorVersion":
+      fields.push([
+        "requirement.minimumVersion",
+        options.package.requirement.minimumVersion,
+      ]);
+      break;
+    case "exactVersion":
+      fields.push(["requirement.version", options.package.requirement.version]);
+      break;
+    case "branch":
+      fields.push(["requirement.branch", options.package.requirement.branch]);
+      break;
+  }
+  for (const [name, value] of fields) {
+    if (/['\\\n\r\t]/.test(value)) {
+      throw new Error(
+        `[smileid-spm] Refusing to inject Podfile block: '${name}' contains an unsafe character (got: ${JSON.stringify(value)}).`,
+      );
+    }
+  }
+}
+
+function renderBlock(options: PodfileLinkOptions): string {
+  const beginMarker = `${BEGIN_PREFIX} ${options.marker} ===`;
+  const endMarker = `${END_PREFIX} ${options.marker} ===`;
+  const requirement = renderRequirement(options.package.requirement);
+  const productList = options.products.map((p) => `'${p}'`).join(", ");
+
+  return `${beginMarker}
+# Wires ${options.package.url} into Pods.xcodeproj and links its
+# products to the '${options.podTarget}' pod target so the Swift
+# bridge code can \`import\` them. Idempotent across pod installs.
+#
+# UUIDs are minted via SecureRandom rather than \`pods_project.new\`
+# because \`prepare_react_native_project!\` sets
+# \`:deterministic_uuids => false\`. With that flag off, CocoaPods
+# skips its predictabilize step and \`stabilize_target_uuids\` resets
+# \`@generated_uuids\` to a tiny leftover pool — so any post_install
+# call to \`pods_project.new\` restarts the sequential index near 0
+# and re-mints UUIDs already in use. The collision then runs through
+# \`add_referrer\`, which clobbers \`objects_by_uuid[uuid]\` and
+# leaves the rootObject (\`46EB2E00000000\`) unreachable, crashing
+# Xcode 26 with \`XCSwiftPackageProductDependency
+# _setSavedArchiveVersion:\` unrecognized selector. Random 24-char
+# hex IDs can't collide with the 14-char cocoapods scheme.
+begin
+  pods_project = installer.pods_project
+  spm_url = '${options.package.url}'
+  spm_requirement = ${requirement}
+  product_names = [${productList}]
+  target_name = '${options.podTarget}'
+
+  smileid_spm_safe_uuid = lambda do |project|
+    loop do
+      candidate = SecureRandom.hex(12).upcase
+      return candidate unless project.objects_by_uuid.key?(candidate)
+    end
+  end
+
+  pkg = pods_project.root_object.package_references.find do |r|
+    r.respond_to?(:repositoryURL) && r.repositoryURL == spm_url
+  end
+  unless pkg
+    pkg_uuid = smileid_spm_safe_uuid.call(pods_project)
+    pkg = Xcodeproj::Project::Object::XCRemoteSwiftPackageReference.new(pods_project, pkg_uuid)
+    pkg.initialize_defaults
+    pkg.repositoryURL = spm_url
+    pkg.requirement = spm_requirement
+    pods_project.root_object.package_references << pkg
+  end
+
+  target = pods_project.targets.find { |t| t.name == target_name }
+  if target.nil?
+    Pod::UI.warn "[smileid-spm] Pod target #{target_name} not found; skipping SPM link."
+  else
+    product_names.each do |product_name|
+      already = target.package_product_dependencies.any? do |d|
+        d.package == pkg && d.product_name == product_name
+      end
+      next if already
+
+      dep_uuid = smileid_spm_safe_uuid.call(pods_project)
+      dep = Xcodeproj::Project::Object::XCSwiftPackageProductDependency.new(pods_project, dep_uuid)
+      dep.initialize_defaults
+      dep.package = pkg
+      dep.product_name = product_name
+      target.package_product_dependencies << dep
+
+      bf_uuid = smileid_spm_safe_uuid.call(pods_project)
+      bf = Xcodeproj::Project::Object::PBXBuildFile.new(pods_project, bf_uuid)
+      bf.initialize_defaults
+      bf.product_ref = dep
+      target.frameworks_build_phase.files << bf
+    end
+  end
+
+  pods_project.save
+rescue => e
+  Pod::UI.warn "[smileid-spm] Failed to link SPM products for ${options.podTarget}: #{e.message}"
+  raise
+end
+${endMarker}`;
+}
+
+function renderRequirement(req: SpmRequirement): string {
+  switch (req.kind) {
+    case "upToNextMajorVersion":
+      return `{ kind: 'upToNextMajorVersion', minimumVersion: '${req.minimumVersion}' }`;
+    case "upToNextMinorVersion":
+      return `{ kind: 'upToNextMinorVersion', minimumVersion: '${req.minimumVersion}' }`;
+    case "exactVersion":
+      return `{ kind: 'exactVersion', version: '${req.version}' }`;
+    case "branch":
+      return `{ kind: 'branch', branch: '${req.branch}' }`;
+  }
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/plugin/src/lib/spm.ts

@@ -0,0 +1,314 @@
+// Shared plumbing for wiring a remote Swift Package into both the
+// consuming Expo app's Xcode project and the autogenerated CocoaPods
+// project for a specific bridge pod target.
+//
+// Why this exists: `expo-modules-autolinking@55.0.x`'s
+// `RawModuleConfigApple` schema does not surface a `dependencies`
+// field, so listing SPM products in `expo-module.config.json` is a
+// silent no-op. This module fills that gap.
+
+import { XcodeProject } from "@expo/config-plugins";
+
+export interface SpmPackage {
+  /** Remote git URL of the Swift Package, e.g. `https://github.com/smileidentity/ios-spm`. */
+  url: string;
+  /** Version requirement; mirrors Xcode's package resolution UI. */
+  requirement: SpmRequirement;
+}
+
+export type SpmRequirement =
+  | { kind: "upToNextMajorVersion"; minimumVersion: string }
+  | { kind: "upToNextMinorVersion"; minimumVersion: string }
+  | { kind: "exactVersion"; version: string }
+  | { kind: "branch"; branch: string };
+
+export interface SpmTargetLink {
+  /** Native target name in the project (app target or pod target). */
+  targetName: string;
+  /** SPM library product names to attach to the target. */
+  products: string[];
+}
+
+/**
+ * Adds (or reuses) a remote Swift Package reference on the given
+ * Xcode project and links the requested products to the target.
+ * Idempotent: existing package refs and product deps are reused so
+ * multiple plugins can compose without conflict.
+ */
+export function linkSpmPackage(
+  project: XcodeProject,
+  pkg: SpmPackage,
+  link: SpmTargetLink,
+): void {
+  const pkgRef = upsertPackageReference(project, pkg);
+  const target = findNativeTarget(project, link.targetName);
+  if (!target) {
+    throw new Error(
+      `[smileid-spm] Native target '${link.targetName}' not found in Xcode project.`,
+    );
+  }
+  for (const product of link.products) {
+    upsertProductDependency(project, target.uuid, pkgRef, product);
+  }
+}
+
+// Internals — pbxproj surgery. xcode.js doesn't expose SPM helpers,
+// so we manipulate the underlying object graph directly.
+
+interface PackageRef {
+  uuid: string;
+}
+
+interface NativeTarget {
+  uuid: string;
+  obj: PbxNativeTarget;
+}
+
+interface PbxNativeTarget {
+  isa: "PBXNativeTarget";
+  name: string;
+  packageProductDependencies?: Array<{ value: string; comment?: string }>;
+  buildPhases: Array<{ value: string; comment?: string }>;
+}
+
+interface PbxProject {
+  isa: "PBXProject";
+  packageReferences?: Array<{ value: string; comment?: string }>;
+}
+
+function objects(project: XcodeProject): Record<string, unknown> {
+  const hash = (
+    project as unknown as {
+      hash: { project: { objects: Record<string, unknown> } };
+    }
+  ).hash.project.objects;
+  return hash;
+}
+
+function section<T>(project: XcodeProject, isa: string): Record<string, T> {
+  const objs = objects(project);
+  if (!objs[isa]) {
+    objs[isa] = {};
+  }
+  return objs[isa] as Record<string, T>;
+}
+
+function generateUuid(project: XcodeProject): string {
+  return (project as unknown as { generateUuid: () => string }).generateUuid();
+}
+
+function upsertPackageReference(
+  project: XcodeProject,
+  pkg: SpmPackage,
+): PackageRef {
+  const refs = section<{
+    isa: string;
+    repositoryURL?: string;
+    requirement?: object;
+  }>(project, "XCRemoteSwiftPackageReference");
+
+  for (const [uuid, ref] of Object.entries(refs)) {
+    if (uuid.endsWith("_comment")) continue;
+    if (typeof ref !== "object" || ref === null) continue;
+    if (ref.repositoryURL?.replace(/^"|"$/g, "") === pkg.url) {
+      return { uuid };
+    }
+  }
+
+  const uuid = generateUuid(project);
+  refs[uuid] = {
+    isa: "XCRemoteSwiftPackageReference",
+    repositoryURL: `"${pkg.url}"`,
+    requirement: serializeRequirement(pkg.requirement),
+  };
+  refs[`${uuid}_comment`] =
+    `XCRemoteSwiftPackageReference "${repoName(pkg.url)}"` as never;
+
+  // Attach to the PBXProject's packageReferences list.
+  const projectSection = section<PbxProject>(project, "PBXProject");
+  for (const [projUuid, proj] of Object.entries(projectSection)) {
+    if (projUuid.endsWith("_comment")) continue;
+    if (typeof proj !== "object" || proj === null) continue;
+    if (proj.isa !== "PBXProject") continue;
+    proj.packageReferences ??= [];
+    if (!proj.packageReferences.some((r) => r.value === uuid)) {
+      proj.packageReferences.push({
+        value: uuid,
+        comment: `XCRemoteSwiftPackageReference "${repoName(pkg.url)}"`,
+      });
+    }
+  }
+
+  return { uuid };
+}
+
+function upsertProductDependency(
+  project: XcodeProject,
+  targetUuid: string,
+  pkgRef: PackageRef,
+  productName: string,
+): void {
+  const targetSection = section<PbxNativeTarget>(project, "PBXNativeTarget");
+  const target = targetSection[targetUuid];
+  if (!target || typeof target !== "object") {
+    throw new Error(
+      `[smileid-spm] Target ${targetUuid} disappeared between lookups.`,
+    );
+  }
+
+  const productDeps = section<{
+    isa: string;
+    package?: string;
+    productName?: string;
+  }>(project, "XCSwiftPackageProductDependency");
+
+  // Each target owns its own XCSwiftPackageProductDependency entry —
+  // sharing one across targets is not how Xcode writes pbxproj and
+  // would cause downstream tools (and re-runs of this plugin) to
+  // silently drop the second target's binding. Look up the dep
+  // *within this target's* packageProductDependencies, never globally.
+  target.packageProductDependencies ??= [];
+  let depUuid = target.packageProductDependencies.find((d) => {
+    const entry = productDeps[d.value];
+    return (
+      entry !== undefined &&
+      typeof entry === "object" &&
+      entry !== null &&
+      entry.package === pkgRef.uuid &&
+      entry.productName === productName
+    );
+  })?.value;
+
+  if (!depUuid) {
+    depUuid = generateUuid(project);
+    productDeps[depUuid] = {
+      isa: "XCSwiftPackageProductDependency",
+      package: pkgRef.uuid,
+      productName,
+    };
+    productDeps[`${depUuid}_comment`] = productName as never;
+    target.packageProductDependencies.push({
+      value: depUuid,
+      comment: productName,
+    });
+  }
+
+  ensureFrameworkLink(project, target, depUuid, productName);
+}
+
+function ensureFrameworkLink(
+  project: XcodeProject,
+  target: PbxNativeTarget,
+  productDepUuid: string,
+  productName: string,
+): void {
+  const frameworksPhase = findFrameworksBuildPhase(project, target);
+  if (!frameworksPhase) {
+    throw new Error(
+      `[smileid-spm] Target '${target.name}' has no PBXFrameworksBuildPhase; cannot link ${productName}.`,
+    );
+  }
+
+  const buildFiles = section<{ isa: string; productRef?: string }>(
+    project,
+    "PBXBuildFile",
+  );
+
+  // Scope the existence check to *this target's* frameworks phase.
+  // A globally-scoped check would early-return when a sibling target
+  // already linked the same product, leaving this target unlinked.
+  frameworksPhase.obj.files ??= [];
+  for (const fileRef of frameworksPhase.obj.files) {
+    const bf = buildFiles[fileRef.value];
+    if (
+      bf !== undefined &&
+      typeof bf === "object" &&
+      bf !== null &&
+      bf.productRef === productDepUuid
+    ) {
+      return;
+    }
+  }
+
+  const buildFileUuid = generateUuid(project);
+  buildFiles[buildFileUuid] = {
+    isa: "PBXBuildFile",
+    productRef: productDepUuid,
+  };
+  buildFiles[`${buildFileUuid}_comment`] =
+    `${productName} in Frameworks` as never;
+
+  frameworksPhase.obj.files.push({
+    value: buildFileUuid,
+    comment: `${productName} in Frameworks`,
+  });
+}
+
+interface FrameworksPhase {
+  uuid: string;
+  obj: {
+    isa: "PBXFrameworksBuildPhase";
+    files?: Array<{ value: string; comment?: string }>;
+  };
+}
+
+function findFrameworksBuildPhase(
+  project: XcodeProject,
+  target: PbxNativeTarget,
+): FrameworksPhase | undefined {
+  const phaseSection = section<{
+    isa: string;
+    files?: Array<{ value: string; comment?: string }>;
+  }>(project, "PBXFrameworksBuildPhase");
+  for (const phaseRef of target.buildPhases) {
+    const phase = phaseSection[phaseRef.value];
+    if (
+      phase &&
+      typeof phase === "object" &&
+      phase.isa === "PBXFrameworksBuildPhase"
+    ) {
+      return { uuid: phaseRef.value, obj: phase as FrameworksPhase["obj"] };
+    }
+  }
+  return undefined;
+}
+
+function findNativeTarget(
+  project: XcodeProject,
+  name: string,
+): NativeTarget | undefined {
+  const targets = section<PbxNativeTarget>(project, "PBXNativeTarget");
+  for (const [uuid, t] of Object.entries(targets)) {
+    if (uuid.endsWith("_comment")) continue;
+    if (typeof t !== "object" || t === null) continue;
+    if (t.isa !== "PBXNativeTarget") continue;
+    if (t.name === name || t.name === `"${name}"`) {
+      return { uuid, obj: t };
+    }
+  }
+  return undefined;
+}
+
+function serializeRequirement(req: SpmRequirement): object {
+  switch (req.kind) {
+    case "upToNextMajorVersion":
+      return {
+        kind: "upToNextMajorVersion",
+        minimumVersion: req.minimumVersion,
+      };
+    case "upToNextMinorVersion":
+      return {
+        kind: "upToNextMinorVersion",
+        minimumVersion: req.minimumVersion,
+      };
+    case "exactVersion":
+      return { kind: "exactVersion", version: req.version };
+    case "branch":
+      return { kind: "branch", branch: req.branch };
+  }
+}
+
+function repoName(url: string): string {
+  const match = url.replace(/\.git$/, "").match(/\/([^/]+)$/);
+  return match?.[1] ?? url;
+}

package/plugin/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./build",
+    "rootDir": "./src",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "ignoreDeprecations": "6.0",
+    "target": "ES2021",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "declaration": true,
+    "declarationMap": false,
+    "sourceMap": true,
+    "composite": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["build", "node_modules"]
+}

package/src/__tests__/use_smile_id_vision_face.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it, vi, beforeEach, type Mock } from "vitest";
+
+const native = vi.hoisted(() => ({
+  configure: vi.fn(),
+  reset: vi.fn(),
+  close: vi.fn(),
+}));
+
+vi.mock("expo-modules-core", () => ({
+  requireNativeModule: vi.fn(() => native),
+}));
+
+import { requireNativeModule } from "expo-modules-core";
+import {
+  useSmileIDVisionFace,
+  UseSmileIDVisionFaceIdentifiers,
+} from "../index";
+
+describe("useSmileIDVisionFace — TS wrapper", () => {
+  beforeEach(() => {
+    Object.values(native).forEach((m) => (m as Mock).mockReset());
+  });
+
+  it("looks up the native module under the contract-stable name", () => {
+    expect(requireNativeModule).toHaveBeenCalledWith("UseSmileIDVisionFace");
+  });
+
+  it("exposes the lifecycle surface — no per-frame analyze method", () => {
+    expect(typeof useSmileIDVisionFace.configure).toBe("function");
+    expect(typeof useSmileIDVisionFace.reset).toBe("function");
+    expect(typeof useSmileIDVisionFace.close).toBe("function");
+    // Per-frame analysis lives in the native VisionCamera frame
+    // processor plugin — raw pixels never cross the JS bridge.
+    expect("analyze" in useSmileIDVisionFace).toBe(false);
+  });
+
+  it("exposes the kind discriminator and frame processor plugin name", () => {
+    expect(useSmileIDVisionFace.kind).toBe("face");
+    expect(useSmileIDVisionFace.frameProcessorPluginName).toBe(
+      UseSmileIDVisionFaceIdentifiers.frameProcessorPluginName,
+    );
+  });
+
+  describe("configure", () => {
+    it("passes the validated config through to native", async () => {
+      native.configure.mockResolvedValueOnce(undefined);
+      await useSmileIDVisionFace.configure({ selfieCaptureTimeout: 60_000 });
+      expect(native.configure).toHaveBeenCalledTimes(1);
+      expect(native.configure).toHaveBeenCalledWith({
+        selfieCaptureTimeout: 60_000,
+      });
+    });
+
+    it("rejects malformed config at the JS boundary", async () => {
+      await expect(
+        useSmileIDVisionFace.configure({
+          // @ts-expect-error — int field with float value
+          selfieCaptureTimeout: 60_000.5,
+        }),
+      ).rejects.toThrow();
+      expect(native.configure).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("reset / close", () => {
+    it("routes reset through to native", async () => {
+      native.reset.mockResolvedValueOnce(undefined);
+      await useSmileIDVisionFace.reset();
+      expect(native.reset).toHaveBeenCalledTimes(1);
+    });
+
+    it("routes close through to native and is idempotent", async () => {
+      native.close.mockResolvedValue(undefined);
+      await useSmileIDVisionFace.close();
+      await useSmileIDVisionFace.close();
+      expect(native.close).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,41 @@
+import { AnalyzerFactoryKey } from "@smileid/usesmileid_bridge";
+import type { FaceConfig, FaceScanResult } from "@smileid/usesmileid_bridge";
+import { useSmileIDAnalyzerExecutor } from "@smileid/usesmileid_platform_interface";
+
+/**
+ * Apple Vision face analyzer (iOS-only).
+ *
+ * Thin shim around the existing native session
+ * `UseSmileID.UseSmileIDFaceSession(FaceDetectorAnalyzer())` shipped in
+ * the `UseSmileIDVisionFace` Swift Package. The native side runs the
+ * entire pipeline (analyzer + validator + transitioner + state
+ * machine); this TS layer routes calls and validates wire payloads at
+ * the channel boundary.
+ *
+ * The canonical wiring lives in [useSmileIDAnalyzerExecutor] in
+ * `usesmileid_platform_interface`.
+ *
+ * Lifecycle: `configure()` → per-frame analysis via the native frame
+ * processor plugin → `reset()`? → `close()`. See
+ * `usesmileid_platform_interface` `FaceAnalyzer` for the canonical
+ * contract.
+ */
+/**
+ * Must match the Swift Expo Module's `Name("UseSmileIDVisionFace")` and its
+ * VisionCamera frame-processor-plugin registration — drift is a runtime
+ * "module/plugin not found" error, not a compile error.
+ */
+export const UseSmileIDVisionFaceIdentifiers = {
+  nativeModuleName: "UseSmileIDVisionFace",
+  frameProcessorPluginName: "UseSmileIDVisionFaceFrameProcessor",
+} as const;
+
+export const useSmileIDVisionFace = useSmileIDAnalyzerExecutor({
+  nativeModuleName: UseSmileIDVisionFaceIdentifiers.nativeModuleName,
+  frameProcessorPluginName:
+    UseSmileIDVisionFaceIdentifiers.frameProcessorPluginName,
+  kind: "face",
+  key: AnalyzerFactoryKey.VisionFace,
+});
+
+export type { FaceConfig, FaceScanResult };