@splitin/verification-adapter-sdk 0.1.0-beta.0

package/dist/fakes.d.cts

@@ -0,0 +1,37 @@
+import { V as VerificationAdapterV1, a as ProviderManifestV1, b as ProviderRuntimeContext, j as ProviderAttemptCommand, k as ProviderAttemptResult, D as ProviderResourceCommand, r as ProviderLaunchEnvelope, c as NormalizedProviderSnapshot, H as ProviderRetryCommand, u as ProviderOperationResult, x as ProviderRedactionCommand, y as ProviderRedactionResult, a7 as VerifiedWebhookEnvelope, N as NormalizedProviderEvent } from './contracts-5VqcOmjU.cjs';
+
+type FakeScenario = 'success' | 'input_required' | 'processing' | 'verified' | 'decline' | 'failure' | 'manual_review' | 'timeout' | 'rate_limit' | 'malformed_response' | 'unknown_state' | 'cancellation' | 'resume' | 'asynchronous_redaction' | 'retryable_provider_failure';
+declare const fakeProviderManifest: ProviderManifestV1;
+declare class FakeVerificationAdapter implements VerificationAdapterV1<Record<string, never>> {
+    readonly contractVersion: "1.0.0";
+    readonly manifest: ProviderManifestV1;
+    readonly provider = "test_fake";
+    readonly environment: "sandbox";
+    readonly runtime: ProviderRuntimeContext<Record<string, never>>;
+    private readonly scenario;
+    private readonly resources;
+    constructor(scenario?: FakeScenario, runtime?: ProviderRuntimeContext<Record<string, never>>);
+    validateConfiguration(): void;
+    createAttempt(command: ProviderAttemptCommand): Promise<ProviderAttemptResult>;
+    resumeAttempt(command: ProviderResourceCommand): Promise<ProviderLaunchEnvelope>;
+    retrieveAttempt(command: ProviderResourceCommand): Promise<NormalizedProviderSnapshot>;
+    retryAttempt(command: ProviderRetryCommand): Promise<ProviderAttemptResult>;
+    cancelAttempt(_command: ProviderResourceCommand): Promise<ProviderOperationResult>;
+    redactSubject(_command: ProviderRedactionCommand): Promise<ProviderRedactionResult>;
+    verifyWebhook(): Promise<VerifiedWebhookEnvelope>;
+    normalizeWebhook(_input: VerifiedWebhookEnvelope): Promise<NormalizedProviderEvent>;
+    private throwIfErrorScenario;
+    private launch;
+}
+declare function createFakeAdapterForScenario(scenario: FakeScenario): FakeVerificationAdapter;
+/** Intentionally incomplete adapter used to assert diagnostic quality. */
+declare class IncompleteVerificationAdapter {
+    readonly provider = "incomplete_fixture";
+    readonly environment = "sandbox";
+    readonly contractVersion: "1.0.0";
+    readonly manifest: ProviderManifestV1;
+    readonly runtime: ProviderRuntimeContext<{}>;
+    validateConfiguration(): void;
+}
+
+export { type FakeScenario, FakeVerificationAdapter, IncompleteVerificationAdapter, createFakeAdapterForScenario, fakeProviderManifest };

package/dist/fakes.d.ts

