@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/callback-645_omgz.d.ts

@@ -0,0 +1,133 @@
+import { S as Snapshot, a as ActorRefFromLogic, c as AnyEventObject, j as AnyActorSystem, n as ActorLogic, p as EventObject, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/declarations/src/actors/callback.d.ts
+type CallbackSnapshot<TInput> = Snapshot<undefined> & {
+  input: TInput;
+};
+type CallbackActorLogic<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ActorLogic<CallbackSnapshot<TInput>, TEvent, TInput, AnyActorSystem, TEmitted>;
+/**
+ * Represents an actor created by `fromCallback`.
+ *
+ * The type of `self` within the actor's logic.
+ *
+ * @example
+ *
+ * ```ts
+ * import { fromCallback, createActor } from 'xstate';
+ *
+ * // The events the actor receives.
+ * type Event = { type: 'someEvent' };
+ * // The actor's input.
+ * type Input = { name: string };
+ *
+ * // Actor logic that logs whenever it receives an event of type `someEvent`.
+ * const logic = fromCallback<Event, Input>(({ self, input, receive }) => {
+ *   self;
+ *   // ^? CallbackActorRef<Event, Input>
+ *
+ *   receive((event) => {
+ *     if (event.type === 'someEvent') {
+ *       console.log(`${input.name}: received "someEvent" event`);
+ *       // logs 'myActor: received "someEvent" event'
+ *     }
+ *   });
+ * });
+ *
+ * const actor = createActor(logic, { input: { name: 'myActor' } });
+ * //    ^? CallbackActorRef<Event, Input>
+ * ```
+ *
+ * @see {@link fromCallback}
+ */
+type CallbackActorRef<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorRefFromLogic<CallbackActorLogic<TEvent, TInput>>;
+type Receiver<TEvent extends EventObject> = (listener: {
+  bivarianceHack(event: TEvent): void;
+}['bivarianceHack']) => void;
+type CallbackLogicFunction<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ({ input, system, self, sendBack, receive, emit }: {
+  /**
+   * Data that was provided to the callback actor
+   *
+   * @see {@link https://stately.ai/docs/input | Input docs}
+   */
+  input: TInput;
+  /** The actor system to which the callback actor belongs */
+  system: AnyActorSystem;
+  /** The parent actor of the callback actor */
+  self: CallbackActorRef<TEvent>;
+  /** A function that can send events back to the parent actor */
+  sendBack: (event: TSentEvent) => void;
+  /**
+   * A function that can be called with a listener function argument; the
+   * listener is then called whenever events are received by the callback actor
+   */
+  receive: Receiver<TEvent>;
+  emit: (emitted: TEmitted) => void;
+}) => (() => void) | void;
+/**
+ * An actor logic creator which returns callback logic as defined by a callback
+ * function.
+ *
+ * @remarks
+ * Useful for subscription-based or other free-form logic that can send events
+ * back to the parent actor.
+ *
+ * Actors created from callback logic (“callback actors”) can:
+ *
+ * - Receive events via the `receive` function
+ * - Send events to the parent actor via the `sendBack` function
+ *
+ * Callback actors are a bit different from other actors in that they:
+ *
+ * - Do not work with `onDone`
+ * - Do not produce a snapshot using `.getSnapshot()`
+ * - Do not emit values when used with `.subscribe()`
+ * - Can not be stopped with `.stop()`
+ *
+ * @example
+ *
+ * ```typescript
+ * const callbackLogic = fromCallback(({ sendBack, receive }) => {
+ *   let lockStatus = 'unlocked';
+ *
+ *   const handler = (event) => {
+ *     if (lockStatus === 'locked') {
+ *       return;
+ *     }
+ *     sendBack(event);
+ *   };
+ *
+ *   receive((event) => {
+ *     if (event.type === 'lock') {
+ *       lockStatus = 'locked';
+ *     } else if (event.type === 'unlock') {
+ *       lockStatus = 'unlocked';
+ *     }
+ *   });
+ *
+ *   document.body.addEventListener('click', handler);
+ *
+ *   return () => {
+ *     document.body.removeEventListener('click', handler);
+ *   };
+ * });
+ * ```
+ *
+ * @param callback - The callback function used to describe the callback logic
+ *   The callback function is passed an object with the following properties:
+ *
+ *   - `receive` - A function that can send events back to the parent actor; the
+ *       listener is then called whenever events are received by the callback
+ *       actor
+ *   - `sendBack` - A function that can send events back to the parent actor
+ *   - `input` - Data that was provided to the callback actor
+ *   - `self` - The parent actor of the callback actor
+ *   - `system` - The actor system to which the callback actor belongs The callback
+ *       function can (optionally) return a cleanup function, which is called
+ *       when the actor is stopped.
+ *
+ * @returns Callback logic
+ * @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ */
+declare function fromCallback<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(callback: CallbackLogicFunction<TEvent, AnyEventObject, TInput, TEmitted>): CallbackActorLogic<TEvent, TInput, TEmitted>;
+//#endregion
+export { fromCallback as n, CallbackActorLogic as t };

package/dist/camera-_2sXMXiF.esm.js

@@ -0,0 +1,140 @@
+//#region ../infra/src/media/cameraGrantMemo.ts
+/**
+* Document-scoped record of "a `getUserMedia` call has already succeeded here".
+*
+* Deliberately a module-scoped variable and **not** `sessionStorage`.
+* ENG-43732's first fix (PR #298) cached the grant in `sessionStorage` and was
+* reverted by PR #420: `sessionStorage` survives a page reload but an iOS
+* WebView's camera grant does not, so the flag outlived the permission and the
+* SDK skipped its explainer while the native prompt still appeared. In-memory
+* state dies with the document, so a reload always re-asks the browser.
+*
+* A second consequence worth keeping: this carries no Web Storage dependency at
+* all, so nothing here can throw in hosts that delete or block the storage
+* globals.
+*
+* Written by the acquisition helpers in `./camera` and by
+* `BrowserCameraProvider`. Read by Core's `checkPermission()`, which trusts it
+* only on Android WebView — where the Permissions API structurally cannot
+* report a grant. See `isAndroidWebView` in `../capabilities/platform`.
+*/
+let cameraGrantedInDocument = false;
+/** Records that camera access was successfully acquired in this document. */
+function markCameraGrantedInDocument() {
+	cameraGrantedInDocument = true;
+}
+/**
+* Forgets any recorded grant. Called whenever the browser reports a concrete
+* `denied`, or an acquisition fails with `NotAllowedError` — so a permission
+* revoked mid-session self-heals on the next check instead of stranding the
+* user on a dead camera view.
+*/
+function clearCameraGrantedInDocument() {
+	cameraGrantedInDocument = false;
+}
+/** Whether camera access has been successfully acquired in this document. */
+function isCameraGrantedInDocument() {
+	return cameraGrantedInDocument;
+}
+/**
+* Runs a camera acquisition and records its outcome in the memo: a resolved
+* stream marks the grant, a permission denial forgets it, and every other
+* failure leaves the memo untouched — a busy, missing or over-constrained
+* device says nothing about permission. The error is always re-thrown unchanged,
+* so callers keep their existing control flow.
+*
+* Every acquisition path should go through this rather than calling `mark`
+* directly, so the "which errors count as a denial" rule lives in one place.
+*/
+async function trackCameraAcquisition(acquire) {
+	try {
+		const result = await acquire();
+		markCameraGrantedInDocument();
+		return result;
+	} catch (error) {
+		const name = error instanceof Error ? error.name : void 0;
+		if (name === "NotAllowedError" || name === "PermissionDeniedError") clearCameraGrantedInDocument();
+		throw error;
+	}
+}
+//#endregion
+//#region ../infra/src/media/camera.ts
+/**
+* Default resolution fallback order for camera access.
+* Tries each resolution in order until one succeeds.
+* Matches legacy behavior from Webcam.tsx
+*/
+const DEFAULT_RESOLUTION_FALLBACKS = [
+	{ height: 720 },
+	{
+		width: 3840,
+		height: 2160
+	},
+	{
+		width: 1920,
+		height: 1080
+	},
+	{
+		width: 640,
+		height: 480
+	},
+	{
+		width: 800,
+		height: 480
+	},
+	{}
+];
+/**
+* Request camera access with specific constraints.
+* Throws if the request fails - no automatic fallback.
+*/
+async function requestCameraAccess(constraints) {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) throw new Error("MediaDevices API not available");
+	const acquire = () => navigator.mediaDevices.getUserMedia(constraints);
+	if (!constraints.video) return acquire();
+	return trackCameraAcquisition(acquire);
+}
+/**
+* Request camera access with automatic resolution fallback.
+* Tries progressively different resolutions if the initial request fails.
+*
+* @param baseConstraints - Base constraints (facingMode, audio, etc.)
+* @param fallbacks - Optional custom fallback order (defaults to 720p -> 1080p -> 480p -> auto)
+* @returns MediaStream from the camera
+* @throws Error if all fallbacks fail or MediaDevices API not available
+*/
+async function requestCameraWithFallback(baseConstraints, fallbacks = DEFAULT_RESOLUTION_FALLBACKS) {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) throw new Error("MediaDevices API not available");
+	const baseVideo = baseConstraints.video;
+	for (let i = 0; i < fallbacks.length; i++) {
+		const resolution = fallbacks[i];
+		const videoConstraints = { ...baseVideo };
+		if (resolution.width) videoConstraints.width = { ideal: resolution.width };
+		if (resolution.height) videoConstraints.height = { ideal: resolution.height };
+		if (!resolution.width && !resolution.height) {
+			delete videoConstraints.width;
+			delete videoConstraints.height;
+		}
+		try {
+			return await trackCameraAcquisition(() => navigator.mediaDevices.getUserMedia({
+				...baseConstraints,
+				video: videoConstraints
+			}));
+		} catch (error) {
+			if (i === fallbacks.length - 1) throw error;
+		}
+	}
+	throw new Error("All camera resolution fallbacks failed");
+}
+function stopCameraStream(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+async function enumerateVideoDevices() {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) return [];
+	return (await navigator.mediaDevices.enumerateDevices()).filter((d) => d.kind === "videoinput");
+}
+async function applyTrackConstraints(track, constraints) {
+	await track.applyConstraints(constraints);
+}
+//#endregion
+export { stopCameraStream as a, requestCameraWithFallback as i, enumerateVideoDevices as n, clearCameraGrantedInDocument as o, requestCameraAccess as r, isCameraGrantedInDocument as s, applyTrackConstraints as t };

