écrits/tutorial/2026/11
● Tutorial16 nov. 2026·20 min

Saoudisation des ingénieurs à 30 % et 8 000 SAR : contrôle TypeScript

La décision ministérielle 93483 impose 30 % d'ingénieurs saoudiens sur 46 codes de métier depuis le 30 juin 2026, et un ingénieur saoudien ne compte qu'avec l'accréditation du SCE et un salaire déclaré à la GOSI d'au moins 8 000 SAR. Construisez le contrôle en TypeScript : périmètre de l'entité, arrondi, les deux conditions, régulariser d'abord vos propres salariés, remplacement contre recrutement.

Le 31 décembre 2025, le ministère des Ressources humaines et du Développement social a publié la décision ministérielle 93483, qui approuve la mise à jour du guide de procédure des métiers de l'ingénierie. Après un délai de grâce de six mois, elle s'applique depuis le 30 juin 2026 : tout établissement privé employant au moins cinq personnes dans 46 codes de métier d'ingénieur doit compter au moins 30 % de Saoudiens parmi elles, à l'échelle de l'entité entière.

Le taux est la partie facile. Le guide ajoute deux conditions avant qu'un ingénieur saoudien soit compté : une accréditation professionnelle valide du Saudi Council of Engineers (SCE), et un salaire mensuel déclaré à la GOSI d'au moins 8 000 SAR. Un ingénieur saoudien qui manque l'une des deux figure sur votre paie, dans votre effectif d'ingénieurs, et ne vaut rien pour votre taux. La plupart des exports RH ne contiennent pas la date d'expiration de l'accréditation, si bien que la plupart des contrôles ne voient pas le problème.

Ce tutoriel construit le contrôle en TypeScript à partir du guide officiel, avec des tests exécutables. Il s'adresse au développeur ou au responsable des systèmes RH chargé d'avoir des chiffres justes, pas à la personne qui décide de se conformer ou non. La décision est déjà en vigueur : le module indique depuis combien de temps vous êtes en dessous, pas combien de temps il vous reste.

Si votre sujet est celui des techniciens plutôt que des ingénieurs, il s'agit d'une autre décision avec d'autres codes : voir notre actualité sur le passage des techniciens à 35 % et le moteur des techniciens.

Prérequis

  • Node.js 20 ou plus récent et TypeScript 5
  • Un export du personnel avec, pour chaque salarié : la nationalité, le code de métier enregistré dans Qiwa, la succursale et l'entité de rattachement, et le salaire soumis à cotisation GOSI
  • Deux colonnes que la plupart des exports n'ont pas encore : la date d'expiration de l'accréditation SCE de chaque ingénieur saoudien, et si la personne exerce réellement un travail d'ingénieur. La première vient de l'ingénieur ou du registre du SCE, la seconde des responsables directs
  • Une connaissance de base des termes Qiwa et Nitaqat

Ce que vous allez construire

Un petit module qui répond à six questions pour chaque entité :

  1. Combien de salariés relèvent des 46 codes, et la décision s'applique-t-elle ?
  2. Combien de Saoudiens sont requis, avec l'arrondi du guide ?
  3. Quels ingénieurs saoudiens échouent à la condition de salaire, à celle d'accréditation, ou aux deux ?
  4. Lesquels pouvez-vous régulariser en premier, et pour quel coût mensuel ?
  5. Ensuite, combien de non-Saoudiens remplacer, ou combien de Saoudiens recruter ?
  6. Quels salariés créent un risque parce que leur code et leur travail réel divergent ?

Le résultat est un court plan d'action lisible par les RH.

Étape 1 : ce que dit réellement le guide

Nous avons lu le guide de procédure et la décision dans le centre de connaissances du ministère (« الدليل الإجرائي لقرار توطين المهن الهندسية »). Voici les faits sur lesquels repose le code :

PointTexte du guide, résumé
DécisionDécision ministérielle 93483 du 31/12/2025 (11/07/1447 H), approuvant le guide mis à jour
Taux30 % de l'ensemble des salariés des métiers visés, au niveau de l'entité (section 3.1)
PérimètreÉtablissements privés employant 5 salariés ou plus dans les métiers du tableau 1 (section 3.2)
EntitéToutes les succursales de même activité économique appartenant à un même établissement
MétiersTableau 1 : 46 codes de métier, de l'ingénieur civil et électricien à l'ingénieur coûts, qualité ou nucléaire
SalaireUn ingénieur saoudien ne compte que si son salaire mensuel déclaré à la GOSI, le salaire soumis à cotisation, est d'au moins 8 000 SAR (section 3.3)
AccréditationL'ingénieur doit détenir l'accréditation professionnelle du Saudi Council of Engineers ; les non-accrédités ne sont pas comptés (section 3.4)
ChevauchementSi une autre décision vise un métier d'ingénieur à un taux différent, le taux le plus élevé s'applique (section 3.2, article 3 de la décision)
DatesPubliée le 31/12/2025, délai de grâce de six mois, application depuis le 30/06/2026 (section 3.7)
SanctionsNe pas respecter le taux, ou confier à un non-Saoudien les tâches d'un métier saoudisé sous un autre intitulé, relève des infractions de saoudisation des décisions 75913 et 44558 (section 5)
FAQS'applique quelle que soit la bande Nitaqat de l'établissement ; s'applique à l'intitulé classé et au travail réel ; calcul automatique à partir des données GOSI et des registres d'accréditation