@@ -0,0 +1,37 @@
+import { V as VerificationAdapterV1, a as ProviderManifestV1, b as ProviderRuntimeContext, j as ProviderAttemptCommand, k as ProviderAttemptResult, D as ProviderResourceCommand, r as ProviderLaunchEnvelope, c as NormalizedProviderSnapshot, H as ProviderRetryCommand, u as ProviderOperationResult, x as ProviderRedactionCommand, y as ProviderRedactionResult, a7 as VerifiedWebhookEnvelope, N as NormalizedProviderEvent } from './contracts-5VqcOmjU.js';
+
+type FakeScenario = 'success' | 'input_required' | 'processing' | 'verified' | 'decline' | 'failure' | 'manual_review' | 'timeout' | 'rate_limit' | 'malformed_response' | 'unknown_state' | 'cancellation' | 'resume' | 'asynchronous_redaction' | 'retryable_provider_failure';
+declare const fakeProviderManifest: ProviderManifestV1;
+declare class FakeVerificationAdapter implements VerificationAdapterV1<Record<string, never>> {
+    readonly contractVersion: "1.0.0";
+    readonly manifest: ProviderManifestV1;
+    readonly provider = "test_fake";
+    readonly environment: "sandbox";
+    readonly runtime: ProviderRuntimeContext<Record<string, never>>;
+    private readonly scenario;
+    private readonly resources;
+    constructor(scenario?: FakeScenario, runtime?: ProviderRuntimeContext<Record<string, never>>);
+    validateConfiguration(): void;
+    createAttempt(command: ProviderAttemptCommand): Promise<ProviderAttemptResult>;
+    resumeAttempt(command: ProviderResourceCommand): Promise<ProviderLaunchEnvelope>;
+    retrieveAttempt(command: ProviderResourceCommand): Promise<NormalizedProviderSnapshot>;
+    retryAttempt(command: ProviderRetryCommand): Promise<ProviderAttemptResult>;
+    cancelAttempt(_command: ProviderResourceCommand): Promise<ProviderOperationResult>;
+    redactSubject(_command: ProviderRedactionCommand): Promise<ProviderRedactionResult>;
+    verifyWebhook(): Promise<VerifiedWebhookEnvelope>;
+    normalizeWebhook(_input: VerifiedWebhookEnvelope): Promise<NormalizedProviderEvent>;
+    private throwIfErrorScenario;
+    private launch;
+}
+declare function createFakeAdapterForScenario(scenario: FakeScenario): FakeVerificationAdapter;
+/** Intentionally incomplete adapter used to assert diagnostic quality. */
+declare class IncompleteVerificationAdapter {
+    readonly provider = "incomplete_fixture";
+    readonly environment = "sandbox";
+    readonly contractVersion: "1.0.0";
+    readonly manifest: ProviderManifestV1;
+    readonly runtime: ProviderRuntimeContext<{}>;
+    validateConfiguration(): void;
+}
+
+export { type FakeScenario, FakeVerificationAdapter, IncompleteVerificationAdapter, createFakeAdapterForScenario, fakeProviderManifest };

package/dist/fakes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakes.d.ts","sources":["fakes.d.ts"],"names":[],"mappings":"AAAA"}

package/dist/fakes.js