package/dist/camera.d.ts

@@ -1,5 +1,4 @@
-import { n as PermissionStatus, t as PermissionResult } from "./types-BcF-fii5.js";
-
+import { n as PermissionStatus, t as PermissionResult } from "./types-BEwVKkLJ.js";
 //#region src/internal/permissions/permissionServices.d.ts
 type RequestPermissionOptions = {
   requestMotion?: boolean;
@@ -10,6 +9,24 @@ type RequestPermissionOptions = {
    */
   requestAudio?: boolean;
 };
+/**
+ * Resolves the current camera permission without prompting the user.
+ *
+ * A concrete answer from the Permissions API always wins. The `'prompt'` case is
+ * where Android WebView needs help: it has no persistent permission store — the
+ * host app answers each `getUserMedia` through `onPermissionRequest` — so the
+ * query reports `'prompt'` however many times access was granted, and every
+ * capture module in a flow re-rendered the "allow camera" screen (ENG-43732).
+ * There we fall back to whether an acquisition has actually succeeded in this
+ * document.
+ *
+ * The Android-WebView gate is load-bearing, not defensive tidiness. iOS WebKit
+ * (PR #420) and Firefox for Android (PR #726) genuinely do re-prompt per
+ * `getUserMedia`, so treating a past grant as current would skip the SDK's
+ * explainer while the native prompt still appeared — the regressions that got
+ * two previous attempts at this fix reverted. Those platforms must keep seeing
+ * `'prompt'`.
+ */
 declare function checkPermission(): Promise<PermissionResult>;
 /**
  * Requests camera permission by attempting to access the camera, then immediately

package/dist/camera.esm.js

@@ -1,6 +1,2 @@
-import "./WasmUtilProvider-BgzcXBdl.esm.js";
-import "./MotionSensorProvider-BHuHoYvJ.esm.js";
-import { i as requestPermission, t as checkPermission } from "./permissionServices-C_kxhNeo.esm.js";
-import "./camera-CxxXV0VN.esm.js";
-
-export { checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };
+import { i as requestPermission, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
+export { checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };

package/dist/{canvas-Pi10hG_l.esm.js → canvas-E1zGkel4.esm.js}

@@ -225,6 +225,5 @@ var IncodeCanvas = class IncodeCanvas {
 		return resized;
 	}
 };
-
 //#endregion
-export { IncodeCanvas as t };
+export { IncodeCanvas as t };

package/dist/certificate-issuance.d.ts

@@ -1,8 +1,7 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import * as xstate80 from "xstate";
-
+import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
 //#region src/modules/certificate-issuance/certificateIssuanceConstants.d.ts
 declare const MIN_PASSWORD_LENGTH = 8;
 declare const PASSWORD_VALIDATION_KEYS: readonly ["length", "uppercase", "lowercase", "number"];
@@ -40,7 +39,7 @@ type CertificateIssuanceContext = {
 type CertificateIssuanceInput = {
   config: CertificateIssuanceConfig;
 };
-declare const certificateIssuanceMachine: xstate80.StateMachine<CertificateIssuanceContext, {
+declare const certificateIssuanceMachine: StateMachine<CertificateIssuanceContext, {
   type: "LOAD";
 } | {
   type: "PASSWORD_CHANGED";
@@ -54,69 +53,67 @@ declare const certificateIssuanceMachine: xstate80.StateMachine<CertificateIssua
 } | {
   type: "FINISH";
 }, {
-  [x: string]: xstate80.ActorRefFromLogic<xstate80.PromiseActorLogic<IssueCertificateResponse, {
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<IssueCertificateResponse, {
     password: string;
-  }, xstate80.EventObject>> | undefined;
+  }, EventObject>> | undefined;
 }, {
   src: "issueCertificate";
-  logic: xstate80.PromiseActorLogic<IssueCertificateResponse, {
+  logic: PromiseActorLogic<IssueCertificateResponse, {
     password: string;
-  }, xstate80.EventObject>;
+  }, EventObject>;
   id: string | undefined;
-}, xstate80.Values<{
+}, Values<{
   setPassword: {
     type: "setPassword";
-    params: xstate80.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
   setBlob: {
     type: "setBlob";
-    params: xstate80.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
 }>, {
   type: "isPasswordValid";
   params: unknown;
-}, never, "error" | "idle" | "processing" | "success" | "finished" | "password" | "downloaded", string, CertificateIssuanceInput, xstate80.NonReducibleUnknown, xstate80.EventObject, xstate80.MetaObject, {
+}, never, "error" | "idle" | "processing" | "success" | "finished" | "password" | "downloaded", string, CertificateIssuanceInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "certificateIssuance";
   readonly initial: "idle";
-  readonly context: ({
-    input
-  }: {
+  readonly context: ({ input }: {
     spawn: {
       <TSrc extends "issueCertificate">(logic: TSrc, ...[options]: {
         src: "issueCertificate";
-        logic: xstate80.PromiseActorLogic<IssueCertificateResponse, {
+        logic: PromiseActorLogic<IssueCertificateResponse, {
           password: string;
-        }, xstate80.EventObject>;
+        }, EventObject>;
         id: string | undefined;
-      } extends infer T ? T extends {
+      } extends (infer T) ? T extends {
         src: "issueCertificate";
-        logic: xstate80.PromiseActorLogic<IssueCertificateResponse, {
+        logic: PromiseActorLogic<IssueCertificateResponse, {
           password: string;
-        }, xstate80.EventObject>;
+        }, EventObject>;
         id: string | undefined;
       } ? T extends {
         src: TSrc;
-      } ? xstate80.ConditionalRequired<[options?: ({
+      } ? ConditionalRequired<[options?: ({
         id?: T["id"] | undefined;
         systemId?: string;
-        input?: xstate80.InputFrom<T["logic"]> | undefined;
+        input?: InputFrom<T["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate80.RequiredActorOptions<T>]: unknown }) | undefined], xstate80.IsNotNever<xstate80.RequiredActorOptions<T>>> : never : never : never): xstate80.ActorRefFromLogic<xstate80.GetConcreteByKey<{
+      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never): ActorRefFromLogic<GetConcreteByKey<{
         src: "issueCertificate";
-        logic: xstate80.PromiseActorLogic<IssueCertificateResponse, {
+        logic: PromiseActorLogic<IssueCertificateResponse, {
           password: string;
-        }, xstate80.EventObject>;
+        }, EventObject>;
         id: string | undefined;
       }, "src", TSrc>["logic"]>;
-      <TLogic extends xstate80.AnyActorLogic>(src: TLogic, ...[options]: xstate80.ConditionalRequired<[options?: ({
+      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate80.InputFrom<TLogic> | undefined;
+        input?: InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate80.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate80.IsNotNever<xstate80.RequiredLogicInput<TLogic>>>): xstate80.ActorRefFromLogic<TLogic>;
+      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
     };
     input: CertificateIssuanceInput;
-    self: xstate80.ActorRef<xstate80.MachineSnapshot<CertificateIssuanceContext, {
+    self: ActorRef<MachineSnapshot<CertificateIssuanceContext, {
       type: "LOAD";
     } | {
       type: "PASSWORD_CHANGED";
@@ -129,7 +126,7 @@ declare const certificateIssuanceMachine: xstate80.StateMachine<CertificateIssua
       type: "DOWNLOAD_FAILED";
     } | {
       type: "FINISH";
-    }, Record<string, xstate80.AnyActorRef | undefined>, xstate80.StateValue, string, unknown, any, any>, {
+    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "PASSWORD_CHANGED";
@@ -142,7 +139,7 @@ declare const certificateIssuanceMachine: xstate80.StateMachine<CertificateIssua
       type: "DOWNLOAD_FAILED";
     } | {
       type: "FINISH";
-    }, xstate80.AnyEventObject>;
+    }, AnyEventObject>;
   }) => {
     config: CertificateIssuanceConfig;
     password: string;
@@ -172,9 +169,7 @@ declare const certificateIssuanceMachine: xstate80.StateMachine<CertificateIssua
       readonly invoke: {
         readonly id: "issueCertificate";
         readonly src: "issueCertificate";
-        readonly input: ({
-          context
-        }: {
+        readonly input: ({ context }: {
           context: CertificateIssuanceContext;
           event: {
             type: "LOAD";
@@ -190,7 +185,7 @@ declare const certificateIssuanceMachine: xstate80.StateMachine<CertificateIssua
           } | {
             type: "FINISH";
           };
-          self: xstate80.ActorRef<xstate80.MachineSnapshot<CertificateIssuanceContext, {
+          self: ActorRef<MachineSnapshot<CertificateIssuanceContext, {
             type: "LOAD";
           } | {
             type: "PASSWORD_CHANGED";
@@ -203,7 +198,7 @@ declare const certificateIssuanceMachine: xstate80.StateMachine<CertificateIssua
             type: "DOWNLOAD_FAILED";
           } | {
             type: "FINISH";
-          }, Record<string, xstate80.AnyActorRef>, xstate80.StateValue, string, unknown, any, any>, {
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
             type: "LOAD";
           } | {
             type: "PASSWORD_CHANGED";
@@ -216,7 +211,7 @@ declare const certificateIssuanceMachine: xstate80.StateMachine<CertificateIssua
             type: "DOWNLOAD_FAILED";
           } | {
             type: "FINISH";
-          }, xstate80.AnyEventObject>;
+          }, AnyEventObject>;
         }) => {
           password: string;
         };

package/dist/certificate-issuance.esm.js

@@ -1,11 +1,6 @@
-import "./api-DsbUi7TO.esm.js";
-import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
-import "./urlUtils-CpiYwn7w.esm.js";
-import "./externalFetch-hvmz_npP.esm.js";
-import { a as MIN_PASSWORD_LENGTH, i as validatePassword, n as emptyPasswordValidations, o as PASSWORD_VALIDATION_KEYS, r as isPasswordValid, s as REQUIREMENT_I18N_KEYS, t as certificateIssuanceMachine } from "./certificateIssuanceStateMachine-DlZQT1_u.esm.js";
-
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { a as MIN_PASSWORD_LENGTH, i as validatePassword, n as emptyPasswordValidations, o as PASSWORD_VALIDATION_KEYS, r as isPasswordValid, s as REQUIREMENT_I18N_KEYS, t as certificateIssuanceMachine } from "./certificateIssuanceStateMachine-COd7_l2T.esm.js";
 //#region src/modules/certificate-issuance/certificateIssuanceActor.ts
 /**
 * Creates and starts a certificate issuance actor.
@@ -13,7 +8,6 @@ import { a as MIN_PASSWORD_LENGTH, i as validatePassword, n as emptyPasswordVali
 function createCertificateIssuanceActor(options) {
 	return createActor(certificateIssuanceMachine, { input: { config: options.config } }).start();
 }
-
 //#endregion
 //#region src/modules/certificate-issuance/certificateIssuanceManager.ts
 function mapState(snapshot) {
@@ -68,6 +62,5 @@ function createCertificateIssuanceManager(options) {
 		instrumentation: createManagerInstrumentation(eventModuleNames.certificateIssuance)
 	});
 }
-
 //#endregion
-export { MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, emptyPasswordValidations, isPasswordValid, validatePassword };
+export { MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, emptyPasswordValidations, isPasswordValid, validatePassword };

package/dist/{certificateIssuanceStateMachine-DlZQT1_u.esm.js → certificateIssuanceStateMachine-COd7_l2T.esm.js}

@@ -1,8 +1,8 @@
-import { n as getApi, r as getToken } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as externalFetch } from "./externalFetch-hvmz_npP.esm.js";
-
+import { n as getApi, r as getToken } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { t as externalFetch } from "./externalFetch-BKBThAUC.esm.js";
 //#region src/modules/certificate-issuance/certificateIssuanceServices.ts
 function buildIssueCertificateUrl(baseURL) {
 	return `${baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL}${endpoints.certificateIssuanceIssue}`;
@@ -25,7 +25,6 @@ async function issueCertificate(params, signal) {
 		signal
 	})).blob() };
 }
-
 //#endregion
 //#region src/modules/certificate-issuance/certificateIssuanceConstants.ts
 const MIN_PASSWORD_LENGTH = 8;
@@ -41,7 +40,6 @@ const REQUIREMENT_I18N_KEYS = {
 	lowercase: "certificateIssuance.password.lowercase",
 	number: "certificateIssuance.password.number"
 };
-
 //#endregion
 //#region src/modules/certificate-issuance/certificateIssuanceUtils.ts
 function emptyPasswordValidations() {
@@ -54,7 +52,7 @@ function emptyPasswordValidations() {
 }
 function validatePassword(value) {
 	return {
-		length: value.length >= MIN_PASSWORD_LENGTH,
+		length: value.length >= 8,
 		uppercase: /[A-Z]/.test(value),
 		lowercase: /[a-z]/.test(value),
 		number: /[0-9]/.test(value)
@@ -63,7 +61,6 @@ function validatePassword(value) {
 function isPasswordValid(validations) {
 	return PASSWORD_VALIDATION_KEYS.every((key) => validations[key]);
 }
-
 //#endregion
 //#region src/modules/certificate-issuance/certificateIssuanceStateMachine.ts
 const certificateIssuanceMachine = setup({
@@ -122,6 +119,5 @@ const certificateIssuanceMachine = setup({
 		finished: { type: "final" }
 	}
 });
-
 //#endregion
-export { MIN_PASSWORD_LENGTH as a, validatePassword as i, emptyPasswordValidations as n, PASSWORD_VALIDATION_KEYS as o, isPasswordValid as r, REQUIREMENT_I18N_KEYS as s, certificateIssuanceMachine as t };
+export { MIN_PASSWORD_LENGTH as a, validatePassword as i, emptyPasswordValidations as n, PASSWORD_VALIDATION_KEYS as o, isPasswordValid as r, REQUIREMENT_I18N_KEYS as s, certificateIssuanceMachine as t };

package/dist/consent.d.ts

@@ -1,5 +1,2 @@
-import "./StateMachine-D5WO6lHS.js";
-import "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-B4PMGXW-.js";
+import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-uhDPdU6i.js";
 export { type ConsentActor, type ConsentCheckbox, type ConsentConfig, type ConsentManager, type ConsentState, consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/consent.esm.js

@@ -1,8 +1,3 @@
-import "./api-DsbUi7TO.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./xstate.esm-nY3M5UYm.esm.js";
-import { t as consentMachine } from "./consentStateMachine-BOkVFiU7.esm.js";
-import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-BwNu-uC-.esm.js";
-
-export { consentMachine, createConsentManager, createConsentManagerFromActor };
+import { t as consentMachine } from "./consentStateMachine-WD-S-Yhs.esm.js";
+import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-BApTlfA0.esm.js";
+export { consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/{consentManager-BwNu-uC-.esm.js → consentManager-BApTlfA0.esm.js}

@@ -1,12 +1,11 @@
-import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as consentMachine } from "./consentStateMachine-BOkVFiU7.esm.js";
-
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { t as consentMachine } from "./consentStateMachine-WD-S-Yhs.esm.js";
 //#region src/modules/consent/consentActor.ts
 function createConsentActor(options) {
 	return createActor(consentMachine, { input: { config: options.config } }).start();
 }
-
 //#endregion
 //#region src/modules/consent/consentManager.ts
 function getCanSubmit(checkboxes) {
@@ -109,6 +108,5 @@ function createConsentManagerFromActor(actor) {
 		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent, { getEventScreenName: getConsentScreenName })
 	});
 }
-
 //#endregion
-export { createConsentManagerFromActor as n, createConsentManager as t };
+export { createConsentManagerFromActor as n, createConsentManager as t };