L'exemple chiffré du guide est le meilleur cas de test dont vous disposerez. Un établissement compte 5 agents de nettoyage, 14 administratifs, 23 techniciens et 51 ingénieurs répartis en quatre spécialités. Seuls les 51 ingénieurs comptent. 4 sont saoudiens, donc 51 × 30 % = 15,3, arrondi à 15, moins 4 : remplacer 11 ingénieurs non saoudiens par des Saoudiens. Une note précise que ce calcul suppose le remplacement, et qu'ajouter des Saoudiens à l'effectif impose de recalculer.

Deux points que le guide ne dit pas, et que le code traite comme des paramètres plutôt que comme des faits :

  • Si un ingénieur saoudien qui échoue à une condition reste au dénominateur. Le guide dit qu'il « ne sera pas compté dans le taux de saoudisation ». Nous le lisons ainsi : toujours ingénieur, mais pas saoudien pour le ratio. C'est la lecture la plus stricte, et celle par défaut.
  • D'où viennent les données d'accréditation dans votre système. Le ministère lit directement le registre du SCE ; vous devrez tenir votre propre copie de chaque date d'expiration.

Étape 2 : les règles comme données

Gardez le guide dans un seul enregistrement, pas en constantes dispersées dans le code. Quand le ministère mettra à jour la liste, comme il l'a fait avec cette décision, vous modifiez l'enregistrement et les tests montrent ce qui a bougé.

// src/rules.ts
export type OccupationCode = string;
 
export interface QuotaRule {
  decision: string;
  guideIssued: string;    // ISO date
  effectiveFrom: string;  // ISO date, end of the grace period
  ratePercent: number;    // whole percent
  minWorkers: number;     // applies from this many workers in the listed codes
  gosiWageFloor: number | null;        // SAR per month, GOSI contributory wage
  requiresSceAccreditation: boolean;   // Saudi Council of Engineers
  codes: Record<OccupationCode, string>;
}
 
// Updated procedural guide, Ministerial Decision 93483 of 31 Dec 2025
// (11/07/1447 AH). Table 1 lists 46 engineering occupation codes.
export const ENGINEERS_2026: QuotaRule = {
  decision: "93483",
  guideIssued: "2025-12-31",
  effectiveFrom: "2026-06-30",
  ratePercent: 30,
  minWorkers: 5,
  gosiWageFloor: 8000,
  requiresSceAccreditation: true,
  codes: {
    "214904": "Materials engineer",
    "215104": "Electromechanical engineer",
    "214201": "Civil engineer",
    "215105": "Automation engineer",
    "214601": "Mining engineer",
    "215106": "Power generation engineer",
    "216101": "Architect",
    "216102": "Interior architect",
    "214409": "Heavy equipment mechanical engineer",
    "214206": "Roads engineer",
    "214103": "Production engineer, technical",
    "214207": "Bridges engineer",
    "214202": "Civil engineer, technical",
    "214404": "Aeronautical engineer",
    "214204": "Geotechnical engineer",
    "215108": "Electrical installations engineer",
    "214205": "Structural engineer",
    "214602": "Metallurgical engineer",
    "214302": "Water treatment engineer",
    "214407": "Welding mechanical engineer",
    "214303": "Sanitary engineer",
    "214102": "Production engineer",
    "214402": "Mechanical engineer, technical",
    "215101": "Electrical engineer",
    "214408": "Railway mechanical engineer",
    "214401": "Mechanical engineer",
    "214411": "Turbines engineer",
    "216201": "Landscape and site design engineer",
    "214412": "Mechatronics engineer",
    "214101": "Industrial engineer",
    "214502": "Chemical engineer, technical",
    "215201": "Electronics engineer",
    "214504": "Water desalination engineer",
    "214301": "Environmental engineer",
    "214603": "Oil and gas engineer",
    "214406": "HVAC engineer",
    "214902": "Cost engineer",
    "214410": "Vehicles engineer",
    "214903": "Explosives engineer",
    "214501": "Chemical engineer",
    "214906": "Quality control engineer",
    "214915": "Nuclear engineer",
    "214908": "Research and development engineer",
    "214405": "Marine engineer",
    "215102": "Electrical engineer, technical",
    "215107": "Power transmission and distribution engineer",
  },
};

