Documentation index

Who can do what with a file or a label: the one place edms answers it, for its routes and for its listings.

The deploy itself: point current at the new release.

A controller specialized for JSON data APIs backed by one or more iRepository instances.

CLI admin commands (status, phpinfo, package listing/building, cron management), run via the shell request dispatcher (aShellController) -- each route_* method backs one #[Command]/`#[Inte…

A site's audience for the hub: today's headline numbers of mmo.metrics (visitors, visits, page views, users logged in, conversions, errors), so the hub compares the clients' use of the application …

Class to use to match a route in the router.

This is the main module of the framework: - listen on the php signals : shutdown, error, exception, autoload - route request and send response to the server - log everything - plan jobs (CRON like)

What the application itself says about its health: the metrics its own \MMO\admin\controllers\MetricsController answers (GET api/monitoring/metrics.json) -- php and opcache, the packages and…

Declares a single named property of a \MMO\core\classes\tArrayProperties-using class: how to read it (getter), write it (setter), persist it (store), and its JSON-Schema.

Validator for a PHP array value -- which, per JSON Schema, can be EITHER the 'array' type (a list) or the 'object' type (a map): $testArray/$testObject decide which, from the value's own …

Read the finished artifact back and refuse to ship it if it contains anything that must never leave a developer's machine.

A css at-rule the language does not interpret (@media, @supports, @keyframes, @font-face, ...).