@@ -0,0 +1,538 @@
+import { Ajv2020 } from 'ajv/dist/2020.js';
+
+// src/errors.ts
+var ProviderError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.code = code;
+    this.name = "ProviderError";
+    this.retryable = options.retryable ?? false;
+    this.safeCode = options.safeCode ?? code.toLowerCase();
+    this.retryAfterSeconds = options.retryAfterSeconds;
+  }
+  code;
+  retryable;
+  safeCode;
+  retryAfterSeconds;
+};
+
+// src/identifiers.ts
+var VERIFICATION_ADAPTER_CONTRACT_VERSION = "1.0.0";
+var ENGINE_CONTRACT_VERSION = "1.0.0";
+var PROVIDER_MANIFEST_SCHEMA_URN = "urn:splitin:verification:provider-manifest:v1";
+var STANDARD_PACKAGE_CODES = [
+  "human_idv",
+  "business_kyb",
+  "associated_person_idv",
+  "ownership_review"
+];
+var CANONICAL_STATUSES = [
+  "created",
+  "pending_user_input",
+  "paused",
+  "processing",
+  "manual_review_required",
+  "verified",
+  "declined",
+  "failed",
+  "expired",
+  "canceled",
+  "provider_unavailable",
+  "redacted"
+];
+var TERMINAL_STATUSES = [
+  "verified",
+  "declined",
+  "failed",
+  "expired",
+  "canceled",
+  "redacted"
+];
+var STANDARD_PACKAGE_SET = new Set(STANDARD_PACKAGE_CODES);
+new Set(CANONICAL_STATUSES);
+new Set(TERMINAL_STATUSES);
+var PROVIDER_CODE = /^[a-z][a-z0-9_]{1,63}$/;
+var LAUNCHER_KEY = /^[a-z][a-z0-9_]{1,63}$/;
+var CUSTOM_PACKAGE = /^[a-z0-9][a-z0-9-]{0,32}(?:\.[a-z0-9][a-z0-9_-]{0,63}){1,6}$/;
+var WEBHOOK_PROTOCOL = /^(?:[a-z][a-z0-9_]{1,63}|[a-z0-9][a-z0-9-]{0,32}(?:\.[a-z0-9][a-z0-9_-]{0,63}){1,6})$/;
+var COUNTRY = /^[A-Z]{2}$/;
+var SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+function isProviderCode(value) {
+  return PROVIDER_CODE.test(value);
+}
+function isLauncherKey(value) {
+  return LAUNCHER_KEY.test(value);
+}
+function isStandardPackageCode(value) {
+  return STANDARD_PACKAGE_SET.has(value);
+}
+function isCustomPackageCode(value) {
+  return CUSTOM_PACKAGE.test(value) && !STANDARD_PACKAGE_SET.has(value);
+}
+function isPackageCode(value) {
+  return isStandardPackageCode(value) || isCustomPackageCode(value);
+}
+function isWebhookProtocol(value) {
+  return WEBHOOK_PROTOCOL.test(value);
+}
+function isCountryCode(value) {
+  return COUNTRY.test(value);
+}
+function isSemver(value) {
+  return SEMVER.test(value);
+}
+function majorsCompatible(left, right) {
+  return left.split(".")[0] === right.split(".")[0];
+}
+
+// src/schema.ts
+var providerManifestV1JsonSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: PROVIDER_MANIFEST_SCHEMA_URN,
+  title: "Verification Provider Manifest V1",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "contractVersion",
+    "adapterVersion",
+    "engineCompatibility",
+    "provider",
+    "displayName",
+    "supportedPackages",
+    "supportedCountries",
+    "environments",
+    "capabilities",
+    "launcherKeys",
+    "launchPresentations",
+    "configurationSchemaVersion",
+    "configurationSchema",
+    "webhook",
+    "dataPolicy",
+    "retry",
+    "cancellation",
+    "redaction",
+    "apiHosts",
+    "testedApiVersions"
+  ],
+  properties: {
+    contractVersion: { const: "1.0.0" },
+    adapterVersion: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?$" },
+    engineCompatibility: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?$" },
+    provider: { type: "string", pattern: "^[a-z][a-z0-9_]{1,63}$" },
+    displayName: { type: "string", minLength: 1 },
+    description: { type: "string" },
+    supportedPackages: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true,
+      items: {
+        type: "string",
+        anyOf: [
+          { enum: ["human_idv", "business_kyb", "associated_person_idv", "ownership_review"] },
+          { pattern: "^[a-z0-9][a-z0-9-]{0,32}(?:\\.[a-z0-9][a-z0-9_-]{0,63}){1,6}$" }
+        ]
+      }
+    },
+    supportedCountries: { type: "array", minItems: 1, uniqueItems: true, items: { type: "string", pattern: "^[A-Z]{2}$" } },
+    environments: { type: "array", minItems: 1, uniqueItems: true, items: { enum: ["sandbox", "production"] } },
+    capabilities: {
+      type: "object",
+      additionalProperties: false,
+      required: ["presentations", "canResume", "canRetry", "canCancel", "canRedact"],
+      properties: {
+        presentations: { type: "array", minItems: 1, uniqueItems: true, items: { enum: ["embedded", "hosted", "qr", "none"] } },
+        canResume: { type: "boolean" },
+        canRetry: { type: "boolean" },
+        canCancel: { type: "boolean" },
+        canRedact: { type: "boolean" }
+      }
+    },
+    launcherKeys: { type: "array", minItems: 1, uniqueItems: true, items: { type: "string", pattern: "^[a-z][a-z0-9_]{1,63}$" } },
+    launchPresentations: { type: "array", minItems: 1, uniqueItems: true, items: { enum: ["embedded", "hosted", "qr", "none"] } },
+    configurationSchemaVersion: { type: "string", minLength: 1 },
+    configurationSchema: { $ref: "#/$defs/jsonSchema2020" },
+    webhook: {
+      type: "object",
+      additionalProperties: false,
+      required: ["protocol", "eventFamilies"],
+      properties: {
+        protocol: { type: "string", minLength: 1, maxLength: 128 },
+        eventFamilies: { type: "array", uniqueItems: true, items: { type: "string", minLength: 1 } },
+        toleranceSeconds: { type: "integer", minimum: 1 }
+      }
+    },
+    dataPolicy: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "classifications",
+        "prohibitedPersistence",
+        "rawPayloadPersistence",
+        "browserSecretPersistence",
+        "governmentIdentifierPersistence"
+      ],
+      properties: {
+        classifications: { type: "array", uniqueItems: true, items: { type: "string", minLength: 1 } },
+        prohibitedPersistence: { type: "array", uniqueItems: true, items: { type: "string", minLength: 1 } },
+        rawPayloadPersistence: { const: false },
+        browserSecretPersistence: { const: false },
+        governmentIdentifierPersistence: { const: false }
+      }
+    },
+    retry: {
+      type: "object",
+      additionalProperties: false,
+      required: ["sameResourceWhenResumable", "newAttemptAfterTerminal"],
+      properties: {
+        sameResourceWhenResumable: { type: "boolean" },
+        newAttemptAfterTerminal: { type: "boolean" }
+      }
+    },
+    cancellation: {
+      type: "object",
+      additionalProperties: false,
+      required: ["supported", "terminal"],
+      properties: { supported: { type: "boolean" }, terminal: { type: "boolean" } }
+    },
+    redaction: {
+      type: "object",
+      additionalProperties: false,
+      required: ["supported", "asynchronous"],
+      properties: {
+        supported: { type: "boolean" },
+        asynchronous: { type: "boolean" },
+        notApplicable: { type: "boolean" }
+      }
+    },
+    apiHosts: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true,
+      items: { type: "string", pattern: "^[a-z0-9.-]+$" }
+    },
+    testedApiVersions: { type: "array", minItems: 1, uniqueItems: true, items: { type: "string", minLength: 1 } }
+  },
+  $defs: {
+    jsonSchema2020: {
+      type: "object",
+      required: ["$schema", "type", "additionalProperties", "required", "properties"],
+      properties: {
+        $schema: { const: "https://json-schema.org/draft/2020-12/schema" },
+        type: { const: "object" },
+        additionalProperties: { const: false },
+        required: { type: "array", uniqueItems: true, items: { type: "string", minLength: 1 } },
+        properties: { type: "object" }
+      }
+    }
+  }
+};
+var emptyConfigurationSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  additionalProperties: false,
+  required: [],
+  properties: {}
+};
+
+// src/manifest.ts
+var manifestValidator = new Ajv2020({ allErrors: true, strict: false }).compile(providerManifestV1JsonSchema);
+function defineProviderManifest(input) {
+  assertProviderManifest(input);
+  return deepFreeze(JSON.parse(JSON.stringify(input)));
+}
+function assertProviderManifest(manifest) {
+  if (!manifestValidator(manifest)) {
+    const first = manifestValidator.errors?.[0];
+    invalid(
+      `json_schema_${toSafeCode(first?.keyword ?? "invalid")}`,
+      `The provider adapter manifest does not satisfy ProviderManifestV1 JSON Schema at ${first?.instancePath || "/"}.`
+    );
+  }
+  if (manifest.contractVersion !== VERIFICATION_ADAPTER_CONTRACT_VERSION) invalid("contract_version");
+  if (!isProviderCode(manifest.provider)) invalid("provider_code");
+  if (!manifest.displayName.trim() || !isSemver(manifest.adapterVersion) || !isSemver(manifest.engineCompatibility)) {
+    invalid("identity");
+  }
+  if (!majorsCompatible(manifest.adapterVersion, VERIFICATION_ADAPTER_CONTRACT_VERSION)) {
+    invalid("adapter_version_incompatible", "Provider adapter major version must be compatible with contract V1.");
+  }
+  if (!majorsCompatible(manifest.engineCompatibility, ENGINE_CONTRACT_VERSION)) {
+    invalid("engine_incompatible", "Provider adapter is not compatible with this engine major version.");
+  }
+  if (!manifest.supportedPackages.length || manifest.supportedPackages.some((value) => !isPackageCode(value))) {
+    invalid("supported_packages");
+  }
+  if (manifest.supportedPackages.some((value) => !isStandardPackageCode(value) && !isCustomPackageCode(value))) {
+    invalid("supported_packages");
+  }
+  if (!manifest.supportedCountries.length || manifest.supportedCountries.some((value) => !isCountryCode(value))) {
+    invalid("supported_countries");
+  }
+  if (!manifest.launcherKeys.length || manifest.launcherKeys.some((value) => !isLauncherKey(value))) {
+    invalid("launcher_keys");
+  }
+  if (!isWebhookProtocol(manifest.webhook.protocol)) invalid("webhook_protocol");
+  if (!manifest.apiHosts.length || manifest.apiHosts.some((host) => host.includes("/") || host.includes(":"))) {
+    invalid("api_hosts", "Provider API hosts must be code-owned hostnames, not URLs or caller-supplied origins.");
+  }
+  if (manifest.dataPolicy.rawPayloadPersistence !== false || manifest.dataPolicy.browserSecretPersistence !== false || manifest.dataPolicy.governmentIdentifierPersistence !== false) {
+    invalid("data_policy");
+  }
+  if (manifest.capabilities.canCancel !== manifest.cancellation.supported) invalid("cancellation_capability");
+  if (manifest.capabilities.canRedact !== manifest.redaction.supported) invalid("redaction_capability");
+  assertConfigurationSecrets(manifest);
+}
+function assertConfigurationSecrets(manifest) {
+  const properties = manifest.configurationSchema.properties ?? {};
+  for (const [name, schema] of Object.entries(properties)) {
+    if (schema["x-secret"] === true && schema.type !== "string") {
+      invalid("secret_schema", `Configuration field "${name}" marked x-secret must be a string.`);
+    }
+  }
+}
+function createAllowlistedHttp(allowedHosts, fetchImpl, timeoutMs = 1e4) {
+  const hosts = new Set(allowedHosts.map((host) => host.toLowerCase()));
+  return {
+    async fetch(input, init) {
+      const url = new URL(typeof input === "string" || input instanceof URL ? String(input) : input.url);
+      if (url.protocol !== "https:" && url.hostname !== "127.0.0.1" && url.hostname !== "localhost") {
+        throw new ProviderError("INVALID_CONFIGURATION", "Provider HTTP is limited to HTTPS or loopback.", {
+          safeCode: "http_origin_denied"
+        });
+      }
+      if (!hosts.has(url.hostname.toLowerCase())) {
+        throw new ProviderError("INVALID_CONFIGURATION", "Provider HTTP origin is not allowlisted in the adapter manifest.", {
+          safeCode: "http_origin_denied"
+        });
+      }
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const parentSignal = init?.signal;
+        if (parentSignal) {
+          if (parentSignal.aborted) controller.abort();
+          else parentSignal.addEventListener("abort", () => controller.abort(), { once: true });
+        }
+        return await fetchImpl(input, { ...init, signal: controller.signal });
+      } catch (error) {
+        if (controller.signal.aborted) {
+          throw new ProviderError("TIMEOUT", "The provider HTTP request timed out.", { retryable: true, safeCode: "timeout" });
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+  };
+}
+function createDefaultRuntime(environment, configuration, options = {}) {
+  const fetchImpl = options.http?.fetch ?? fetch;
+  return {
+    environment,
+    configuration: Object.freeze({ ...configuration }),
+    http: options.http ?? createAllowlistedHttp(options.allowedHosts ?? ["127.0.0.1"], fetchImpl),
+    now: options.now ?? (() => /* @__PURE__ */ new Date()),
+    crypto: options.crypto ?? globalThis.crypto,
+    idempotency: options.idempotency ?? {
+      keyFor: (operation, attemptId, suppliedKey) => suppliedKey ?? `${operation}:${attemptId}`
+    },
+    logger: options.logger ?? silentLogger,
+    telemetry: options.telemetry,
+    recordHealth: options.recordHealth ?? (async () => void 0),
+    rateBudget: options.rateBudget
+  };
+}
+var silentLogger = Object.freeze({
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+});
+function invalid(safeCode, message = "The provider adapter manifest is invalid.") {
+  throw new ProviderError("INVALID_CONFIGURATION", message, { safeCode });
+}
+function toSafeCode(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function deepFreeze(value) {
+  if (value && typeof value === "object") {
+    Object.freeze(value);
+    for (const nested of Object.values(value)) deepFreeze(nested);
+  }
+  return value;
+}
+
+// src/fakes.ts
+var fakeProviderManifest = defineProviderManifest({
+  contractVersion: VERIFICATION_ADAPTER_CONTRACT_VERSION,
+  adapterVersion: "1.0.0",
+  engineCompatibility: "1.0.0",
+  provider: "test_fake",
+  displayName: "Conformance Fake Provider",
+  supportedPackages: ["human_idv", "com.example.employee_check"],
+  supportedCountries: ["US"],
+  environments: ["sandbox"],
+  capabilities: { presentations: ["embedded", "hosted"], canResume: true, canRetry: true, canCancel: true, canRedact: true },
+  launcherKeys: ["test_embedded", "hosted"],
+  launchPresentations: ["embedded", "hosted"],
+  configurationSchemaVersion: "urn:splitin:verification:config:test-fake:v1",
+  configurationSchema: emptyConfigurationSchema,
+  webhook: { protocol: "none", eventFamilies: ["test"] },
+  dataPolicy: {
+    classifications: ["normalized_status"],
+    prohibitedPersistence: ["raw_webhook", "launch_secret", "document", "selfie"],
+    rawPayloadPersistence: false,
+    browserSecretPersistence: false,
+    governmentIdentifierPersistence: false
+  },
+  retry: { sameResourceWhenResumable: true, newAttemptAfterTerminal: true },
+  cancellation: { supported: true, terminal: true },
+  redaction: { supported: true, asynchronous: true },
+  apiHosts: ["127.0.0.1"],
+  testedApiVersions: ["fake-1"]
+});
+var SCENARIO_STATUS = {
+  success: "verified",
+  verified: "verified",
+  input_required: "pending_user_input",
+  processing: "processing",
+  decline: "declined",
+  failure: "failed",
+  manual_review: "manual_review_required",
+  timeout: "processing",
+  rate_limit: "processing",
+  malformed_response: "processing",
+  unknown_state: "processing",
+  cancellation: "canceled",
+  resume: "pending_user_input",
+  asynchronous_redaction: "processing",
+  retryable_provider_failure: "processing"
+};
+var FakeVerificationAdapter = class {
+  contractVersion = VERIFICATION_ADAPTER_CONTRACT_VERSION;
+  manifest = fakeProviderManifest;
+  provider = "test_fake";
+  environment = "sandbox";
+  runtime;
+  scenario;
+  resources = /* @__PURE__ */ new Map();
+  constructor(scenario = "input_required", runtime) {
+    this.scenario = scenario;
+    this.runtime = runtime ?? createDefaultRuntime("sandbox", {}, { allowedHosts: ["127.0.0.1"] });
+  }
+  validateConfiguration() {
+    if (this.runtime.environment !== "sandbox") {
+      throw new ProviderError("INVALID_CONFIGURATION", "The fake provider is sandbox-only.");
+    }
+  }
+  async createAttempt(command) {
+    this.runtime.idempotency.keyFor("create", command.attemptId, command.idempotencyKey);
+    const existing = this.resources.get(command.idempotencyKey);
+    const providerResourceId = existing ?? `tfr_${command.attemptId.replace(/[^a-zA-Z0-9]/g, "")}`;
+    this.resources.set(command.idempotencyKey, providerResourceId);
+    const canonicalStatus = this.scenario === "success" || this.scenario === "verified" ? "verified" : "pending_user_input";
+    return {
+      attemptId: command.attemptId,
+      providerResourceId,
+      providerStatus: canonicalStatus,
+      canonicalStatus,
+      launch: this.launch(command.attemptId, canonicalStatus)
+    };
+  }
+  async resumeAttempt(command) {
+    return this.launch(command.attemptId, "pending_user_input");
+  }
+  async retrieveAttempt(command) {
+    this.throwIfErrorScenario();
+    return {
+      providerResourceId: command.providerResourceId,
+      providerStatus: SCENARIO_STATUS[this.scenario],
+      canonicalStatus: SCENARIO_STATUS[this.scenario],
+      occurredAt: this.runtime.now().toISOString(),
+      normalizedReasonCodes: [],
+      safeMetadata: { source: "fake", scenario: this.scenario }
+    };
+  }
+  async retryAttempt(command) {
+    return this.createAttempt({ ...command, attemptId: `${command.attemptId}_retry` });
+  }
+  async cancelAttempt(_command) {
+    return { accepted: true, providerStatus: "canceled", canonicalStatus: "canceled" };
+  }
+  async redactSubject(_command) {
+    if (this.scenario === "asynchronous_redaction") {
+      return { completed: false, retryable: true, disposition: "processing" };
+    }
+    return { completed: true, retryable: false, disposition: "redacted" };
+  }
+  async verifyWebhook() {
+    throw new ProviderError("UNSUPPORTED_CAPABILITY", "The fake provider does not receive webhooks.", {
+      safeCode: "webhooks_not_supported"
+    });
+  }
+  async normalizeWebhook(_input) {
+    throw new ProviderError("UNSUPPORTED_CAPABILITY", "The fake provider does not receive webhooks.", {
+      safeCode: "webhooks_not_supported"
+    });
+  }
+  throwIfErrorScenario() {
+    if (this.scenario === "timeout") {
+      throw new ProviderError("TIMEOUT", "The fake provider timed out.", { retryable: true, safeCode: "timeout" });
+    }
+    if (this.scenario === "rate_limit") {
+      throw new ProviderError("RATE_LIMITED", "The fake provider is rate limited.", {
+        retryable: true,
+        safeCode: "rate_limited",
+        retryAfterSeconds: 30
+      });
+    }
+    if (this.scenario === "retryable_provider_failure") {
+      throw new ProviderError("RETRYABLE_PROVIDER_FAILURE", "The fake provider failed retryably.", {
+        retryable: true,
+        safeCode: "retryable_provider_failure"
+      });
+    }
+    if (this.scenario === "malformed_response") {
+      throw new ProviderError("RETRYABLE_PROVIDER_FAILURE", "The fake provider returned a malformed body.", {
+        retryable: true,
+        safeCode: "malformed_provider_response"
+      });
+    }
+    if (this.scenario === "unknown_state") {
+      throw new ProviderError("UNKNOWN_PROVIDER_STATE", "The fake provider returned an unknown state.", {
+        retryable: false,
+        safeCode: "unknown_provider_status"
+      });
+    }
+  }
+  launch(attemptId, canonicalStatus) {
+    return {
+      attemptId,
+      canonicalStatus,
+      launcherKey: "test_embedded",
+      presentation: "embedded",
+      providerDisclosure: "Test provider",
+      transientSecret: `test_launch_${attemptId.replace(/-/g, "")}`,
+      transientSecretExpiresAt: new Date(this.runtime.now().getTime() + 5 * 6e4).toISOString(),
+      continuationReference: `cont_${attemptId}`
+    };
+  }
+};
+function createFakeAdapterForScenario(scenario) {
+  return new FakeVerificationAdapter(scenario);
+}
+var IncompleteVerificationAdapter = class {
+  provider = "incomplete_fixture";
+  environment = "sandbox";
+  contractVersion = VERIFICATION_ADAPTER_CONTRACT_VERSION;
+  manifest = fakeProviderManifest;
+  runtime = createDefaultRuntime("sandbox", {}, { allowedHosts: ["127.0.0.1"] });
+  validateConfiguration() {
+    throw new ProviderError("INVALID_CONFIGURATION", "Incomplete adapter is missing createAttempt, resumeAttempt, retrieveAttempt, retryAttempt, cancelAttempt, redactSubject, verifyWebhook, and normalizeWebhook.", {
+      safeCode: "missing_method_create_attempt"
+    });
+  }
+};
+
+export { FakeVerificationAdapter, IncompleteVerificationAdapter, createFakeAdapterForScenario, fakeProviderManifest };
+//# sourceMappingURL=fakes.js.map
+//# sourceMappingURL=fakes.js.map