Les codes sont les codes à six chiffres de la classification saoudienne unifiée des métiers, tels qu'imprimés dans le tableau 1. Les libellés anglais sont les nôtres ; les intitulés arabes du guide font foi. Les 46 codes commencent tous par 21 : les techniciens ont des codes qui commencent par 3 et relèvent de leur propre décision, les deux viviers ne se mélangent donc jamais.

Étape 3 : l'arrondi et les deux façons de combler un écart

Le guide arrondit à l'entier le plus proche : 15,3 devient 15. Nous calculons en pourcentages entiers pour que le résultat ne dépende jamais de la façon dont un décimal comme 0,3 est stocké. À 30 %, nous n'avons trouvé aucun effectif jusqu'à 300 où Math.round(n * 0.3) se trompe, mais la même fonction sert les décisions à 35 % et 70 %, où cela arrive.

// src/quota.ts
// Saudis required for a headcount, rounded to the nearest whole number,
// halves up (51 x 30% = 15.3 gives 15, as in the guide's example).
export function requiredSaudis(headcount: number, ratePercent: number): number {
  return Math.floor((headcount * ratePercent + 50) / 100);
}
 
// Replacement: a non-Saudi leaves, a qualified Saudi takes the post.
export function gapByReplacement(
  headcount: number,
  counted: number,
  ratePercent: number,
): number {
  return Math.max(0, requiredSaudis(headcount, ratePercent) - counted);
}
 
// Hiring only: each new qualified Saudi raises both sides of the ratio.
export function gapByHiring(
  headcount: number,
  counted: number,
  ratePercent: number,
): number {
  if (ratePercent >= 100) {
    return counted >= headcount ? 0 : Number.POSITIVE_INFINITY;
  }
  let hires = 0;
  while (counted + hires < requiredSaudis(headcount + hires, ratePercent)) {
    hires += 1;
  }
  return hires;
}

Le remplacement garde l'effectif : un non-Saoudien part, un Saoudien qualifié prend le poste, seul le numérateur bouge. Le recrutement ajoute des personnes : chaque nouveau Saoudien augmente les deux termes du ratio, d'où la note du guide demandant de recalculer.

Sur l'exemple du guide, le remplacement demande 11 personnes. Le recrutement seul en demande 16 : avec 20 Saoudiens sur 67 ingénieurs, 67 × 30 % = 20,1 arrondi à 20, et l'entité est conforme. Avec dix ingénieurs dont un Saoudien, le remplacement en demande deux et le recrutement seul trois.

Étape 4 : le périmètre, les deux conditions et le travail réel

C'est le cœur du module. Pour chaque entité, il rassemble les salariés des 46 codes, décide qui compte, et note où le code et le travail divergent.

// src/assess.ts
import { QuotaRule } from "./rules";
import { requiredSaudis, gapByReplacement, gapByHiring } from "./quota";
 
export interface Worker {
  id: string;
  entityId: string;               // all branches of one owner, same activity
  branchId: string;
  saudi: boolean;
  occupationCode: string;         // as registered in Qiwa and GOSI
  doesEngineeringWork: boolean;   // from the line manager, not the system
  gosiWage: number;               // monthly contributory wage, SAR
  sceAccreditedUntil: string | null; // ISO date, null = no accreditation
}
 
export type Gate = "wage" | "sce";
 
export interface UncountedSaudi {
  id: string;
  failed: Gate[];
  wageTopUp: number; // SAR per month to reach the floor, 0 if not needed
}
 
export interface Assessment {
  entityId: string;
  applies: boolean;
  headcount: number;   // workers in the listed codes (the denominator)
  ratePercent: number;
  uncountedInHeadcount: boolean;
  saudis: number;      // Saudis in the listed codes
  counted: number;     // Saudis who pass every gate
  required: number;
  gapByReplacement: number;
  gapByHiring: number;
  uncounted: UncountedSaudi[];
  codeWithoutWork: string[];  // listed code, other work: fix the registration
  workWithoutCode: string[];  // engineering work, other code: breach risk
}
 
export interface Options {
  // Our reading, not the guide's words: a Saudi engineer who fails a gate
  // still sits in the denominator. Set false to test the other reading.
  uncountedStayInHeadcount: boolean;
}
 