A client attaches a file to an entity of the application (an upload's attachment), or looks at the files attached to it: edms cannot know who may, the application answers, for an $action: - …

Dispatched when an unknown class is referenced, giving listeners a chance to load/register it (a PSR-4-autoloader-style hook built on the event system instead of spl_autoload_register).

Dump the target's database into its own backups/, and optionally bring the dump back here.

A binary operation: $base * 3, $a == $b, $a and $b.

The ordered list of values a render actually emitted a ? placeholder for.

The kanban boards a release follows: each one a <mmo-kanban>'s data, and its tickets' discussions, kept in a JSON file of its own, {folder}/{board}.json (KanbanBoard for the file).

A board file (boards/{board}.json, KanbanBoard, served by \MMO\admin\controllers\BoardController) as a repository of mmo.client's kanban entities: one KanbanBoard, its KanbanTickets…

The board each user works on: a project has several boards, one per feature or deployment objective, each with its checklist, and whoever works picks one -- in the developer admin (Développeur > Bo…

The developer layer's store on a development machine: a ticket filed from a page goes straight onto the board's file ({boards}/{board}.json, KanbanBoard), which git versions with the applica…

Merge two repositories of mmo.client's kanban entities (KanbanBoard, KanbanTicket, KanbanComment) into each other, when asked: a local one -- a JsonRepository, mmo.mongodb's `MongoRepositor…

A sync of a kanban board with GitHub (BoardSync), as a long job of mmo.core: run in its own process, with no time limit, followed live (<mmo-job>) -- a board with many tickets, and their com…

kanban sync, from the command line of an application listing it in its routes: merge a local repository of kanban entities (a JsonRepository, a MongoRepository) with GitHub (a `GitHubReposito…

Validator for a bool value -- adds no keywords of its own beyond Validator::KEYS.

Backticks

Square brackets []

Turn a git commit into ONE immutable, versioned artifact: build/{name}-{version}-{commit}-{libraries}.tar.gz plus its sha256.

The standard library of Simple CSS (the spec, 41).

Whether the .phar a package manager keeps for a package (PackageManifest::getBuildFilename) still holds the package's sources -- read, not guessed from dates.

Best-effort static call-graph scanner.

A function call.

A release checklist: everything to look at before a version is committed or shipped, one box per item -- or one per item and per member, when the team checks it together.

Builds the items of a release checklist (Checklist) from its recipe: what changed in the repositories, what the board's tickets say to check, and what no ticket covers.

The release checklists: what to look at before a version is committed or shipped, each one a JSON file of

Any object that can exchange credential with an oauth server

User storage interface.

Represent a configuration to use with the oauth code authentification

Converter from one type to another.

Entity container.

An APIRoute specialized for CLI subcommands (method 'SHELL', matching any path via '**') -- see

Dispatched (via \MMO\commit()) to persist a batch of entity changes -- each listening iRepository (\MMO\core\classes\aRepository::onCommit) picks out and stores the entities that belong…

One commit, as Repository::log lists it.

The values a php application injects into a compilation, read from scs as context::name.

The Simple CSS compiler: one instance compiles one stylesheet.

`@component button { ...

@config @screen.tablet = 768px -- sets a compiler option from the source.

The framework's central configuration/DI container: a nested array of settings and lazily-instantiated objects (\MMO\core\objects\unserialize's '$' => ClassName convention), addressable by p…

Implementation of PSR ContainerInterface: a nested, json-path-addressable data container (backed by

Content to be shown by the page controller.

Everything one task needs to act on one target, and the place tasks hand results to each other:

context::density, context::design.spacing.md -- a value injected by the php application.

An HTTP cookie, with import/export helpers for the common cookie-jar text formats (Netscape/cURL's classic tab-separated format -- NetscapeLine/toNetscapeLine/Netscape/ExportNet…

Dispatched to build an instance of $class, letting a listener answer with $event->setReturn($instance) instead of a plain new $class(...) -- e.g.

Ex1: $stmt = new CreateStatement($handler); $stmt->ifNotExists(); $stmt->temporary(); $stmt->table('test'); $stmt->fields(['id' => 'INT(3) UNSIGNED NOT NULL PRIMARY KEY', 'name' => 'VARCHAR(255) NO…

The secrets a deployment needs, read from a file in the project that git never sees.

Manage the current user's real system crontab (via the crontab command).

A parsed 5-field cron expression (minute hour dayOfMonth month dayOfWeek), used by \MMO\core\Cron to schedule jobs.

Configuration for the cryptographic functions

One generated css rule, before emission.

A XlsxPrinter that renders to CSV text instead of xlsx cell values: same row/column flattening, but plain-text/RFC-4180-style quoting (exportString) instead of Excel formulas for repeated…

A curl extension wrapper: builds up request options fluently (setHeaders/setCookies/...), then

Curly brackets {}

php scripts/admin.php with no command: one screen showing the project, its targets, its servers and what was deployed where -- beside the list of what can be done from here, one key each.

A target's database, asked on its server with the database's own client: its size, its collections (or tables), the connections, the server's uptime and version, the operations running for too long…

What every key of deploy.json means, and a declaration that says it: every key of every server and target written, at its default when nobody chose it, each one with a comment saying what it does.

property: value -- a css declaration.

DELETE FROM table [WHERE …] [ORDER BY …] [LIMIT …]

A job that only counts: the example to copy, and what to run to see the jobs work end to end (a launcher, a page following it, the tests) without touching any data.

One line of a target's deployment journal (\MMO\admin\helpers\Journal), stored on the target itself in deploy/deployments.json, and mirrored into the local store by \MMO\admin\tasks\Syn…

The developer layer of an application (mmo.client's display mode dev, \MMO\admin\helpers\DeveloperMode): on each page, the tickets of the board and the items of the checklists that are about…

The developer mode of an application: a layer of mmo.client's display modes (dev), which mmo.admin brings.

The developer mode from the command line (DeveloperController, \MMO\admin\helpers\DeveloperMode):

What changed between two revisions, as git diff says it: one DiffFile per file, each with its

The diffs and the history of git repositories, as JSON: what <mmo-diff> shows.

One file of a Diff: its paths and modes on each side, its blobs, and the hunks of what changed.

One hunk of a DiffFile: a run of changed lines with the unchanged lines around them, as git's @@ -oldStart,oldCount +newStart,newCount @@ context introduces it.

One line of a DiffHunk: kept, added or removed, with its number on each side it exists on.

The generator's control panel: pick libraries, pick languages, (re)generate.

Generates the complete HTML documentation from a JSON file

Everything the documentation can point a reader at, in one list: what the index page lists and what the search box searches (\MMO\doc\controllers\DocPageController::routeIndex, \MMO\doc\c…

One member of a symbol: a constant, a property, a method, a plain function, a custom element's attribute, a css hook or a slot.

Base of every node of the documentation model (DocPage, DocSymbol, DocMember, DocParam).

One generated documentation page: the unit both renderers work on.

Renders a generated documentation page as real html, instead of dropping its markdown into an <mmo-markdown>.

One parameter of a function/method, or one attribute of a custom element -- whatever the language, a name, a type, an optional default and a description.

One top-level documented thing: a php class/interface/trait/enum/function, a javascript class/function/ namespace, or a .jhs custom element/view.

One rendered type expression, already resolved: the display text plus, for every atom of it, where that atom is documented.

A renderable container for a controller/response's output data (its "body"), plus metadata: HTTP-style Links (LinkProviderInterface), request/response logs (\MMO\core\events\Log), fre…

Dispatched whenever a document's body is (re)set (from Document::__construct or Document::setBody), letting listeners inspect or react to the new body (e.g.

A document's options as named arguments, for its constructor: new HtmlDocument(null, new DocumentOptions(...)) stands for new HtmlDocument(null, ['raw' => true, ...]), and a misspelled option i…

Dispatched by Document::render(), letting a listener supply the rendered output itself (via setReturn) instead of the document's default printer -- e.g.

Double quotes

DROP TABLE [IF EXISTS] table

The upkeep of edms, from the command line of the application (listed in its routes): - edms gc [--dry-run]: the garbage collector (FileManager::collectGarbage), to run every day or so; - `ed…

An entity that lives embedded inside another entity's property ($parent/$key) instead of its own collection -- has no collection/repository of its own (getCollection/getReposito…

Collects the generated CssRule and turns them into css: resolves @order, groups the rules of a same at-rule (@media, @supports, @keyframes) together and formats the output.

The framework's standard, storable entity: an id, a label/title, and creation/modification timestamps on top of \MMO\core\classes\aEntity's schema/property/change-tracking machinery, plus the …

Everything an authorized php function may need to know about where it is being called from: the injected compilation context, the css selector currently being emitted, the compile-time scope and th…

Evaluates expressions and renders css values.

Base class for every event/signal in the framework: just an $origin (whoever dispatched it) plus the

Runs an @example snippet from a symbol's own doc comment, in a sandbox (ExampleRunner), and returns its output as JSON.

Runs an @example PHP snippet in an isolated, sandboxed subprocess.

The false JSON Schema: no value is valid, and coercion always fails.

Dispatched to resolve a URL into a value: any registered listener that can answer it calls $event->setReturn($value) (Signal), and the caller reads it back via Signal::getReturn.

A stored file: its name is the entity's label, its bytes are kept by the storage (FileManager::getStorage) under getStorageKey.

One file inside a Repository, as git status reported it.

The files over http, for the logged-in user (FileManager does the work, and checks the rights).

The files and their labels: what edms does, whoever asks (its routes, controllers\FileController, or the application's code).

A stored file, sent as it is read: a download can be bigger than PHP's memory, which StreamResponse::render reads the whole stream into.

A single filter: a set of path => condition pairs, ALL of which must match (an implicit AND) for test to pass.

A group of filters (or nested groups) combined with GroupOperator (AND/OR/NOR).

A reference to another path in the SAME data being tested, e.g.

A single operator + value condition, e.g.

Event to notify that the client's flag has been updated.

`@for $i in 1..6 { ...

The css generation state at one point of the compilation: which selectors are being emitted, inside which at-rules, and at which @order priority.

`@fn name($param) { return ...

The package's configuration: where the git binary is, whether it has to run through sudo, and how long a single command may take.

A thin client for the GitHub REST API, for the things a repository cannot answer on its own: pull requests, issues, releases and the state of a branch on the server.

A GitHub project, or a repository's issues, as a repository of mmo.client's kanban entities: one KanbanBoard, its KanbanTickets, and their KanbanComments.

Controller to authenticate user with Google.

A generic group domain delimited by two ALREADY-REGISTERED tokens (referenced by their id, e.g.

The guided tours of the pages, for MMO.guide (src/js/core/Guide.js): a page's tour is the .tour.json written beside its .phtml (declaration.phtml → declaration.tour.json).

An HTML XmlDocument (rendered via HtmlPrinter), with a ready-made <html><head>...</head><body>...</body></html> skeleton (createBody): a charset/viewport meta, an <base href> set…

A TextPrinter for HTML output: the same templates as HTML markup instead of plain text -- used both for a document's inline "server console" log block (\MMO\core\documents\HtmlDocument) a…

Renders a documentation page (\MMO\doc\models\DocPage) as html, for \MMO\doc\controllers\DocPageController.

Whether a site answers, from here -- what its users see: the status, the time, the text the application alone writes, and how long its certificate has left.

One project's fleet, watched from this machine: the servers and the sites (targets) its deploy.json declares, the probes run on them, what they saw and what went wrong.

The api of a monitoring hub (Hub): what its pages' elements ask ({MMO\admin}/monitoring/pages, <mmo-hub-bar>, <mmo-hub-ack>, <mmo-hub-tools>), and what a script asks.

What the pages of a monitoring hub are made of ({MMO\admin}/monitoring/pages/hub.phtml): mmo.client's design system -- .widgets of tiles, article.card, table.data, .status-tag -- its `<mm…

Makes a monitoring hub for a project: a folder of its own holding hub.json, its page, its command line, and the README saying how to use them -- mmo.admin's hub-template/, its {{placeholders}} …

A monitoring hub from the command line: php hub.php <command> in the hub's folder (Hub).

Internationalization module.

`@if cond { ... } @else { ...

Class used to import a list of raw data (organized in a map) into a list of entities.

@import "file.scs" -- resolved at compile time.

Import data using a socket.

The developer layer's store on a server: what is filed from a page goes into an inbox, {folder}/inbox/{board}.json, in a git repository of its own (VersionedFolder) -- apart from the clients…

Bring a server's inbox (InboxStore) onto the board of this machine: php admin.php developer pull --target=dev.

Dispatched when a package's manifest configuration is being included (see PackageManifest's own hooks).

What went wrong, from the readings: an incident opens the first time a metric crosses a rule (or a probe fails), stays open while it does, and is resolved by the first reading where it no longer does.

An index access: $sizes[0], $map["md"].

INSERT INTO table (cols) VALUES (…), (…) [ON DUPLICATE/CONFLICT …]

Create the target's folder layout, so every later task can assume it exists.

Validator for a PHP object value: 'instanceOf' (this framework's own extension keyword, not part of the JSON Schema spec).

Same keywords as NumberValidator, but requires the JSON Schema 'integer' type instead of 'number'.

A Command exposed in \MMO\core\classes\aShellController's built-in interactive REPL: $cmd is what the user types to select it (matched as a required, constant first "argument" of the unde…

${...} / #{...} -- an expression evaluated inside a css value or a selector.

A repository's GitHub issues seen as the data of a kanban board (mmo.client's <mmo-kanban>), and the changes made on the board written back to the issues.

The discussion of a GitHub issue (or pull request) as mmo.client's <mmo-kanban> shows it: comments with their author, which can answer one another.

Specific attribute - jhs-compile: (html): will render the node without using open().

Extracts documentation from a .jhs file -- mmo.client's one-file format holding an element's markup, its javascript class and its styles together (\MMO\client\JHSCompiler).

The HTTP side of long jobs (JobStore): start one, follow it live, stop it.

A job's events as Server-Sent Events (text/event-stream), read as they come: what JobController's events.sse answers, through a \MMO\core\server\StreamResponse (which sends each chunk…

Runs one recorded job (JobStore) in the current process, from start to end, and records how it went: its state, its logs as events, its result or its error.

Where long jobs (aJob) live: one folder per job, that the job's own process writes and any number of readers (a page, an SSE stream, the command line) read -- the job never talks to a browser.

A target's deployment history, stored ON the target (deploy/deployments.json) rather than on whoever's laptop ran the deploy -- so it survives a fresh clone of the project, and describes the trut…

Bundle the package's javascript into a single file.

JS Configuration for the mmo-app

Generates the javascript documentation of a package, exactly the way Documentor generates its php one.

A JSON Document.

Change a JSON file the way a person would: only the values that change, where they are, keeping every comment, the order of the keys and the layout of everything else.

The notifications kept in a folder, one JSON file per recipient ({md5 of the uid}.json, the uid inside), the latest last, at most $max: the oldest read ones go first.

A hand-written, tolerant JSON parser (Decode/DecodeFile): accepts standard JSON, plus a few lenient extensions with a warning logged (not thrown) -- single-quoted strings, and unquoted ba…

Converts any value into a plain, json_encode()-ready structure (see Encode/EncodeFile).

Collections container.

Represents a name = <json>; JavaScript variable assignment, to embed server-side data into an HTML document's inline <script> (used by \MMO\core\documents\HtmlDocument).

A <mmo-kanban> board kept in a JSON file: its data (statuses, labels, categories, people, tickets) and each ticket's discussion.

A board of <mmo-kanban>: its settings -- the statuses its columns are, its labels, its categories and the people a ticket can be assigned to.

A comment of a <mmo-kanban> ticket's discussion (KanbanTicket): who wrote it, what (markdown), and which comment it answers.

The JSON API of <mmo-kanban> boards, over any repository holding KanbanBoard, KanbanTicket and

The AI prompts of <mmo-kanban> tickets: fenced code blocks of a ticket's description whose language is an AI agent's name, so the agent (or whoever drives it) can pick up the tickets meant for it.

A ticket of a <mmo-kanban> board (KanbanBoard, named by board).

A node of the label tree: the tree is at the same time the folders of the files (under _FILESYSTEM) and their tags (under _TAGS, a client's own ones under {client}/_TAGS, \MMO\edms\FileM…

Turns a .scs source into a flat list of Token.

A small, tolerant javascript lexer -- just enough to let Parser walk a source file without ever mistaking a brace, a quote or a slash inside a string/comment/regular expression for real code.

A PSR-7 web link (RFC 5988/8288's Link: header entries, e.g.

This attribute is used to auto connect a class to events.

An array literal: [4, 8, 16].

A literal value: a number, a string, an identifier, a color, a boolean...

The bytes of the files, in a local folder ($folder): a key is a path in it.

A single log entry -- carries a level (one of the iLogLevel flags), a printf-style message + context, where it originated (file/line, and an optional call stack), and renders itself either as …

The errors a target's logs gained since the last look: each log file is read from where the previous reading stopped (its size then), so an error is counted once, the collection it appeared in -- n…

A repository operation, recorded (and dispatchable as an event, so a listener can inspect/veto it via

Build and send a MIME email via PHP's mail() (which shells out to sendmail), with support for HTML/plain alternative bodies, attachments, inline (data-URI) images, and DKIM signing.

Send templated HTML emails (mail/Send), rendering a template file (via \MMO\core\documents\Document::import) into an HtmlDocument and passing its output as the body of a Mail.

The journal of a mail sent through \MMO\core\controllers\MailController: who sent what to whom, and whether it left.

A map literal: (sm: 8px, md: 16px).

Renders a documentation page (\MMO\doc\models\DocPage) as markdown.

MCPController — a Model Context Protocol (https://modelcontextprotocol.io) server that exposes the MMOFramework itself to any MCP-compatible AI agent (Claude, or any other client speaking the proto…

What an application says about itself, collected for the hub's application probe: php and its opcache, the packages it runs and their versions, the release it is, and what its providers count (@see…

What a site tells the hub about itself (GET api/monitoring/metrics.json): php and its opcache, its packages and their versions, its release, and what its providers count (\MMO\admin\monitori…

Apply the database patches a target has not run yet -- exactly once each, in order.

The optional optimization step of the pipeline (the spec, 49 -- step 12): duplicate selector merging and duplicate declaration removal.

A display mode: a way the application looks for whoever turns it on.

Whether whoever is asking may turn a mode on, which has a scope (Mode::$scope): mmo.client knows no user, mmo.oauth answers.

The display modes of the application (Mode): one level -- how dense it is, simple, standard or expert -- and any number of layers drawn over it -- dev, writer...

Asks every library and the application the display modes they have (Mode): sent once, by

The modes whoever is asking chose, or the ones they are given by default: mmo.client keeps no user, mmo.oauth answers -- user with what the user saved (their config.modes), default with what …

A submodule: a full Repository that also happens to be an entry of another one.

Mongodb bridge

Where a hub keeps what it saw: plain files in its data folder, nothing to install.

@namespace ui -- the name the definitions of this file answer to.

Marker attribute: excludes a property from what \MMO\core\printers\TextPrinter (HtmlPrinter...) prints of an object, dumped (\MMO\dump() / \MMO\idump()) or not (`HtmlPrinter::Print($object…

The notification centre's routes (Notifications): the logged in user's own notifications, and marking them read.

Who is asking for their notifications (\MMO\client\Notifications): mmo.client knows no user, mmo.oauth answers with the logged in user's uid.

The notification centre: what happened that a user should know of, kept until they read it -- a ticket a developer filed for the project lead, a declaration to validate.

A notification was given to its recipients (\MMO\client\Notifications::send): another channel -- an email, a webhook to a team's chat -- listens to this one.

Tells someone an incident opened, got worse or was resolved (Incidents): through the channels of the hub's notify list, each with the lowest level it cares about.

Validator for a null value -- adds no keywords of its own beyond Validator::KEYS.

Validator for a numeric value: 'multipleOf'/'maximum'/'minimum'/'exclusiveMaximum'/'exclusiveMinimum'.

mmo.oauth's commands on the application's command line.

@order -1 { ... } -- sets the emission priority of everything inside.

Capture everything echoed/printed (via PHP's own output buffering, ob_start()) so it can be inspected, filtered, or discarded instead of being sent to the real output.

## Structure of the manifest: mmo.json the packages manager will try to find a mmo.json in the current folder or one of its parent in auto mode.

Store mmoframework package informations

A page of the site built from sections (Section), edited in the backoffice and served at its slug.

Event to request content for a page

Render a version of a page (Page::exportDraft, Page::getPublished) into an html document: each section by its template (sections/{type}.phtml), then the page's layout (`layouts/{layout}…

A version of a page as it was published (Pages::publish): the history a rollback copies back into the draft (Pages::rollback).

A page of the application, as the developer layer names it: its route, the url's path below the site (settings/utilisateurs), whatever site the url is of -- `http://localhost/my.oviepro/settings/…

The pages built from sections: what the backoffice does with them, whoever asks (its routes,

The backoffice's api of the pages (Pages does the work, and checks the rights), under admin/:

Parenthesis ()

Turns the tokens of a .scs source into an ast (nodes\StylesheetNode).

Extracts documentation from javascript sources, the way reflection extracts it from php.

WARNING: Need Module PHP IMagick PHP wrapper for the pdftk command line utility using fdf standard https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/PDF32000_2008.pdf

Base class for an entity backed by a SQL row -- used by Table to generate one class per table from its columns (Table::toPHP), and usable directly as the parent of a hand-written table en…

Converts an entity's property values into values a SQL column can actually hold.

A aRepository backed by a SQL database: one Table per collection.

Accumulates counters (e.g.

Change values of one class's configuration in a PHP file -- the \MMO\config([...]) a project's scripts/bootstrap.php holds -- where they are written, leaving the rest of the file as a person wr…

The php callables an scs source is allowed to invoke through php::name(...).

Represents a polynome made of one or more variable

Prints an ast (Parser) back as Simple CSS source.

A printer's options as named arguments: new PrintOptions(escape: true) stands for ['escape' => true].

Process is a thin wrapper around proc_* functions to easily start independent PHP processes.

The command-line surface of mmo.admin: build, ship, activate, roll back, back up, restore and migrate one or more deployment targets.

One deployable codebase: where it lives, how it is built, and which patches belong to it.

A GitHub project (Projects v2: github.com/users/<login>/projects/<n>, or orgs/<login>/...) seen as the data of a kanban board (mmo.client's <mmo-kanban>), and the changes made on the board wr…

Makes an application built on the framework: mmo.admin's project/ skeleton, then its deployment files (templates/: deploy.json, .gitattributes, scripts/...) -- the very ones `php scripts/…

Keep the last N releases on the target and delete the rest, so immutable releases do not fill the disk.

The pages visitors see: a published page (Pages::publish) at its slug, the site's root being $homepage.

Generic way to query a collection of entities.

A chunk of css kept verbatim (punctuation, combinators, !important, ...).

Whether a project is set up to deploy, read from its files alone: what the dashboard shows before offering anything, and what decides whether it offers deploying at all.

What one probe saw of one subject (a server, a target), once: a status, numbers, facts and details.

Builds the documentation model (\MMO\doc\models\DocSymbol) for php symbols, out of reflection.

What a target runs, read on the target itself: the release current points at, what its journal says of the last deployment, the releases kept, a lock left behind, the space its folders take and h…

Run the release scripts a target has not run yet, once the new release is live: what a version needs done on each site besides its code and its database patches -- roles to create (`php admin.php d…

A mutual-exclusion lock held ON the target, so two people (or a person and a cron) cannot deploy to the same machine at the same time.

Collections container.

A local git repository, driven by the git command line.

Controller used to handle entities through the repositories

PSR-7-style HTTP request.

Psr Response with a body as an object.

Replace the target's database with the content of a dump.

The outcome of a compilation: the generated css, plus the compile-time variables it evaluated.

return expression -- only valid inside a @fn body.

Go back to a previously shipped release, on purpose (as opposed to ActivateTask::rollback, which the runner calls automatically when a deployment fails half-way).

# API json api

selector { ... } -- a css rule, possibly nested.

The thresholds a reading is judged by: a metric above its warning raises the reading to a warning, above its critical to critical -- below, for a rule that says below (days left on a certific…

Runs a list of aDeployTask against a list of Target, and is the only place that decides what happens when something goes wrong.

Clean html on the server so that it only holds what <mmo-editor> produces: the same rules as MMO.editor.sanitize() (src/js/editor.js), which the browser applies first.

Singleton class that parses sass variables

Implementation of JSON Schema

A chain of compile-time variables (@let).

Event to request the list of existing scopes: what the roles' editor offers (\MMO\oauth\controllers\AccessController::routeScopesCatalog).

`@screen tablet { ...

Compiles Simple CSS (.scs) into css.

Looks up anything documented across every installed package's documentation, reading the index.json search index \MMO\doc\Documentor::buildIndex writes alongside each library's markdown (bui…

Declares a named, user-facing search field on a \MMO\core\classes\tArrayProperties-using class: a title/view for the UI, and a filter-expression template (buildFilters) that turns a user'…

One section of a page (Page::$sections): its type names the template rendering it (sections/{type}.phtml) and the schema its data follows (sections/{type}.schema.json, SectionTypes).

What a section's template prints its fields with ($_VARS['f'] in sections/{type}.phtml): every value is made safe for where it goes, so a template never escapes anything itself.

A type of section: the pair of files sections/{name}.phtml (how it is rendered, PageRenderer) and sections/{name}.schema.json (what its data holds), found in Pages::$templates.

The types of section a page can hold (SectionType): every sections/{name}.schema.json that has its sections/{name}.phtml, in the folders of Pages::$templates.

The section-type editor's api (SectionTypeStore does the work), under admin/section-types:

The site's types of section, as the section-type editor writes them (\MMO\editor\controllers\SectionTypesController): the files sections/{name}.schema.json, {name}.phtml and {name}.css o…

This attribute is used to alter the serialization process.

A machine deployment targets live on -- declared once, and referenced by every Target it hosts.

php scripts/admin.php setup: the questions whose answers are a project's deployment, asked in the order deploying needs them, each one explained -- then the files those answers make, shown before…

Run local shell commands via Process, exposing just the latest run's output/exit code.

Parsed command-line arguments (options/flags), as used by ShellRequest's body.

A TextPrinter for an ANSI-color-capable terminal: the same templates, restyled with SHELL_* color/style escape codes (see functions.php's SHELL_* constants).

Command Request used to create a simple request from a string Models a CLI invocation as a PSR-7-style Request: the script's own path becomes the URI, and the rest of $argv becomes the body (@see…

The outcome of one command: stdout, stderr and -- crucially -- a real exit code.

A uniform command runner on top of any iShell -- the local Shell or a remote SSH -- giving every command the same result object with a real exit code, plus dry-run support and the ha…

Put the artifact on the target and extract it into releases/{version} -- beside the running release, never over it.

The shutdown event.

An Event that a listener can answer with a return value (a request/response style event, as opposed to a plain notification) -- the dispatching code calls Send then reads getReturn.

A new PDF written from code -- an invoice, a receipt, a report: headings, text, labelled fields, a table whose columns fit their content, totals.

Signal that is sent only one time during the application lifecycle.

Where a token/node/value came from in a .scs source.

A source map v3 for the generated css: it tells a browser which .scs file, line and column each piece of css came from, so devtools shows lib.scs:91 instead…

Simple quotes

A remote shell over SSH (wraps the ssh2 PECL extension).

The bits of an ssh config a deployment needs, so a server can be declared as an ALIAS rather than as a host, a port, a user and a key path committed with the project.

A command started on a remote host and *detached* from the SSH session that started it (SSH::execBackground): it keeps running after the command returns, after the SSH session is closed, and a…

A Repository living on another host: every command is run over an existing SSH connection instead of as a local process.

A Stream wrapping the stdout of a command started via SSH::openExec, with the matching stderr stream and exit code alongside it.

Wrapper on query to pdo.

Compute statistics shaped as mmo-chart's config (counts/sums per dataset, optionally as a percentage, over one or more comparison periods) over an entity collection, exposed both as an API (…

Everything the deployment tooling knows, as entities: which projects exist, which machines they run on, which targets live on those machines, and what has actually been deployed to each.

PHP stream implementation.

Psr Response that reads a stream Used to retrieve files The application sends it as it reads it, a chunk at a time (render's output option): a download is not limited by php's memory.

A quoted string containing interpolations: "btn-${$name}".

Validator for a string value: 'maxLength'/'minLength'/'pattern'/'format'.

`@style name($param = default) { ...

The root node of a parsed .scs file.

Represents a set of equations for which a common solution is looked for.

A server's health: load, cpu, memory, swap, disks and inodes, network, processes, services, uptime -- one script reading /proc, df, ps and systemctl, run once per server whatever number of …

Helper to create PDO query on Table

Used by entities to create searchable term or filters for them.

Tag <>. Unlike the other group domains, defaults to NOT recursive (a < inside a tag is not treated as opening a nested tag).

One deployment target: a folder, on a Server, that a release is shipped to.

Selecting which targets a command acts on -- a thin, deliberately boring facade over Store's targets collection.

The test accounts of a checklist's recipe (recipe.accounts): as whom a check is done, and the account of this machine's database that fills the condition -- « an account limited to a group », « a…

The test runner's page: every installed package that ships a test suite, and a button to run each one.

The test records of a checklist's recipe (recipe.testData): what each test account (recipe.accounts, TestAccounts) must find in its perimeter and must not find outside it, for every « Open…

Where TestData reads and makes the test records: an application's repository, through its entities -- each record committed as the account writing it (\MMO\oauth\user() while it is saved), so …

Runs a package's phpunit suite and reports the result as data.

The http face of the javascript test suite: lists what can be run, and runs it.

A plain-text Document (rendered via TextPrinter by default) that appends any recorded

Converter to string for any value's type, driven by a per-type/per-log-level $templates table (each a strtr()-style string with {placeholder} tokens -- see renderTemplate/setTemp…

Reads the theme's token layer, lets an application change any value in it, and writes the result back as Simple CSS.

The http face of ThemeConfigurator: reads the theme's customizable surface, and writes a new one.

@theme [scope] { group { key: value } } -- runtime design tokens, emitted as css custom properties.

A single lexical token.

A single lexed unit: either a "known" token from its domain's token list (id = the key it was registered under), or a run of plain, unrecognized text (id = TEXT_ID, i.e.

A "grammar": a list of recognized literal tokens (each a plain string, e.g.

A generic, hand-rollable lexer: split text into a stream of Token instances, driven by a stack of

What a person looks at when a reading is not enough: the processes, the connections, the last log lines, the space a site's folders take...

The translations of a page (Page::$translations): its texts in each of its other languages, the default one being the draft itself (Page::$languages, the first).

The true JSON Schema: every value is valid, and coercion is a no-op.

A unary operation: -$spacing, not $rounded.

Unit used by polynome.

Holds a list of UnitVector

Represent a unit with its power and its factor: {factor} * ({unit}^{power})

UnixPipes implementation uses unix pipes as handles.

`UPDATE table SET col=?

An upload in progress, as Uploads keeps it: what the first request said about the file, and its bytes so far ({id}.part, next to its description {id}.json).

The uploads in progress, in a folder of their own ($folder), which only the server's account reads: the server keeps what an upload is and where its bytes are, a client only knows the upload's id.

A Path extended with scheme/host/user/password/port/query/fragment -- a full PSR-7 UriInterface, plus the same ArrayAccess/basepath machinery as Path (accessed via string keys: 'scheme', 'host…

@use lib::center / @use size(48px, 48px) -- expands a @style in place.

Model for user

Validates one value against one Schema (JSON Schema 2020-12 semantics), keyword by keyword.

One validation failure: which schema keyword ($keywordLocation) rejected which part of the value (Validator::getPath), and why ($message).

A compile-time Simple CSS value.

A css value, a selector or an at-rule prelude: an ordered list of terms, each one remembering whether it was preceded by whitespace so the emitted css looks like the source that produced it.

@let $name = value -- a compile-time variable declaration.

$name, $map.key, $colors.primary or $tokens::palette.n50.

`@variant primary { ...

A folder kept as a git repository of its own, every change committed as it is written: the developer layer's inbox on a server (the tickets filed there, InboxStore), apart from the application…

A hand-rolled RFC 6455 WebSocket server: a single instance listens for one TCP connection (listen), performs the HTTP-Upgrade handshake, then exchanges framed messages over it (readMessag…

WindowsPipes implementation uses temporary files as handles.

Controller used to dispatch workflow events and get parcours configuration

Flattens arbitrary rows of data (arrays, entities, nested structures) into a plain [row][column] => string grid suitable for \MMO\core\documents\xlsx\Sheet cells -- e.g.

A Document whose body is an XML tree (XmlNodes/XmlNode) instead of a plain array, rendered via XmlPrinter.

SimpleXMLElement wrapper, adding: namespace-prefixed attribute/child access ('ns:name'), parent/sibling navigation, a self-contained toXML serializer, and various convenience mutators Simple…

An XmlNodes with a tag name and attributes -- an actual XML/HTML element.

A lightweight, mutable DOM-like tree: a list of "child nodes" that are each either a plain string (text) or another XmlNodes/XmlNode instance.

A tolerant HTML/XML parser: unlike JsonParser, it never throws on malformed markup -- an invalid tag or mismatched closing tag just logs a warning (\MMO\core\classes\aParser::addError, no…

A TextPrinter for XML output: the same templates as XML markup instead of plain text -- used for a document's inline "server console" log block (\MMO\core\documents\XmlDocument, rendered …

A text node of an XmlNodes tree.