Guides pratiques › Utiliser l’Arche Store

Guides pratiques

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
}
Diagramme : Blinker
Ce qu’archec dessine depuis ce code : Blinker
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 :

  1. --store <where> ;
  2. ARCHE_STORE ;
  3. 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 trust du projet dit lesquels :
    • trust verified n’accepte que les éditeurs vérifiés (fabricants de cartes, projets connus) ;
    • trust reviewed accepte 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 sigstore dans son trust (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 :

  1. décompresse le paquet dans .arche/store/<name>@<version>/ ;
  2. écrit uses <name> "^1.2" dans le bloc du projet ;
  3. enregistre l’identifiant du store, la version, l’empreinte et la clé de signature dans arche.lock ;
  4. 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 .ts ou un bloc ```ts signifie TypeScript ;
  • un fichier .py ou un bloc ```python signifie Python ;
  • des corps tous en ```arche relè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: , et dit si le store l’a vérifié.

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, license ou export-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 paquet kind 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 :

  1. Il lance l’importeur dans le nouveau dossier. Pour Capella, c’est archec capella (un .capella, son .aird, son dossier ou un zip ; --prefix, --layers et --no-diagrams sont transmis). Pour Polarion, les work items deviennent requirements.arche. Ils viennent d’un export JSON (avec --config polarion.yaml pour sa correspondance des champs), ou sont récupérés depuis le serveur que nomme polarion.yaml, avec POLARION_TOKEN défini.
  2. 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 est 0.1.0 sauf si vous passez --version. Le type est architecture pour Capella et spec pour Polarion (--kind en fixe un autre). --label, --description et --keywords sont facultatifs.
  3. Il écrit un README qui dit d’où vient le modèle et comment le prendre.
  4. 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 :

  • base est le thème de départ, dark ou light ;
  • 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_ID et GITHUB_CLIENT_SECRET sont 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/downloads et packages.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 :

  1. 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.

  2. 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.

  3. Copiez le Client ID. Cliquez sur Generate a new client secret et copiez le secret : GitHub ne l’affiche qu’une fois.

  4. Sur le serveur, mettez les deux valeurs dans /etc/arche-store.env. C’est l’EnvironmentFile de l’unité systemd arche-store.service (ops/arche-store.service dans le dépôt du serveur). ops/provision.sh le crée vide, appartenant à root, en mode 600. Ajoutez ces deux lignes :

    GITHUB_CLIENT_ID=Iv1.0123456789abcdef
    GITHUB_CLIENT_SECRET=0123456789abcdef0123456789abcdef01234567

    archec n’appelle personne sans y être autorisé : le store a donc aussi besoin de ARCHE_ALLOW=github dans 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-store
  5. Vé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 login affiche le login et les organisations.

À savoir :

  • Sans les deux variables, /auth/github répond 501. Les jetons créés avec archec store token continuent 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 exemple https://github.example.com) et ARCHE_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 donc https://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, en kind template ;
  • les collections starter et plants. plants contient 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 ```arche passent ;
  • il utilise d’autres paquets du store ;
  • ses fichiers .arche sont 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 (hal et chip pour 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.