export function gatesFailed(w: Worker, rule: QuotaRule, asOf: string): Gate[] {
  const failed: Gate[] = [];
  if (rule.gosiWageFloor !== null && w.gosiWage < rule.gosiWageFloor) {
    failed.push("wage");
  }
  if (
    rule.requiresSceAccreditation &&
    (w.sceAccreditedUntil === null || w.sceAccreditedUntil < asOf)
  ) {
    failed.push("sce");
  }
  return failed;
}
 
export function assessEntity(
  entityId: string,
  workers: Worker[],
  rule: QuotaRule,
  asOf: string,
  options: Options = { uncountedStayInHeadcount: true },
): Assessment {
  const mine = workers.filter((w) => w.entityId === entityId);
  const listed = mine.filter((w) => w.occupationCode in rule.codes);
 
  const uncounted: UncountedSaudi[] = [];
  let counted = 0;
  for (const w of listed.filter((x) => x.saudi)) {
    const failed = gatesFailed(w, rule, asOf);
    if (failed.length === 0) {
      counted += 1;
    } else {
      const floor = rule.gosiWageFloor ?? 0;
      uncounted.push({
        id: w.id,
        failed,
        wageTopUp: failed.includes("wage") ? floor - w.gosiWage : 0,
      });
    }
  }
 
  const headcount = options.uncountedStayInHeadcount
    ? listed.length
    : listed.length - uncounted.length;
  const applies = listed.length >= rule.minWorkers;
 
  return {
    entityId,
    applies,
    headcount,
    ratePercent: rule.ratePercent,
    uncountedInHeadcount: options.uncountedStayInHeadcount,
    saudis: listed.filter((w) => w.saudi).length,
    counted,
    required: applies ? requiredSaudis(headcount, rule.ratePercent) : 0,
    gapByReplacement: applies
      ? gapByReplacement(headcount, counted, rule.ratePercent)
      : 0,
    gapByHiring: applies ? gapByHiring(headcount, counted, rule.ratePercent) : 0,
    uncounted,
    codeWithoutWork: listed.filter((w) => !w.doesEngineeringWork).map((w) => w.id),
    workWithoutCode: mine
      .filter((w) => w.doesEngineeringWork && !(w.occupationCode in rule.codes))
      .map((w) => w.id),
  };
}

Trois choix de ce fichier méritent une phrase chacun.

L'accréditation est vérifiée par rapport à une date. Un ingénieur dont l'accréditation a expiré hier cesse de compter aujourd'hui. Stocker la date d'expiration, et non un oui ou non, permet aux mêmes données de répondre au contrôle du mois suivant.

Un salarié codé ingénieur qui fait autre chose reste dans le périmètre. La FAQ indique que le taux est calculé automatiquement à partir des données GOSI : le ministère voit le code. Le module compte cette personne, comme le fera le ministère, et la liste dans codeWithoutWork pour que les RH corrigent l'enregistrement.

Un salarié qui fait un travail d'ingénieur sous un autre code est un risque, pas une unité comptée. Pour un non-Saoudien, la section 5 fait de l'attribution des tâches d'un métier saoudisé sous un autre intitulé une infraction. Pour un Saoudien, c'est une unité perdue tant que le code n'est pas corrigé. Les deux apparaissent dans workWithoutCode.

Étape 5 : régulariser d'abord vos propres salariés

Quand l'écart est ouvert, les Saoudiens les moins chers sont souvent ceux que vous employez déjà. Un ingénieur à qui il ne manque que l'accréditation vous coûte une inscription, pas un salaire. Un ingénieur à 7 600 SAR coûte 400 SAR par mois pour franchir le plancher, plus les cotisations patronales GOSI sur cette hausse. Les deux reviennent moins cher qu'un recrutement, et aucun ne fait partir quelqu'un.

// src/fixes.ts
import { Assessment, UncountedSaudi } from "./assess";
import { gapByHiring, requiredSaudis } from "./quota";
 
export interface FixPlan {
  wageTopUps: { id: string; perMonth: number }[];
  accreditations: string[];   // Saudis to register with the SCE
  stillToFill: number;        // posts left after fixing your own people
  hiresInstead: number;       // or this many new hires, nobody replaced
  topUpCostPerMonth: number;
}
 
