L’Arche Store
L’Arche Store sert à partager ce que vous écrivez en arche-lang. Un projet y prend un paquet en une seule commande, et archec vérifie le paquet avant d’écrire quoi que ce soit. Vous pouvez aussi publier vos propres paquets, ou faire tourner votre propre store.
Avant d’écrire vous-même un type, une unité, une carte ou un contrôleur,
regardez sur les étagères : archec shelf liste ce qui est prêt à
prendre.
Un premier paquet#
Un store peut être un simple dossier. Créez-en un, publiez-y une petite bibliothèque, puis ajoutez cette bibliothèque à un projet.
lib/library.arche dit au store ce qu’il doit savoir :
library blinker "LED blinker" {
description "A component that blinks an LED."
kind driver
owner demo
version "0.1.0"
license "Apache-2.0"
export-control none
}
component Blinker "Blinker" {
var on: bool = false
}archec store init store
archec store publish lib --store store
! no `archec` range: say which archec versions read it (`archec ">=0.10"`)
! no `edition`: archec reads it as the oldest; `edition "0.12"` says which spellings it uses
! no README.md: the card shows only what archec reads from the model
a signing key for demo was made: ~/.arche/keys/demo.pem — keep it, it is how the store knows you
publisher demo registered with key d9ded01eb8928734
✓ demo/blinker 0.1.0 → store
Ensuite, dans un dossier de projet dont le main.arche contient un bloc
project "…" { … } :
archec add main.arche demo/blinker --store ../store
✓ demo/blinker 0.1.0 (community) → .arche/store/blinker@0.1.0
no code: model only
wrote: uses blinker "^0.1"
✓ arche.lock updated
now `include "blinker/…"` the files you need
Le bloc du projet contient maintenant uses blinker "^0.1", et arche.lock
enregistre la version, son empreinte et la clé qui l’a signée.
Ce qu’un paquet peut contenir#
- des architectures : des modèles complets, à réutiliser ou à étendre ;
- des pilotes : un composant et son code ;
- des spécifications : exigences, interfaces, ICD ;
- des cartes ;
- des modèles de projet : des projets de départ ;
- des kits d’interface : un thème pour les écrans du produit (voir plus bas) ;
- des bibliothèques de parts et de types ;
- des générateurs : vos propres générateurs de code (voir
generators.md). Un script ou une commande apporté par un
générateur ne s’exécute qu’une fois enregistré par
archec generator approve. - des plugins : générateurs, importeurs et exporteurs réunis (voir plugins.md).
archec new my-project --from owner/name copie plutôt un paquet dans un nouveau
projet. La copie vous appartient, vous la modifiez à votre guise, et
derived-from indique d’où elle vient (voir new.md).
Prendre un paquet#
archec store search can fd --kind driver
archec add main.arche acme/can-fd@^1.2
Le store utilisé est le store hébergé, https://store.arche-lang.xyz, sauf si vous en indiquez un autre. archec regarde, dans cet ordre :
--store <where>;ARCHE_STORE;- ce que
archec store use <folder | git URL | https URL>a écrit dans~/.arche/config.json.
ARCHE_STORE= (définie, mais vide) tient archec à l’écart du store hébergé.
archec add prend la version la plus récente de l’intervalle que cet archec sait
lire. Il vérifie ensuite que :
- l’archive est bien celle que le store a publiée (son hash) ;
- son éditeur l’a signée, avec une clé que le store associe à ce propriétaire (Ed25519) ;
- ses fichiers sont bien ceux qui ont été signés (leur empreinte) ;
- le projet accepte son éditeur. Le
trustdu projet dit lesquels :trust verifiedn’accepte que les éditeurs vérifiés (fabricants de cartes, projets connus) ;trust reviewedaccepte aussi les paquets qu’un relecteur du store a lus ;trust community(par défaut) accepte tout le monde.
- quand la version a un bundle Sigstore, que ce bundle
est bien celui de cette archive et nomme l’identité que le store a
enregistrée ; si cosign est installé, que cosign le vérifie. Un projet qui a
sigstoredans sontrust(trust reviewed, sigstore) ne prend que les paquets dont cosign a vérifié le bundle.
Si une vérification échoue, rien n’est écrit. Sinon, archec :
- décompresse le paquet dans
.arche/store/<name>@<version>/; - écrit
uses <name> "^1.2"dans le bloc du projet ; - enregistre l’identifiant du store, la version, l’empreinte et la clé de
signature dans
arche.lock; - liste le code qu’apporte le paquet. Ce code arrive dans le firmware par
archec gen: lisez-le.
Commitez arche.lock, pas .arche/. Sur un checkout tout neuf, archec store fetch main.arche reprend les versions verrouillées et les vérifie par rapport
au fichier de verrouillage.
archec audit main.arche # every piece of code, by where it came from
archec store outdated main.arche # newer versions, and yanks
archec store diff acme/can-fd 1.2.0 1.3.0 # what the model gained, lost or changed
Chaque page de paquet montre le même diff, la version la plus récente face à
la précédente (et un sélecteur pour les paires plus anciennes), ce qu’utilise
le paquet et ce qui l’utilise. Elle prévient quand il utilise un paquet que le
store n’a pas, ou un intervalle dont toutes les versions sont retirées.
archec store deps <index> vérifie cela sur tout le store. Chaque propriétaire
a une page (u/<owner>.html) avec ses paquets et ses collections.
Les fichiers générés indiquent d’où vient leur code :
/* … Its model and code: from store package acme/can-fd 1.2.0 (sha256-…, community). */.
Publier#
Un paquet est un dossier de bibliothèque. Son library.arche dit ce dont le
store a besoin :
library can-fd "CAN-FD driver for STM32G4" {
description "FDCAN frames: classic CAN and CAN FD, bit timing from the clock."
version "1.2.0"
owner acme
kind driver
license "Apache-2.0"
export-control none
archec ">=0.10"
edition "0.12"
keywords can, stm32, automotive
derived-from "arche/nucleo-g474re@^0.1"
}
archec store check . # what would be refused, warned about, or held
archec store card . -o card.html
archec store publish .
Sur le premier exemple, archec store check affiche :
! no `archec` range: say which archec versions read it (`archec ">=0.10"`)
! no `edition`: archec reads it as the oldest; `edition "0.12"` says which spellings it uses
! no README.md: the card shows only what archec reads from the model
✓ demo/blinker 0.1.0: 1 file(s), 0.2 KiB — ready to publish
--dry-run empaquette le paquet et le compile comme le fait le validateur du
store, sans rien envoyer. Le paquet est décompressé seul, et ce qu’il utilise est
pris dans le .arche/store/ du dossier.
Certains fichiers ne font jamais partie d’un paquet : les fichiers cachés (qui
commencent par un point), et ce qu’archec construit à la racine d’un dossier
(generated/ et arche-out/). Un projet peut donc être son propre paquet
(archec new --kind library).
La première publication crée votre clé de signature dans
~/.arche/keys/<owner>.pem, et enregistre le propriétaire avec cette clé.
Conservez ce fichier : c’est grâce à lui que le store vous reconnaît.
Une version publiée ne change jamais. Pour en retirer une, lancez
archec store yank acme/can-fd@1.2.0 --reason "…". Dès lors, archec add ne la
prend plus, et archec store outdated prévient les projets qui l’utilisent.
Le langage des handlers#
archec store check indique aussi le langage des handlers du paquet (voir
handlers.md). C’est la propriété handlers du projet. Si elle est
absente, archec regarde le code :
- un fichier
.tsou un bloc```tssignifie TypeScript ; - un fichier
.pyou un bloc```pythonsignifie Python ; - des corps tous en
```archerelèvent du langage d’actions, qu’Arche exécute comme du TypeScript.
Le store enregistre ce langage. La fiche du paquet l’affiche (Handlers), et la liste des paquets l’affiche à côté du type.
Le validateur lit lui-même le TypeScript : il efface les types, si bien qu’il n’y
a rien à installer. Il attribue au paquet un badge, typescript: pass, ou la
première ligne qu’il n’arrive pas à lire. Il attribue un badge aux paquets Python
de la même façon.
La page Try it exécute le TypeScript dans le navigateur du visiteur, comme elle exécute le langage d’actions. Rien n’est chargé pour cela : ni Pyodide, ni compilateur.
Badges#
Le validateur compile chaque paquet comme le ferait un projet qui l’utilise.
C’est le badge archec. Une fois le paquet compilé, il ajoute les badges
ci-dessous. Chacun vaut pass, fail, ou skip avec la raison. Un outil qui
n’est pas installé là où tourne la vérification donne un skip, jamais un pass.
| Badge | Ce qu’il vérifie | Ignoré quand |
|---|---|---|
own tests (tests) |
Les cas de test du paquet lui-même, exécutés sur le simulateur du navigateur dans node (comme archec test --sim web), et ses exigences formelles quand NuSMV ou nuXmv est installé. Un cas que le simulateur du navigateur ne peut pas exécuter (une étape en Python) est compté à part, pas comme un échec. |
le paquet n’a ni cas de test ni exigence formelle |
style (vet) (vet) |
Les constats qu’archec vet signale sur les fichiers du paquet lui-même. Il échoue en donnant leur nombre. |
jamais |
MISRA C (misra) |
L’addon MISRA C:2012 de cppcheck (cppcheck --addon=misra) sur les fichiers C du paquet, et sur le C qu’écrit archec gen --target c quand le paquet a un comportement. |
cppcheck ou son addon n’est pas installé. Il n’y a pas de badge quand le paquet n’a pas de C du tout. |
clippy (clippy) |
cargo clippy --offline sur la crate du paquet lui-même (un Cargo.toml), ou à défaut sur la crate qu’écrit archec gen --target embassy pour son déploiement. Un avertissement le fait échouer. |
cargo ou clippy n’est pas installé, ou cargo ne peut pas construire la crate hors ligne (une dépendance n’est pas dans son cache, une cible n’est pas installée). Il n’y a pas de badge quand il n’y a pas de Rust. |
Le store hébergé calcule les badges à la publication d’une version.
archec store test <index> --write les recalcule pour chaque paquet. Chaque
outil tourne avec une limite de temps : ARCHEC_STORE_TIMEOUT secondes, 120 par
défaut. Un outil qui dépasse ce temps est arrêté, et son badge est un skip qui
le dit. Les cas de test cessent d’être exécutés une fois ce temps écoulé. Le
cache de construction de cargo est partagé entre les vérifications :
ARCHEC_STORE_CARGO_TARGET, par défaut arche-store-cargo-target dans le
dossier temporaire.
La page du paquet affiche les badges en anglais et en français. La raison ou les premiers constats s’affichent au survol d’un badge.
Provenance Sigstore#
Votre clé dans ~/.arche/keys signe chaque paquet. Un paquet peut aussi
porter une provenance Sigstore. C’est un bundle que cosign sign-blob produit
sur le .archepkg. Il dit qui a signé le paquet : un workflow GitHub Actions,
ou une adresse e-mail. Cette identité est dans le certificat émis par Fulcio,
et la signature est consignée dans Rekor.
archec store pack . -o out/
cosign sign-blob --bundle can-fd.sigstore.json out/acme-can-fd-1.2.0.archepkg
archec store publish . --sigstore can-fd.sigstore.json
Signez l’archive qu’écrit archec store pack : le même dossier s’empaquette
toujours en les mêmes octets. Si le bundle signe d’autres octets, la
publication est refusée.
Le store garde le bundle à côté de l’archive
(archives/<owner>/<name>/<version>.archepkg.sigstore.json). Il enregistre
l’identité et l’émetteur du certificat :
- l’identité est l’URI ou l’adresse e-mail du subjectAltName du certificat ;
- l’émetteur est l’émetteur OIDC de l’extension 1.3.6.1.4.1.57264.1.8 de Fulcio, ou de l’ancienne 1.3.6.1.4.1.57264.1.1.
Quand cosign est dans le PATH, le store lance cosign verify-blob --bundle … --certificate-identity <identity> --certificate-oidc-issuer <issuer>. Si cosign
ne vérifie pas le bundle, la publication est refusée. Sans cosign, le store
garde le bundle et le marque comme non vérifié. La page du paquet affiche
Sigstore:
archec add vérifie le bundle de la même façon. Pour exiger Sigstore dans un
projet, ajoutez sigstore à son trust :
project App {
trust reviewed, sigstore
}
Ce projet ne prend alors que les paquets qui ont un bundle que cosign a vérifié
sur la machine qui a lancé archec add. archec check signale
library-sigstore pour un paquet pris sans bundle. archec store verify-index
vérifie aussi chaque bundle par rapport à son archive.
archec lit le bundle avec le seul module crypto de node : il n’y a pas de
bibliothèque Sigstore à installer. Il lit les deux formats : le bundle Sigstore
(cosign sign-blob --new-bundle-format, par défaut depuis cosign 3) et
l’ancien format de cosign. archec vérifie seulement que le bundle est pour
cette archive, et l’identité qu’il nomme. La signature, la chaîne de
certificats jusqu’à Fulcio et l’entrée Rekor sont vérifiées par cosign. Sans
cosign, l’identité affichée est ce que le bundle prétend, rien de plus. Un
bundle signé avec une clé (cosign sign-blob --key) est refusé : il ne nomme
aucune identité.
Ce que la publication refuse#
- un paquet sans
owner,licenseouexport-control; - tout ce qui pourrait s’exécuter à l’installation : scripts, binaires, fichiers marqués exécutables, liens ;
- un fichier qui ne passe pas l’analyse syntaxique ;
- un paquet de plus de 20 Mo.
Contrôle des exportations#
export-control est votre déclaration en tant qu’éditeur : none, ear99, ou un
numéro de classification. Publier des données techniques contrôlées constitue en
soi une exportation.
Un paquet dont le texte évoque une technologie de défense (radar, autodirecteur, guidage, missile, conduite de tir…) est retenu jusqu’à ce qu’un relecteur du store le libère, quoi qu’il déclare. Une technologie soumise à l’ITAR, ou qui exige une licence d’exportation, n’est pas acceptée. Ceci n’est pas un avis juridique.
Ce que montre la page d’un paquet#
archec store site dessine chaque paquet à partir de ses propres fichiers.
Au-dessus du README, la page montre ce qu’est le paquet :
- Architecture : le diagramme de blocs de son système, tel que le dessine
archec diagram; - The board : l’image que dessine
archec board picture, pour un paquetkind board(quatre au plus, puis « and N more ») ; - Hardware : les cartes et les appareils de son système, câblés, quand il en a ;
- Animations : ses
animation(six au plus), jouées comme les joue une diapositive.
Les blocs ```arche du README et les fichiers .arche du paquet (sous
Files) sont colorés comme l’éditeur les colore, en clair ou en sombre.
Un paquet dont le modèle a des corps et des articulations reçoit un bouton
3D et sa propre page, p/<owner>/<name>.3d.html, en anglais et en
français. La page dessine les corps, avec les articulations sur des curseurs.
Elle charge MuJoCo pour exécuter les contrôleurs du modèle face aux corps.
MuJoCo vient de $ARCHE_MUJOCO_URL, sinon de mujocoUrl dans le store.json
du store (son mujoco.js, ou le dossier qui le contient), sinon de
https://arche-lang.xyz/playground/mujoco/. Mettez none pour se passer de
MuJoCo ; la page ne montre alors que le modèle et ses curseurs. Si MuJoCo est
sur un autre site, ce site doit autoriser les requêtes cross-origin.
archec store serve admet cette origine, et WebAssembly, dans la politique de
sécurité du contenu des pages 3D, et de celles-là seulement.
Un modèle qui a des erreurs, ou qui ne peut pas être dessiné, n’affiche rien de tout cela. La page est construite sans.
Publier un modèle Capella ou des exigences Polarion#
archec store package fait d’un import un paquet en une seule étape :
archec store package drone-arch --from capella "Demo drone.aird" \
--owner acme --license Apache-2.0 --export-control none
archec store package system-reqs --from polarion polarion.yaml \
--owner acme --license Apache-2.0 --export-control none --version 1.0.0
Il procède en quatre étapes :
- Il lance l’importeur dans le nouveau dossier. Pour Capella, c’est
archec capella(un.capella, son.aird, son dossier ou un zip ;--prefix,--layerset--no-diagramssont transmis). Pour Polarion, les work items deviennentrequirements.arche. Ils viennent d’un export JSON (avec--config polarion.yamlpour sa correspondance des champs), ou sont récupérés depuis le serveur que nommepolarion.yaml, avecPOLARION_TOKENdéfini. - Il écrit
library.arche. Le propriétaire, la licence et la classification d’exportation viennent des options, et rien n’est importé sans elles. Le nom est celui du dossier sauf si vous passez--name, et la version est0.1.0sauf si vous passez--version. Le type estarchitecturepour Capella etspecpour Polarion (--kinden fixe un autre).--label,--descriptionet--keywordssont facultatifs. - Il écrit un README qui dit d’où vient le modèle et comment le prendre.
- Il vérifie le paquet comme le fait
archec store publish --dry-run, face à un index vide : le paquet doit compiler comme le compile un projet qui l’utilise.
Rien n’est publié. Lisez le dossier, puis lancez
archec store publish <folder>. Les documents Polarion que polarion.yaml
associe à des livrables sont déclarés dans le paquet, car aucun projet autour
de lui ne les déclare.
Kits d’interface#
Un paquet de kind ui-kit contient un thème pour un ui { } : les
couleurs dans lesquelles ses écrans sont dessinés. Il peut aussi fournir des
éléments qu’utilisent ses écrans. Le thème est un
enregistrement constant, dans le theme.arche du kit :
baseest le thème de départ,darkoulight;- les autres clés sont les couleurs qu’il modifie.
// library.arche: library automotive-dark "Automotive dark" { kind ui-kit; owner acme; version "1.0.0"; … }
// theme.arche
/// Dark and high contrast, for a car's cluster.
const AUTOMOTIVE_DARK = { base: "dark", background: "#0b0f14", surface: "#1a2029", primary: "#4fc3f7", onPrimary: "#00131f", warning: "#ffc400" }
Un projet prend un kit comme n’importe quel paquet : archec add main.arche acme/automotive-dark écrit son uses. Une ui le nomme ensuite :
ui {
theme "acme/automotive-dark" // the kit's theme, by the package's name
colors { primary "#00e5ff" } // and changed further, as any theme
…
}
Si le theme.arche du kit est inclus, theme AUTOMOTIVE_DARK désigne la même
constante. Un projet peut déclarer son propre thème de la même manière.
Un element au premier niveau de n’importe quel fichier .arche du kit est
destiné aux projets qui utilisent le kit. Ils l’emploient dans leurs écrans
comme les leurs (Tyre("Front", bus.TPMS.front)), sans include :
// elements.arche, in the kit
/// A tyre and its pressure.
element Tyre(title: string, p: float32) {
column {
label { text title; size small }
gauge { value p; range 0..4; unit bar }
}
}
- archec vérifie le contraste du thème, comme pour tout thème (
ui-a11y). - Le modèle d’interface indique d’où vient son thème (
theme.from). - Les aperçus et les générateurs le dessinent (
--target ui-qml). - La fiche d’un kit montre chaque thème avec ses couleurs. La fiche de n’importe quel paquet liste les écrans des ui qu’il contient.
Limites des kits d’interface#
- La fiche d’un kit montre ses thèmes. Elle ne liste pas encore ses éléments.
Éditions et versions d’archec#
Un paquet indique les versions d’archec avec lesquelles il fonctionne
(archec ">=0.10") et son édition. Tout archec plus récent lit les anciennes
éditions. archec fmt --edition fait passer un paquet à une édition plus récente.
Avant une version, archec store test <index> --breaks construit chaque paquet
avec le nouvel archec. Il échoue sur tout paquet qui passait avec une version
antérieure. Les badges indiquent les versions d’archec avec lesquelles chaque
paquet fonctionne.
Faire tourner un store#
Un store est un dossier d’index. Sur GitHub, c’est un dépôt :
archec store init arche-store # store.json, README, .github/workflows/store.yml
archec store seed arche-store --license Apache-2.0
cd arche-store && git init && git add . && git commit -m "Arche Store"
archec store init affiche les fichiers qu’il crée, ainsi que l’étape suivante :
✓ arche-store/store.json
✓ arche-store/README.md
✓ arche-store/.github/workflows/store.yml
✓ arche-store/.gitignore
✓ arche-store/publishers/.gitkeep
✓ arche-store/packages/.gitkeep
✓ arche-store/archives/.gitkeep
✓ arche-store/collections/.gitkeep
next: `archec store seed arche-store`, then `git init` it and push; `archec store use arche-store` to use it here
Publier revient alors à ouvrir une pull request qui ajoute un paquet
(archec store publish <folder> --store <your clone>). Le workflow vérifie les
signatures et construit le paquet avec archec. Sur la branche principale, il écrit
les badges et publie les pages (archec store site) sur GitHub Pages.
Le store hébergé, lui, se passe de pull request :
archec store serve arche-store --port 8080
archec store token arche-store acme --org kria-team
archec store token arche-store alice --reviewer
Le store hébergé ajoute :
- des comptes : des jetons, ou la connexion avec GitHub quand
GITHUB_CLIENT_IDetGITHUB_CLIENT_SECRETsont définies ; - des paquets privés pour une organisation (
archec store publish --private) ; - la relecture des paquets retenus ;
- des étoiles, des discussions sur la page de chaque paquet, et des demandes de cartes ou de pilotes manquants ;
- le nombre de téléchargements, par paquet et par version
(
<index>/downloads.json, dans/api/packages,/api/downloadsetpackages.json), et une liste triée par étoiles, par téléchargements ou par dernière mise à jour.
Se connecter avec GitHub#
On se connecte sur /auth/github. Le store envoie la personne sur GitHub, qui
lui demande d’autoriser le store à lire son login et ses organisations (scope
read:org). GitHub la renvoie sur /auth/github/callback. La page affiche
alors un jeton du store, une seule fois, et la ligne archec store login … à
lancer. Le compte est le login GitHub, en minuscules. Ses organisations sont
les organisations GitHub dont il fait partie : il peut donc publier au nom de
chacune.
Pour le mettre en place sur store.arche-lang.xyz, le propriétaire du store fait ceci une fois :
Sur GitHub, ouvrez Settings › Developer settings › OAuth Apps › New OAuth App. Pour une application qui appartient à une organisation, ouvrez plutôt Settings › Developer settings › OAuth Apps de l’organisation.
Remplissez le formulaire :
- Application name :
Arche Store - Homepage URL :
https://store.arche-lang.xyz - Authorization callback URL :
https://store.arche-lang.xyz/auth/github/callback - Laissez Enable Device Flow décoché.
Puis cliquez sur Register application.
- Application name :
Copiez le Client ID. Cliquez sur Generate a new client secret et copiez le secret : GitHub ne l’affiche qu’une fois.
Sur le serveur, mettez les deux valeurs dans
/etc/arche-store.env. C’est l’EnvironmentFilede l’unité systemdarche-store.service(ops/arche-store.servicedans le dépôt du serveur).ops/provision.shle crée vide, appartenant à root, en mode 600. Ajoutez ces deux lignes :GITHUB_CLIENT_ID=Iv1.0123456789abcdef GITHUB_CLIENT_SECRET=0123456789abcdef0123456789abcdef01234567archec n’appelle personne sans y être autorisé : le store a donc aussi besoin de
ARCHE_ALLOW=githubdans son environnement ; sans lui, la connexion répond 503. L’unité d’arche-lang.xyz le définit ; un autre serveur l’ajoute à ce fichier (Ce que chaque commande envoie, et où).Puis redémarrez le store :
sudo systemctl restart arche-storeVérifiez. Ouvrez https://store.arche-lang.xyz/auth/github, acceptez sur la page de GitHub, et lancez la ligne
archec store login https://store.arche-lang.xyz --token …qu’affiche la page.archec store loginaffiche le login et les organisations.
À savoir :
- Sans les deux variables,
/auth/githubrépond 501. Les jetons créés avecarchec store tokencontinuent de marcher. - Si une organisation restreint l’accès des OAuth Apps, elle manque au compte tant qu’un propriétaire de cette organisation n’a pas approuvé l’application (Settings › Third-party access de l’organisation). On peut demander cette approbation sur la page d’autorisation de GitHub.
- Se reconnecter donne un nouveau jeton et révoque le précédent du compte. Les
organisations sont relues sur GitHub à chaque fois. Un relecteur ou un
administrateur créé avec
archec store token … --reviewer(ou--admin) le reste quand il se connecte avec GitHub. - L’état que renvoie GitHub doit correspondre à celui qu’a donné le store, dans le même navigateur (un cookie), en moins de dix minutes, et il ne sert qu’une fois. Sinon le store refuse la connexion et la personne recommence.
- Pour GitHub Enterprise Server, définissez
ARCHE_GITHUB_URL(par exemplehttps://github.example.com) etARCHE_GITHUB_API(https://github.example.com/api/v3). Sans elles, le store utilise github.com et api.github.com. - Derrière Caddy, la ligne de login utilise le schéma et l’hôte que transmet
Caddy (
X-Forwarded-Proto,X-Forwarded-Host) : elle donne donchttps://store.arche-lang.xyz.
archec store seed publie ce qu’archec fournit, sous arche, un éditeur vérifié :
- le store de cartes, et chaque carte séparément ;
- la bibliothèque standard ;
- les fonctions de TheAlgorithms/Python traduites dans le langage d’action
(
lib/algorithms-*, un paquet par dossier, sous MIT comme l’original : voir algorithms) ; - les exemples, comme architectures (dont ts-handlers, dont le comportement est écrit en TypeScript) ;
- les modèles de projet dont part
archec new, enkind template; - les collections
starteretplants.plantscontient un bras à deux segments, un pendule inversé sur chariot, un rover et un quadrirotor. Chacun est un système physique MuJoCo avec son contrôleur, et un plan de test exécuté dessus (voir Plants).
Un projet créé avec archec new --from (ou --template) l’indique dans son bloc
de projet : derived-from "arche/rover-esp32@0.1.0". À la publication, sa
bibliothèque reprend cette ligne, sauf si son propre library.arche en a déjà
une. La page du paquet dessine l’arbre généalogique.
La page d’un modèle de projet commence par Use this template : la ligne
archec new my-project --template owner/name, avec un bouton pour la copier.
La page de la liste a un bouton Templates qui ne montre que les modèles de
projet (ou ouvrez index.html#templates).
Chaque page de paquet a aussi Open in playground. Le lien porte les
fichiers .arche du paquet dans son hash : il marche donc sur un site
statique. Son fichier de projet devient main.arche ; un paquet sans projet
reçoit un main.arche qui inclut ses fichiers racine. Le playground a la
bibliothèque standard et le store de cartes : include "std/…" et
uses arche-hw-store y marchent. Le bouton est absent quand les fichiers n’y
compileraient pas :
- le paquet a besoin de fichiers de handlers (
.py,.ts) : le playground ne charge que des fichiers.arche. Les corps en```archepassent ; - il utilise d’autres paquets du store ;
- ses fichiers
.archesont dans des dossiers ; - le lien ferait plus de 60 ko.
Le lien ouvre le playground d’arche-lang.xyz, /fr/playground/ sur les pages
françaises. Un store privé fixe le sien avec
"playground": "https://…/playground/" dans store.json, ou avec
ARCHE_PLAYGROUND_URL. off retire le bouton.
archec store import-zephyr <zephyr>/boards -o zephyr-boards écrit une collection
de cartes à partir des fichiers de cartes de Zephyr (Apache-2.0). Chaque carte
reçoit :
- son processeur (
haletchippour STM32, nRF, RP2040 et ESP32) ; - sa RAM ;
- ses ports UART, CAN, SPI et I2C, avec les broches que fixe son DTS.
Ajoutez un owner et publiez-la comme paquet.
Toutes les commandes sont dans commands.md.