Guides pratiques › Écrire un générateur

Guides pratiques

Vos propres générateurs

Un générateur transforme le modèle en fichiers : du code, de la configuration ou des documents. archec fournit environ vingt-cinq cibles intégrées, comme C, Rust, Go, DBC, ARXML et ROS 2 (archec gen --list). Votre entreprise peut en avoir besoin d’autres : sa propre glue d’exécution, la configuration d’un banc de test, un document dans sa propre mise en page. Une déclaration generator en ajoute une, et vous la lancez comme une cible intégrée.

Un premier générateur#

Voici un modèle avec deux messages, et un générateur fait d’un seul gabarit :

message BRAKE_CMD "Brake command" {
  field force:  float32 [N]
  field urgent: bool
}
message SPEED "Speed" {
  field kmh: float32
}
system Car {
}

generator msgs "Message structs" {
  templates "generators/msgs"
}

Le dossier generators/msgs/ contient un seul fichier, messages.h. Ce qui se trouve entre {{ et }} est rempli à partir du modèle :

/* {{ project.name }}: its messages. */
{{#each messages}}
typedef struct {
{{#each fields}}
  {{ type | ctype }} {{ id | snake }};
{{/each}}
} {{ id | snake }}_t;
{{/each}}

Lancez-le :

archec gen main.arche --target msgs -o generated
  generated/msgs/messages.h

generated/msgs/messages.h contient :

/* car: its messages. */
typedef struct {
  float force;
  bool urgent;
} brake_cmd_t;
typedef struct {
  float kmh;
} speed_t;

Ici, le projet se trouve dans un dossier nommé car : le nom du projet est celui de son dossier.

Pour aller plus vite, archec generator new écrit un générateur qui fonctionne déjà :

archec generator new rte --templates     # or --script, or --command
✓ generator rte (templates) → main.arche, generators/rte/messages.md, generators/rte/parts.txt
  archec gen main.arche --target rte    ·    archec generator model main.arche    ·    docs/generators.md

Comment fonctionne un générateur#

Un générateur lit le modèle de générateur et renvoie des fichiers. Le modèle de générateur, c’est le projet sous forme de JSON simple. archec generator model main.arche l’affiche.

Un générateur prend l’une de ces trois formes :

  • des gabarits : un dossier de fichiers texte avec des emplacements {{ }} ;
  • un script : une fonction JavaScript ou TypeScript ;
  • une commande : un programme dans n’importe quel langage, qui lit le modèle en JSON.

Les trois formes lisent le même modèle.

Un générateur a deux cousins :

  • un importer lit un fichier d’un autre outil et le fait entrer dans arche-lang ;
  • un exporter écrit le modèle sous forme de fichier d’un autre outil.

Les trois peuvent être réunis dans un plugin : un dossier fourni par le projet, par un paquet du Store ou par archec lui-même (plugins).

Les générateurs déclarent leurs options, peuvent partir d’un autre générateur (from) et peuvent s’exécuter après une cible intégrée pour modifier ses fichiers (les hooks). Les sections suivantes présentent chacun de ces points.

Le modèle de générateur#

Le modèle de générateur, c’est le projet sous forme de JSON simple, en version 1. Son schéma est schemas/generator-model.v1.json. Tous les noms y sont résolus et toutes les valeurs calculées. Ce qu’un générateur devrait sinon calculer lui-même l’est déjà :

Clé Ce qu’elle contient
project name, version, root
options les options du générateur, telles que le projet les fixe
messages id, label, fields (type, unité, plage), layout : bytes et les signals sur le fil — scalaire, décalage, unité, libellé et, pour un message doté d’un format de trame, ses bits, son ordre, son facteur d’échelle, son décalage, sa somme de contrôle
types kind (type, enum, struct, union), literals avec leurs valeurs, fields, underlying ; exception: true pour une exception ; native pour un type … native : son name en c, cpp, rust, go, avec l’include ou l’import qui le déclare
exceptions les identifiants des types exception
interfaces operations (params avec leur direction quand elle vaut out ou inout, result, oneway, raises), attributes (type, readonly), extends, messages
constants, parameters les valeurs calculées (value) et telles qu’écrites (source)
components les définitions : ports (direction, type, messages envoyés et reçus, corps onReceive et onDeadline, interfaces qu’il fournit (provides) et requiert (requires), son pattern, topic et topicParts, service, dataflow, les handlers qui traitent ce qu’il reçoit : { message, function }), functions (un corps en langage d’action avec ses versions Python, C, C++, Rust et Go ; params avec leur direction), variables, machine (états, transitions avec déclencheur, garde, action), lifecycle (les corps init, start, stop et release), parts, props, les requirements qui le tracent
systems, parts les systèmes — chaque lien avec son pattern et ce qu’en disent ses deux extrémités et lui-même (topic, service, dataflow, timeout, async, deferred) — et chaque part par son chemin (Car.brakes.mcu), avec sa définition, les params avec lesquels elle est créée, les values initiales de ses variables et celles qu’elle redéfinit (overrides)
requirements identifiant, libellé, texte et toutes les propriétés
deployment le déploiement actif (ou --deployment) : binaries avec leur processeur (chemin, libellé, carte, OS) et leurs threads (période, priorité, parts et fonctions qu’ils exécutent, le step appelé à chaque période : part.fn), buses avec les frames CAN que chacun transporte (identifiant, message, émetteur, destinataire, fd, periodNs tiré de la period du message), containers
deployment (exécution et mémoire) pour chaque thread, son process, sa queue, son affinity et les ports qu’il exécute ; pour chaque binaire, ses options (celles du générateur en cours : celles du projet, puis le bloc options <generator> { … } du binaire), les memories de son processeur et ses processes avec leurs propres options ; allocators (type, blockBytes, blocks, alignement, mémoire, parent, binaire ou processus qui les contient) ; placements : chaque part qui s’exécute, son execution (active, passive, protected), son thread, son processus, sa memory par usage (hrt, lrt, saved, tmp, comm) et ses ports (le thread qui en exécute un, sa mémoire, son buffering). Voir Déploiement
components[].algorithm un kind algorithm : ses stereotypes, ses parameters (instanciation, configuration, internes), son workingMemory, les fonctions cycle qu’il possède, les metrics qu’il publie et lit ; pour un composite, son composite (L1, LN), ses roles (définition, stéréotypes, after, arguments, configuration), ses delegations et ses connections. Le buffering d’un port
metrics les messages de kind metric : leur paquet, leurs champs, et le topic sur lequel chaque part les publie

Chaque élément possède at : le fichier et la ligne où il est écrit. Quand un générateur trouve un problème, il le signale sur l’élément. archec affiche le problème à cette ligne, et VS Code le montre dans Problems.

  • Un élément placé dans un paquet possède package.
  • Un élément qui a des lignes attr key = value les retrouve dans attrs. Un attr contient ce que le langage ne sait pas dire, comme l’identifiant ou le nom donné par un autre outil. Un exporteur les réécrit, et peut garder un identifiant attr comme identifiant propre de l’élément.
  • Les parts, threads, binaires, processus, allocateurs, mémoires et placements ont aussi des attrs.

Le modèle ne fait que s’enrichir au sein de la version 1 : ajouter un champ ne change pas de version. Un générateur indique la version qu’il lit avec api 1.

Corps en C, Rust et Go#

Un corps, c’est le code d’une fonction, du onEnter ou du onExit d’un état, du onReceive ou du onDeadline d’un port, ou du lifecycle d’un composant. Dans le modèle, chaque corps possède :

  • source, tel qu’écrit ;
  • python ;
  • c, cpp, rust et go, produits par les mêmes traducteurs que les cibles intégrées. cpp est écrit comme l’écrit --target cpp (this->n).

Un corps écrit en Python est lui aussi traduit quand le langage d’action peut exprimer la même chose, comme le font les cibles C et Go. Sinon, c, rust et go sont absents.

La traduction ne peut pas connaître votre runtime. Ce que le corps fait vers l’extérieur est donc écrit comme l’écrivent les cibles intégrées, et c’est à votre générateur de fournir ces noms :

Le corps contient c rust go
une variable n self->n self.n self.n
send tx GO { … } pump_send_tx(self, &(go_t){ … }); (pump_send_tx_go quand le port envoie plusieurs messages) _out.send_tx(Go { … }).await; self.Send("tx", GO{…})
goto Running pump_goto(self, PUMP_RUNNING); self.sm.goto_name("Running"); self.Goto(Pump_Running)
state == Running pump_in(self, PUMP_RUNNING) self.sm.state.is_in("Running") self.In(Pump_Running)
un appel de la fonction f() de la part pump_f(self) self.f(_out).await self.F()
un appel à travers un port, brake.apply(2.5) comme l’écrit la cible C _out.call_brake_apply(2.5).await comme l’écrit la cible Go
wait 10ms, now() arche_wait_ns(…), arche_now_ns() embassy_time::Timer::after(…), Instant::now() archeWait(…), archeNow()
log a, b arche_log("%g %ld", …) un commentaire archeLog(a, b)

Les types sont nommés comme les nomment les cibles : go_t en C, Go en Rust, GO en Go. Les durées sont en nanosecondes (uint64_t, u64, int64). Dans une part sans machine à états, un goto est écrit en commentaire.

Le modèle suffit. examples/generators/dbc.js ne lit rien d’autre que le modèle, et écrit les mêmes fichiers DBC que --target dbc, à l’octet près. Les tests le vérifient.

Gabarits#

Un générateur à gabarits est un dossier de fichiers texte. Chaque fichier est un gabarit : ce qui se trouve entre {{ et }} est rempli à partir du modèle. Le fichier écrit porte le nom du gabarit, sans le suffixe .tpl s’il en a un.

/* {{ project.name }}: its messages. */
{{#each messages where layout.bytes}}
typedef struct {
{{#each fields}}
  {{ type | ctype @root.options.prefix }} {{ id | snake }};{{#if unit}} /* {{ unit }} */{{/if}}
{{/each}}
} {{ @root.options.prefix }}{{ id | snake }}_t;
{{/each}}
Écrit Effet
{{ name }}, {{ a.b }} une valeur : celle de l’élément courant ; sinon celle de la boucle qui l’entoure, et ainsi de suite jusqu’au modèle
{{ .name }}, {{ ../name }}, {{ @root.name }} celle de l’élément courant seulement ; celle de la boucle qui l’entoure ; celle du modèle
{{ x | snake | default "none" }} des filtres, appliqués l’un après l’autre
{{#each list where field=a,b and other}} … {{else}} … {{/each}} une fois par élément (@index, @number, @first, @last) ; {{else}} quand il n’y en a aucun
{{#if cond}} … {{else}} … {{/if}}, {{#unless cond}} field, field=a,b, field!=a, field~text, field>3, reliés par and
{{#with element}} … {{/with}} à l’intérieur d’un seul élément
{{#file "src/{{ id | snake }}.c"}} … {{/file}} un fichier à part — dans un #each, un par élément
{{> name}} un autre gabarit du dossier, dont le nom commence par _ (un partiel, pas un fichier)
{{ keep }} une fois écrit, le fichier est à vous : archec ne l’écrase plus
{{#region "{{ id }}.init"}} … {{/region}} une région USER CODE. Son contenu sert de valeur par défaut. Le code que le développeur y place est conservé chaque fois que le fichier est réécrit (régénération). Le style de commentaire suit le nom du fichier, ou bien "c", "line" ou "hash" placé après l’identifiant. "user-code" écrit des marqueurs // -- start of user code: name (régénération).
{{! … }}, {{!-- … --}} un commentaire ; le second peut contenir {{ }}

Une ligne qui ne contient qu’une balise de bloc ({{#each …}}, {{/if}}, {{else}}…) ne laisse rien derrière elle, pas même son saut de ligne. Un gabarit de code se lit donc comme le code qu’il produit.

Les filtres transforment une valeur. Les voici :

  • noms : snake, camel, pascal, kebab, constant (BRAKE_CMD), upper, lower ;
  • types : ctype, rusttype, pytype donnent un type du modèle dans ce langage, en suivant ses alias. ctype "acme_" écrit un type déclaré sous la forme acme_name_t ;
  • valeurs : hex (hex 4 → 0x00FF), json, quote, default "x" ;
  • listes : join ", ", map "id", sort "id", length, first, last ;
  • texte : indent 4, replace "a" "b", trim, pad 12.

Un argument de filtre écrit sans guillemets est un nom lu dans le modèle (ctype @root.options.prefix).

Un script#

generator can-db "CAN databases" { script "dbc.js"; needs deployment }
module.exports = function generate(model, ctx) {
  const files = {};
  for (const m of model.messages) {
    if (m.layout.problem) { ctx.warn(m, `${m.id} has no fixed layout`); continue; }
    files[`${ctx.filters.snake(m.id)}.txt`] = m.layout.signals.map((s) => s.name).join('\n');
  }
  return { files };   // { "path": "text" }, or { "path": { text, keep: true } }
};

export default function generate… fonctionne aussi. Le script renvoie ses fichiers ; il ne les écrit pas. ctx fournit :

  • options ;
  • readFile(rel) : un fichier du dossier du script ;
  • render(template, data) : le langage de gabarits ;
  • region(id, default, style) : une région USER CODE autour du code par défaut, conservée quand le fichier est réécrit (régénération). style vaut "c", "line", "hash" ou un nom de fichier. "user-code" écrit les marqueurs // -- start of user code: <name> ; le nom de fichier passe alors en cinquième argument ;
  • filters ;
  • note(msg) ;
  • warn(where, msg) et error(where, msg). where est un élément du modèle, un chemin ou un identifiant, ou { file, line } ;
  • builtin(target, { deployment, trace, monitors }) : les fichiers d’une cible intégrée, sous la forme { "path": "text" } (voir plus bas) ;
  • pour un hook (after c) : target, files ({ "path": "text" }) et kept (les chemins marqués keep).

En TypeScript#

script "gen.ts" (ou .mts, .cts) est du TypeScript. archec retire les types et exécute le reste comme n’importe quel script.

  • Node 22.13, 23.2 et les versions suivantes retirent eux-mêmes les types. Les lignes restent à leur place : la ligne d’une erreur est donc celle du fichier .ts. Un enum ou un namespace est réécrit, et ses lignes peuvent bouger.
  • Sur une version plus ancienne de node, esbuild ou typescript s’en chargent, si le projet ou archec a l’un des deux installé. Sinon, l’erreur le dit.

Le fichier generator-model.v1.d.ts donne les types du modèle et de ctx. archec generator types l’écrit. archec generator new rte --script --ts écrit un script et ce fichier côte à côte :

import type { GeneratorContext, GeneratorModel, GeneratorResult } from './generator-model.v1';

export default function generate(model: GeneratorModel, ctx: GeneratorContext): GeneratorResult {
  const files: Record<string, string> = {};
  for (const m of model.messages) files[`${m.id}.txt`] = m.fields.map((f) => f.id).join('\n');
  return { files };
}

export function generate fonctionne aussi. archec se contente de retirer les types ; il ne les vérifie jamais. Lancez tsc --noEmit dans votre éditeur ou en CI pour les vérifier.

Le bac à sable#

Le script s’exécute dans un bac à sable : du JavaScript pur, sans rien de node ni de npm. Il n’a pas de process, pas de système de fichiers au-delà de son propre dossier, et pas de réseau. Un script qui boucle sans fin est arrêté au bout de 30 s.

Un script peut tenir en plusieurs fichiers. import { view } from './core/view' (ou require('./core/view')) charge l’un de ses propres modules, .ts ou .js, avec export comme d’habitude. Un module vient du dossier du script ; dans un plugin ou une bibliothèque, il peut venir de n’importe où à l’intérieur. Un module situé en dehors, ou un module de node ou de npm (import fs from 'fs'), est une erreur.

Une commande, dans n’importe quel langage#

generator icd-md "ICD" { command "python3 icd.py"; output "docs" }

La commande s’exécute dans le dossier du fichier où le générateur est déclaré. Elle lit le modèle en JSON sur son entrée standard (stdin). Elle écrit ce JSON sur sa sortie standard (stdout) :

{ "files": [{ "path": "icd.md", "text": "…", "keep": false }],
  "notes": ["9 messages"],
  "errors": [{ "where": "BRAKE_CMD", "message": "…", "severity": "warning" }] }

Ce qu’elle écrit sur stderr est affiché sous forme de notes. C’est une erreur quand la commande se termine en erreur, ou quand elle écrit autre chose que ce JSON.

Options, et un générateur à partir d’un autre#

options { … } est un enregistrement, et le champ options du modèle le contient. --option prefix=acme_ modifie une option le temps d’une exécution. Pour d’autres valeurs à chaque fois, écrivez un autre générateur à partir du premier, avec from :

generator rte-bench "RTE for the bench" from rte { options { prefix "bench_" } }

Une option que le premier générateur n’a pas déclenche un avertissement (generator-option).

Options déclarées, avec leur type#

Un générateur peut déclarer ses options. C’est surtout utile pour un générateur fourni par une bibliothèque :

generator rte "Our RTE glue" {
  templates "generators/rte"
  option prefix "The prefix of the C names" { type string; default "acme_" }
  option os "The RTOS it runs on" { type string; values posix, freertos; default posix }
  option depth "Queue depth" { type int; default 8 }
}
  • type vaut string, int, float, bool ou list. Sans type, toute valeur est acceptée.
  • values donne les seules valeurs que l’option accepte.
  • default est la valeur quand rien ne la fixe. Le champ options du modèle la contient.

archec check vérifie alors ce que fixe un générateur qui part de lui avec from (generator-option) :

  • une option qu’il ne déclare pas donne un avertissement ;
  • une valeur d’un autre type, ou absente de ses values, donne une erreur sur la valeur.

--option est lu selon le type de l’option et vérifié de la même façon. --option prefix=12 donne la chaîne "12" ; --option list=a,b donne une liste.

archec gen --list liste les options de chaque générateur. Dans VS Code, options { } complète leurs noms puis leurs valeurs, et le survol de l’une d’elles indique ce qu’elle est.

Les fichiers d’une cible intégrée#

Un générateur veut souvent ce qu’écrit une cible intégrée, avec un petit supplément. Par exemple, le C de --target c avec un fichier de glue, ou le DBC dans une autre mise en page. Le générateur lit les fichiers de la cible au lieu de les réécrire.

Un script appelle ctx.builtin :

module.exports = function generate(model, ctx) {
  const c = ctx.builtin('c');                 // { "c/arche_types.h": "…", … }
  const files = {};
  for (const [p, text] of Object.entries(c)) files[p] = `#pragma once_ours\n${text}`;
  files['c/glue.c'] = ctx.render('…', model);
  return { files };
};

Un gabarit ou une commande nomme les cibles qu’il lit avec builtins. Le champ builtins du modèle contient alors leurs fichiers, sous la forme { "c": [{ "path", "text", "keep" }] } :

generator listing "What C writes" { templates "listing"; builtins c, dbc }
{{#each builtins.c}}{{ path }}: {{ text | length }} characters
{{/each}}

Ce sont les fichiers que la cible écrit avant tout hook, pour le déploiement de l’exécution (--deployment). freertos, zephyr, posix et components ne sont pas disponibles, car c’est Arche qui les écrit.

Hooks : après une cible#

Un hook est un générateur qui s’exécute après une cible (after) et modifie ses fichiers. Par exemple, une entreprise place son en-tête de licence sur chaque fichier qu’elle livre. Elle n’a pas besoin pour cela d’un générateur complet, ni d’une retouche à la main après chaque exécution. Elle écrit un hook :

generator license "Our license header" { script "license.js"; after c, go }
module.exports = function (model, ctx) {
  const files = {};
  for (const [p, text] of Object.entries(ctx.files))
    if (/\.[ch]$/.test(p)) files[p] = `/* (c) ACME. All rights reserved. */\n${text}`;
  files['LICENSE'] = ctx.readFile('LICENSE');
  return { files };
};

archec gen --target c écrit alors les fichiers de la cible en passant par le hook. Un hook ne renvoie que ce qu’il modifie :

  • un chemin avec son texte remplace ce fichier, ou l’ajoute ;
  • un chemin avec null supprime le fichier ;
  • un fichier qu’il ne nomme pas reste tel quel.

Un hook de type commande lit la même chose dans le champ after du modèle : { "target": "c", "files": [{ "path", "text", "keep" }] }. Pour supprimer un fichier, il écrit { "files": [{ "path": "c/x.h", "text": null }] }.

  • Ordre : les hooks d’une cible s’exécutent dans l’ordre où ils sont écrits. Un hook placé dans un fichier inclus compte à l’endroit où ce fichier est inclus. Chaque hook travaille sur les fichiers que le précédent a laissés. archec gen --list montre les hooks (after c).
  • Chemins : ils sont tels qu’écrits sous -o (c/arche_types.h), et non sous un dossier propre au hook.
  • keep : un fichier marqué keep est à vous une fois écrit. Quand la cible marque un fichier keep, il reste marqué si un hook le modifie. Ce que le hook lui fait ne compte qu’à la première écriture du fichier. ctx.kept liste ces fichiers.
  • Un hook est un script ou une commande, pas des gabarits.
  • Un hook ne s’exécute qu’à travers sa cible. archec gen --target license le signale. La cible peut être n’importe quelle cible intégrée, ou l’un des générateurs du projet. --no-hooks laisse les hooks de côté.
  • Le hook d’une bibliothèque ne s’exécute qu’une fois approuvé, comme ses autres scripts.

Où vont les fichiers#

Les fichiers vont dans <-o>/<output>/ :

  • par défaut, <output> est l’identifiant du générateur ;
  • output "dir" choisit un autre dossier ;
  • output "." écrit directement dans le dossier -o.

Un chemin qui sortirait de ce dossier est refusé. Un fichier marqué keep est écrit une fois, puis plus jamais. --check indique ce qui changerait et n’écrit rien.

Tester un générateur#

Commencez par approuver la sortie telle qu’elle est :

archec generator test main.arche rte --update
✓ 2 file(s) approved → expected/rte

Ensuite, comparez la sortie avec les fichiers approuvés :

archec generator test main.arche rte
✓ rte: 2 file(s) as approved

En cas d’écart, la commande liste les fichiers manquants, modifiés (à la première ligne qui diffère) et nouveaux.

Les fichiers approuvés sont rangés dans expected/<id>/, à côté de la déclaration. Committez-les. Une modification du modèle ou du générateur apparaît alors comme une différence en CI.

Depuis une bibliothèque, depuis le Store#

Une bibliothèque peut fournir des générateurs. Leurs chemins sont relatifs aux fichiers de la bibliothèque. Un paquet du Store peut être de type generator. uses acme-gen "^1.0" et include "acme-gen/generators.arche" font de ses générateurs des cibles du projet. Un paquet de type plugin n’a pas besoin d’include : uses suffit, et il peut aussi apporter des importeurs et des exporteurs (plugins).

Les gabarits d’une bibliothèque s’exécutent tels quels, car ils n’exécutent aucun code. Le script ou la commande d’une bibliothèque s’exécute sur la machine de la personne qui construit le projet. Il ne s’exécute donc qu’une fois approuvé par le projet :

archec generator approve main.arche rte   # lists the code it runs, then records it

L’approbation est enregistrée dans arche.lock, avec l’empreinte actuelle de la bibliothèque. arche.lock est commité et relu avec le reste. Si la bibliothèque change, le générateur est refusé jusqu’à une nouvelle approbation.

  • --revoke retire une approbation.
  • archec audit liste le JavaScript d’un générateur, avec le reste du code que le projet fait entrer.

Le bac à sable n’est pas une frontière de sécurité : le vm de node n’en est pas une. C’est pourquoi l’approbation est ce qui décide.

Ce qui est vérifié#

Code
generator plusieurs formes ou aucune ; un dossier ou un fichier qui n’existe pas ; un from vers un générateur qui n’existe pas, ou une chaîne qui tourne en rond ; une api que cet archec ne fournit pas ; un builtins ou un after qui nomme autre chose qu’une cible ; un hook fait de gabarits
generator-option une option que ni lui, ni le générateur dont il part, ne déclare (un avertissement) ; une valeur d’un autre type, absente des values de l’option, ou une valeur par défaut qui ne correspond pas à son type (des erreurs)

Dans VS Code#

  • Exécution : une lentille ▶ Generate se trouve au-dessus de chaque générateur. Generate code… liste les générateurs du projet après les cibles intégrées. Ce que signale un générateur apparaît dans Problems, à la ligne de l’élément. La lentille d’un hook (▶ Generate c) exécute sa cible, et Generate code… exécute une cible en passant par ses hooks.
  • Écriture : après from, la complétion propose les générateurs du projet. Dans options { }, elle propose les options déclarées, puis leurs valeurs ; le survol indique à quoi sert chacune. Dans un fichier d’un dossier templates :
    • {{ propose les noms du modèle ;
    • {{# propose les blocs ;
    • | propose les filtres ;
    • le survol de chacun d’eux indique ce qu’il est.

Limites#

  • Un hook est un script ou une commande. Un hook fait de gabarits est signalé (generator).
  • Un hook déclaré par un plugin intégré ne s’exécute pas.
  • builtins ne peut pas lire freertos, zephyr, posix ni components : c’est Arche qui les écrit, pas archec.
  • Le bac à sable n’est pas une frontière de sécurité. Le script ou la commande d’une bibliothèque ne s’exécute qu’une fois approuvé, et c’est l’approbation qui vous protège.
  • archec retire les types d’un script TypeScript mais ne les vérifie jamais.
  • Le C, le Rust et le Go d’un corps nomment les fonctions de votre runtime comme le font les cibles intégrées ; c’est votre générateur qui les fournit. Un corps Python que le langage d’action ne peut pas exprimer n’a ni c, ni rust, ni go.