// Each Saudi engineer you already employ and bring over both gates closes
// one place of the gap. Cheapest first: accreditation only (no wage cost),
// then the smallest wage top-ups.
export function fixFromWithin(a: Assessment): FixPlan {
  const order = (u: UncountedSaudi) =>
    u.failed.includes("wage") ? u.wageTopUp : -1;
  const candidates = [...a.uncounted].sort((x, y) => order(x) - order(y));
  // Fix one person at a time until the gap closes. A fixed Saudi always
  // adds one to the count; under the other reading the person also joins the
  // denominator, so the requirement is recomputed each time.
  const chosen: UncountedSaudi[] = [];
  let counted = a.counted;
  let headcount = a.headcount;
  for (const u of candidates) {
    if (counted >= requiredSaudis(headcount, a.ratePercent)) break;
    chosen.push(u);
    counted += 1;
    if (!a.uncountedInHeadcount) headcount += 1;
  }
  const stillToFill = Math.max(0, requiredSaudis(headcount, a.ratePercent) - counted);
 
  const wageTopUps = chosen
    .filter((u) => u.failed.includes("wage"))
    .map((u) => ({ id: u.id, perMonth: u.wageTopUp }));
 
  return {
    wageTopUps,
    accreditations: chosen.filter((u) => u.failed.includes("sce")).map((u) => u.id),
    stillToFill,
    hiresInstead: stillToFill === 0 ? 0 : gapByHiring(headcount, counted, a.ratePercent),
    topUpCostPerMonth: wageTopUps.reduce((s, t) => s + t.perMonth, 0),
  };
}

L'ordre est voulu : d'abord les cas d'accréditation seule, sans coût salarial, puis les hausses de salaire de la plus petite à la plus grande. Un ingénieur qui échoue aux deux conditions est classé avec les cas de salaire, selon le montant de la hausse. La boucle recalcule l'exigence à chaque fois : elle s'arrête dès que l'écart est comblé et n'augmente personne pour rien.

Deux précautions pour qui exécute la liste. D'abord, une hausse de salaire destinée à franchir un seuil doit être un vrai salaire, payé et déclaré ; le ministère lit la GOSI, et un écart entre la GOSI et la paie est un problème à part entière. Ensuite, l'accréditation dépend du diplôme de l'ingénieur et des exigences du SCE ; le module vous dit qui inscrire, pas que l'inscription aboutira.

Étape 6 : quand deux décisions couvrent un même code

L'article 3 de la décision prévoit que si une autre décision vise un métier d'ingénieur à un taux différent, le plus élevé s'applique. À ce jour, aucun des 46 codes ne figure dans une autre décision à notre connaissance, mais la gestion de projet (code 214909) est juste à côté, dans une décision distincte à 70 %, et les listes changent. Résolvez la règle par code et par date :

// src/overlap.ts
import { QuotaRule } from "./rules";
 
// Clause 3 of the decision: where another decision targets an engineering
// code at a different rate, the higher rate applies. Pick, per code, the
// rule in force on the date with the highest rate.
export function ruleFor(
  code: string,
  rules: QuotaRule[],
  asOf: string,
): QuotaRule | null {
  const inForce = rules.filter((r) => code in r.codes && r.effectiveFrom <= asOf);
  if (inForce.length === 0) return null;
  return inForce.reduce((best, r) => (r.ratePercent > best.ratePercent ? r : best));
}

En pratique, vous regroupez les salariés selon la règle renvoyée par ruleFor et lancez assessEntity une fois par règle. Les tests ci-dessous utilisent une règle fictive à 40 % pour montrer la bascule.

Étape 7 : des constats au plan d'action

Les RH n'ont pas besoin de l'objet d'évaluation. Il leur faut quelques lignes, dans l'ordre où agir :

// src/plan.ts
import { Assessment } from "./assess";
import { FixPlan } from "./fixes";
import { QuotaRule } from "./rules";
 
const DAY = 24 * 60 * 60 * 1000;
 
export function daysSince(fromIso: string, asOfIso: string): number {
  return Math.round((Date.parse(asOfIso) - Date.parse(fromIso)) / DAY);
}
 
export function actionPlan(
  a: Assessment,
  fix: FixPlan,
  rule: QuotaRule,
  asOf: string,
): string[] {
  if (!a.applies) {
    return [`${a.entityId}: ${a.headcount} worker(s) in the listed codes, under ${rule.minWorkers}. Recheck at every hire.`];
  }
  const lines: string[] = [];
  const late = daysSince(rule.effectiveFrom, asOf);
  if (a.gapByReplacement === 0) {
    lines.push(`${a.entityId}: compliant, ${a.counted} of ${a.required} required.`);
  } else if (late >= 0) {
    lines.push(`${a.entityId}: short by ${a.gapByReplacement}, in force since ${rule.effectiveFrom} (${late} days).`);
  } else {
    lines.push(`${a.entityId}: short by ${a.gapByReplacement}, applies from ${rule.effectiveFrom}, ${-late} days left.`);
  }
  for (const t of fix.wageTopUps) {
    lines.push(`Raise ${t.id} by SAR ${t.perMonth} a month in GOSI.`);
  }
  for (const id of fix.accreditations) {
    lines.push(`Register ${id} with the Saudi Council of Engineers.`);
  }
  if (fix.stillToFill > 0) {
    lines.push(`Then replace ${fix.stillToFill} non-Saudi(s), or hire ${fix.hiresInstead} Saudi engineer(s) without replacing anyone.`);
  }
  for (const id of a.workWithoutCode) {
    lines.push(`${id} does engineering work under another code: fix the code.`);
  }
  for (const id of a.codeWithoutWork) {
    lines.push(`${id} is coded as an engineer but does other work: fix the code.`);
  }
  return lines;
}

Pour une entité de dix ingénieurs, dont un Saoudien à 7 000 SAR, le plan donne :

E1: short by 3, in force since 2026-06-30 (139 days).
Raise s1 by SAR 1000 a month in GOSI.
Then replace 2 non-Saudi(s), or hire 3 Saudi engineer(s) without replacing anyone.

Tester votre implémentation

Ces tests fixent chaque chiffre donné par le guide, plus les cas limites autour des deux conditions. Lancez-les avec node --import tsx --test src/assess.test.ts.

// src/assess.test.ts
import { test } from "node:test";
import assert from "node:assert/strict";
import { ENGINEERS_2026, QuotaRule } from "./rules";
import { requiredSaudis, gapByReplacement, gapByHiring } from "./quota";
import { assessEntity, gatesFailed, Worker } from "./assess";
import { fixFromWithin } from "./fixes";
import { ruleFor } from "./overlap";
import { actionPlan } from "./plan";
 
const ASOF = "2026-11-16";
const w = (id: string, saudi: boolean, extra: Partial<Worker> = {}): Worker => ({
  id, entityId: "E1", branchId: "B1", saudi, occupationCode: "214201",
  doesEngineeringWork: true, gosiWage: 12000, sceAccreditedUntil: "2027-06-30",
  ...extra,
});
const many = (n: number, saudi: boolean, prefix: string, extra: Partial<Worker> = {}) =>
  Array.from({ length: n }, (_, i) => w(`${prefix}${i + 1}`, saudi, extra));
 
test("table 1 holds 46 codes", () => {
  assert.equal(Object.keys(ENGINEERS_2026.codes).length, 46);
});
 
test("guide example: 51 engineers, 4 Saudis, replace 11", () => {
  assert.equal(requiredSaudis(51, 30), 15); // 15.3
  assert.equal(gapByReplacement(51, 4, 30), 11);
});
 
test("rounding is to the nearest whole number, halves up", () => {
  assert.equal(requiredSaudis(5, 30), 2);  // 1.5
  assert.equal(requiredSaudis(6, 30), 2);  // 1.8
  assert.equal(requiredSaudis(8, 30), 2);  // 2.4
  assert.equal(requiredSaudis(15, 30), 5); // 4.5
  assert.equal(requiredSaudis(20, 30), 6);
});
 
test("hiring only needs more people than replacement", () => {
  assert.equal(gapByHiring(51, 4, 30), 16); // 20 of 67 = 29.9% rounds to 20
  assert.equal(gapByHiring(10, 1, 30), 3); // 4 of 13 = 30.8%
  assert.equal(gapByHiring(10, 3, 30), 0);
  assert.equal(gapByHiring(3, 0, 100), Number.POSITIVE_INFINITY);
});
 
test("the guide's office: cleaners, admin and technicians are out", () => {
  const staff = [
    ...many(5, false, "C", { occupationCode: "911201", doesEngineeringWork: false }),
    ...many(14, false, "A", { occupationCode: "411001", doesEngineeringWork: false }),
    ...many(23, false, "T", { occupationCode: "311201", doesEngineeringWork: false }),
    ...many(4, true, "S"),
    ...many(47, false, "N"),
  ];
  const a = assessEntity("E1", staff, ENGINEERS_2026, ASOF);
  assert.equal(a.headcount, 51);
  assert.equal(a.required, 15);
  assert.equal(a.gapByReplacement, 11);
});
 
test("the decision applies from five engineers", () => {
  assert.equal(assessEntity("E1", many(4, false, "N"), ENGINEERS_2026, ASOF).applies, false);
  assert.equal(assessEntity("E1", many(5, false, "N"), ENGINEERS_2026, ASOF).applies, true);
});
 
test("branches of one entity are counted together", () => {
  const staff = [
    ...many(3, false, "R", { branchId: "Riyadh" }),
    ...many(3, false, "J", { branchId: "Jeddah" }),
    w("other", false, { entityId: "E2" }),
  ];
  const a = assessEntity("E1", staff, ENGINEERS_2026, ASOF);
  assert.equal(a.headcount, 6);
  assert.equal(a.applies, true);
  assert.equal(a.required, 2);
});
 
test("a Saudi under SAR 8,000 or without SCE accreditation does not count", () => {
  assert.deepEqual(gatesFailed(w("a", true, { gosiWage: 7999 }), ENGINEERS_2026, ASOF), ["wage"]);
  assert.deepEqual(gatesFailed(w("b", true, { gosiWage: 8000 }), ENGINEERS_2026, ASOF), []);
  assert.deepEqual(gatesFailed(w("c", true, { sceAccreditedUntil: null }), ENGINEERS_2026, ASOF), ["sce"]);
  assert.deepEqual(gatesFailed(w("d", true, { sceAccreditedUntil: "2026-11-15" }), ENGINEERS_2026, ASOF), ["sce"]);
  assert.deepEqual(gatesFailed(w("e", true, { sceAccreditedUntil: ASOF }), ENGINEERS_2026, ASOF), []);
});
 
test("uncounted Saudis stay in the denominator by default", () => {
  const staff = [
    ...many(7, false, "N"),
    w("s1", true),
    w("s2", true, { gosiWage: 7000 }),
    w("s3", true, { sceAccreditedUntil: null }),
  ];
  const a = assessEntity("E1", staff, ENGINEERS_2026, ASOF);
  assert.equal(a.headcount, 10);
  assert.equal(a.saudis, 3);
  assert.equal(a.counted, 1);
  assert.equal(a.gapByReplacement, 2);
  const b = assessEntity("E1", staff, ENGINEERS_2026, ASOF, { uncountedStayInHeadcount: false });
  assert.equal(b.headcount, 8);
  assert.equal(b.gapByReplacement, 1); // 2.4 rounds to 2
});
 
test("fix your own people first, accreditation before wage", () => {
  const staff = [
    ...many(16, false, "N"),
    w("s1", true),
    w("low", true, { gosiWage: 6500 }),
    w("near", true, { gosiWage: 7600 }),
    w("nosce", true, { sceAccreditedUntil: null }),
  ];
  const a = assessEntity("E1", staff, ENGINEERS_2026, ASOF);
  assert.equal(a.required, 6);
  assert.equal(a.gapByReplacement, 5);
  const fix = fixFromWithin(a);
  assert.deepEqual(fix.accreditations, ["nosce"]);
  assert.deepEqual(fix.wageTopUps, [{ id: "near", perMonth: 400 }, { id: "low", perMonth: 1500 }]);
  assert.equal(fix.topUpCostPerMonth, 1900);
  assert.equal(fix.stillToFill, 2);
  assert.equal(fix.hiresInstead, 3); // 7 of 23 = 30.4%
});
 
test("accreditation is fixed before any wage, even a small one", () => {
  const staff = [
    ...many(6, false, "N"),
    w("s1", true),
    w("s2", true),
    w("near", true, { gosiWage: 7900 }),
    w("nosce", true, { sceAccreditedUntil: null }),
  ];
  const a = assessEntity("E1", staff, ENGINEERS_2026, ASOF);
  assert.equal(a.gapByReplacement, 1);
  const fix = fixFromWithin(a);
  assert.deepEqual(fix.accreditations, ["nosce"]);
  assert.deepEqual(fix.wageTopUps, []);
});
 
test("under the other reading a fixed Saudi also joins the denominator", () => {
  const staff = [
    ...many(7, false, "N"),
    w("s1", true),
    w("s2", true, { gosiWage: 7000 }),
    w("s3", true, { gosiWage: 7500 }),
  ];
  const a = assessEntity("E1", staff, ENGINEERS_2026, ASOF, { uncountedStayInHeadcount: false });
  assert.equal(a.gapByReplacement, 1); // 8 x 30% = 2.4, 1 counted
  const fix = fixFromWithin(a);
  // after s3, 2 of 9 is short again (2.7 rounds to 3), so s2 follows
  assert.deepEqual(fix.wageTopUps, [{ id: "s3", perMonth: 500 }, { id: "s2", perMonth: 1000 }]);
  assert.equal(fix.stillToFill, 0);
});
 
test("fixing stops once the gap is closed", () => {
  const staff = [
    ...many(7, false, "N"),
    w("s1", true),
    w("s2", true, { gosiWage: 7900 }),
    w("s3", true, { gosiWage: 6000 }),
  ];
  const fix = fixFromWithin(assessEntity("E1", staff, ENGINEERS_2026, ASOF));
  assert.deepEqual(fix.wageTopUps, [{ id: "s2", perMonth: 100 }, { id: "s3", perMonth: 2000 }]);
  const tight = [...staff, w("s4", true)];
  const fix2 = fixFromWithin(assessEntity("E1", tight, ENGINEERS_2026, ASOF));
  assert.deepEqual(fix2.wageTopUps, [{ id: "s2", perMonth: 100 }]);
  assert.equal(fix2.stillToFill, 0);
});
 
test("code and work that disagree are both reported", () => {
  const staff = [
    ...many(5, false, "N"),
    w("desk", false, { doesEngineeringWork: false }),
    w("hidden", false, { occupationCode: "311201" }),
  ];
  const a = assessEntity("E1", staff, ENGINEERS_2026, ASOF);
  assert.deepEqual(a.codeWithoutWork, ["desk"]);
  assert.deepEqual(a.workWithoutCode, ["hidden"]);
  assert.equal(a.headcount, 6);
});
 
test("the higher rate wins where two decisions list the same code", () => {
  const other: QuotaRule = {
    ...ENGINEERS_2026, decision: "test", ratePercent: 40,
    effectiveFrom: "2027-01-01", codes: { "214902": "Cost engineer" },
  };
  assert.equal(ruleFor("214902", [ENGINEERS_2026, other], ASOF)?.decision, "93483");
  assert.equal(ruleFor("214902", [ENGINEERS_2026, other], "2027-01-01")?.decision, "test");
  assert.equal(ruleFor("214201", [ENGINEERS_2026, other], "2027-01-01")?.decision, "93483");
  assert.equal(ruleFor("311201", [ENGINEERS_2026, other], ASOF), null);
});
 
test("the plan reads as days in force after 30 June 2026", () => {
  const staff = [...many(9, false, "N"), w("s1", true, { gosiWage: 7000 })];
  const a = assessEntity("E1", staff, ENGINEERS_2026, ASOF);
  const lines = actionPlan(a, fixFromWithin(a), ENGINEERS_2026, ASOF);
  assert.equal(lines[0], "E1: short by 3, in force since 2026-06-30 (139 days).");
  assert.equal(lines[1], "Raise s1 by SAR 1000 a month in GOSI.");
  assert.equal(lines[2], "Then replace 2 non-Saudi(s), or hire 3 Saudi engineer(s) without replacing anyone.");
  const onDay = actionPlan(a, fixFromWithin(a), ENGINEERS_2026, "2026-06-30");
  assert.equal(onDay[0], "E1: short by 3, in force since 2026-06-30 (0 days).");
  const before = actionPlan(a, fixFromWithin(a), ENGINEERS_2026, "2026-06-01");
  assert.equal(before[0], "E1: short by 3, applies from 2026-06-30, 29 days left.");
});

Les 16 tests passent et tsc --strict ne signale rien. Si vous changez la lecture par défaut de l'étape 1, c'est le test du dénominateur qui doit échouer, et il vous montre l'effet : 10 ingénieurs dont 3 Saoudiens, un seul qualifié, demandent 2 remplacements selon notre lecture et 1 selon l'autre.

Dépannage

Le ministère affiche un taux plus bas que votre module. Vérifiez d'abord l'accréditation. Le ministère lit le registre du SCE ; votre export peut encore marquer comme accrédité un ingénieur dont l'adhésion a expiré.

Votre module compte moins d'ingénieurs que Qiwa. Quelqu'un porte l'un des 46 codes sans apparaître comme ingénieur dans votre export. Comparez par code, pas par libellé de poste.

Un ingénieur saoudien à exactement 8 000 SAR est signalé en échec. Le guide dit « pas moins de » 8 000 : 8 000 compte. Vérifiez que vous comparez le salaire soumis à cotisation GOSI et non le seul salaire de base, et que la valeur n'est pas arrondie à la baisse quelque part dans l'export.

Le chiffre de recrutement paraît trop élevé. C'est le coût de ne remplacer personne. Chaque recrutement augmente aussi l'exigence : à 30 %, environ une embauche sur trois ne fait que suivre.

Prochaines étapes

Conclusion

La décision 93483 est courte, mais elle transforme une question d'effectif en trois : combien d'ingénieurs vous avez, combien des Saoudiens parmi eux sont accrédités, et combien sont déclarés à au moins 8 000 SAR à la GOSI. Le module répond aux trois à partir de données que vous détenez en grande partie, ajoute la colonne qui vous manque probablement, l'expiration de l'accréditation, et place la solution la moins chère en premier : vos propres salariés, avant tout remplacement ou recrutement.

Si vous voulez ce contrôle branché sur votre système RH et exécuté avant chaque embauche et chaque changement de salaire, réservez une séance de diagnostic gratuite et nous examinerons vos données au regard du guide avec vous.

Envoyez-nous votre projet

Nous répondons sous un jour ouvré.