@cynodia/axiom-compiler 0.6.3-alpha.1 → 0.7.0-alpha.2

package/dist/normalize.d.ts

@@ -1,4 +1,5 @@
 import type { ApplicationGraph, ApplicationIR, ValidationIssue, ValidationResult } from '@cynodia/axiom-core';
+import type { RendererCapabilities } from '@cynodia/axiom-core';
 export declare class GraphValidationError extends Error {
     readonly problems: ValidationIssue[];
     constructor(result: ValidationResult);
@@ -6,6 +7,20 @@ export declare class GraphValidationError extends Error {
 export interface CompileOptions {
     /** Compilation refuses invalid graphs by default; disable only for diagnostics. */
     validate?: boolean;
+    /**
+     * Keep authoring metadata in the compiled artifact.
+     *
+     * Off by default, and that default is the point: metadata describing how a node was
+     * *authored* has no business in a browser payload or across a trust boundary. A development
+     * tool, a pattern inspector or an agent debugging an expansion asks for it explicitly.
+     */
+    includeAuthoringMetadata?: boolean;
+    /**
+     * The renderer the IR is being compiled for. Defaults to the browser renderer, because
+     * that is what `compileToIR` produces a page for — so a UI node kind no browser can draw is
+     * rejected at compile time rather than discovered on screen.
+     */
+    renderer?: RendererCapabilities;
 }
 /**
  * Validates a graph and normalizes it into the runtime-ready IR: references resolved,

package/dist/normalize.js

@@ -1,5 +1,6 @@
 import { actionAuthority, actionGuards, authorityContext, inferExpressionType, inferLocationType, itemTypeOf, locationFieldIds, locationRootStateId, referencedIds, resolvePresentationMap, semanticContextFromGraph, stateAuthority, validateGraph, } from '@cynodia/axiom-core';
-import { isUINode } from '@cynodia/axiom-core';
+import { isUINode, stripAuthoringMetadata } from '@cynodia/axiom-core';
+import { BROWSER_RENDERER_CAPABILITIES } from '@cynodia/axiom-runtime';
 export class GraphValidationError extends Error {
     problems;
     constructor(result) {
@@ -38,7 +39,9 @@ function compileRoute(route) {
  */
 export function compileToIR(graph, options = {}) {
     if (options.validate !== false) {
-        const result = validateGraph(graph);
+        const result = validateGraph(graph, {
+            renderer: options.renderer ?? BROWSER_RENDERER_CAPABILITIES,
+        });
         if (!result.valid) {
             throw new GraphValidationError(result);
         }
@@ -54,7 +57,11 @@ export function compileToIR(graph, options = {}) {
     const remoteActionIds = [];
     const authority = {};
     /** Nothing that reads state the client may not observe may reach the client. */
-    const readsHiddenState = (expressions) => expressions.some((expression) => referencedIds(expression).some((id) => hiddenStateIds.has(id)));
+    const readsHiddenState = (expressions) => expressions.some((expression) => 
+    // Following named expressions is not optional here: a calculation that reads
+    // server-only state must not reach the client because a consumer named it instead of
+    // inlining it.
+    referencedIds(expression, (id) => authorityOf.expressions.get(id)).some((id) => hiddenStateIds.has(id)));
     const nodes = {};
     const actions = {};
     const uiNodes = {};
@@ -62,8 +69,12 @@ export function compileToIR(graph, options = {}) {
     const states = [];
     const constraints = [];
     const transitionConstraints = [];
+    const expressionDefs = {};
     const routes = [];
-    for (const node of graph.listNodes()) {
+    // Authoring metadata is stripped on the way in, so no later stage has to remember to.
+    const forIR = (node) => options.includeAuthoringMetadata ? node : stripAuthoringMetadata(node);
+    for (const raw of graph.listNodes()) {
+        const node = forIR(raw);
         nodes[node.id] = node;
         if (isUINode(node)) {
             uiNodes[node.id] = node;
@@ -137,6 +148,13 @@ export function compileToIR(graph, options = {}) {
             case 'route':
                 routes.push(compileRoute(node));
                 break;
+            case 'expression':
+                if (readsHiddenState([node.expression])) {
+                    delete nodes[node.id];
+                    break;
+                }
+                expressionDefs[node.id] = node;
+                break;
             default:
         }
     }
@@ -201,6 +219,7 @@ export function compileToIR(graph, options = {}) {
         uiNodes,
         constraints,
         transitionConstraints,
+        expressionDefs,
         routes,
         // An edge naming a node the client does not receive would tell it that node exists.
         edges: graph.semanticEdges().filter((edge) => nodes[edge.from] && nodes[edge.to]),

package/dist/server.js

@@ -1,4 +1,4 @@
-import { SERVER_IR_CONTRACT, actionAuthority, actionGuards, authorityContext, isObservable, serverStateClosure, stateAuthority, validateGraph, } from '@cynodia/axiom-core';
+import { actionAuthority, actionGuards, authorityContext, expressionDefsIn, isObservable, requiredServerContract, serverIRExpressions, serverStateClosure, stateAuthority, validateGraph, } from '@cynodia/axiom-core';
 import { GraphValidationError } from './normalize.js';
 /**
  * Compiles the authoritative half of a graph.
@@ -24,6 +24,7 @@ export function compileToServerIR(graph, options = {}) {
     const entities = [];
     const constraints = [];
     const transitionConstraints = [];
+    const expressionDefs = {};
     for (const node of nodes) {
         if (node.kind === 'entity') {
             entities.push(node);
@@ -34,6 +35,9 @@ export function compileToServerIR(graph, options = {}) {
         else if (node.kind === 'transition-constraint') {
             transitionConstraints.push(node);
         }
+        else if (node.kind === 'expression') {
+            expressionDefs[node.id] = node;
+        }
     }
     const states = [];
     const observableStateIds = [];
@@ -65,8 +69,7 @@ export function compileToServerIR(graph, options = {}) {
     for (const entry of graph.listFields()) {
         fields[entry.field.id] = entry;
     }
-    return {
-        contract: SERVER_IR_CONTRACT,
+    const rules = {
         id: graph.id,
         name: graph.name,
         version: graph.version,
@@ -79,6 +82,30 @@ export function compileToServerIR(graph, options = {}) {
         ...(graph.principalEntityId ? { principalEntityId: graph.principalEntityId } : {}),
         observableStateIds,
     };
+    // Only the definitions the authority's own rules reach. A calculation used by the client
+    // alone decides nothing here, and the Server IR carries nothing that decides nothing.
+    const used = {};
+    const pending = serverIRExpressions(rules).flatMap((expression) => expressionDefsIn(expression));
+    while (pending.length > 0) {
+        const id = pending.pop();
+        const definition = expressionDefs[id];
+        if (!definition || used[id]) {
+            continue;
+        }
+        used[id] = definition;
+        pending.push(...expressionDefsIn(definition.expression));
+    }
+    const carriesDefinitions = Object.keys(used).length > 0;
+    const document = { ...rules, ...(carriesDefinitions ? { expressionDefs: used } : {}) };
+    /**
+     * The label follows the vocabulary the document actually uses. An application that uses
+     * nothing from 0.7 compiles to the same `axiom.server.v1` document it always did; one
+     * that groups or names an expression says so, because a v1 runtime could not execute it.
+     */
+    const contract = carriesDefinitions
+        ? 'axiom.server.v2'
+        : requiredServerContract(serverIRExpressions(document));
+    return { contract, ...document };
 }
 export function serializeServerIR(ir) {
     return JSON.stringify(ir);

package/dist/stylesheet.js

@@ -361,6 +361,35 @@ button.axiom-button.axiom-layout-horizontal { flex-direction: row; }
 .axiom-ux-empty-state { text-align: center; }
 .axiom-ux-form-section + .axiom-ux-form-section { padding-top: ${space('small')}; border-top: 1px solid var(--axiom-color-border); }
 
+/*
+ * A dialog. The renderer emits the semantics — role, aria-modal, the title relationship — and
+ * these are the affordances that make it read as a modal: a backdrop, elevation, centring and
+ * a scroll bound. They belong here for the same reason button metrics do: every application
+ * would otherwise have to correct the same thing, which is what makes a default a framework's
+ * job rather than an author's.
+ */
+.axiom-dialog {
+  position: fixed;
+  inset: 0;
+  z-index: 100;
+  margin: auto;
+  width: min(32rem, calc(100vw - ${space('large')} * 2));
+  max-height: calc(100vh - ${space('large')} * 2);
+  overflow: auto;
+  display: flex;
+  flex-direction: column;
+  gap: ${space('medium')};
+  padding: ${space('large')};
+  background: var(--axiom-color-surface-raised);
+  color: var(--axiom-color-text);
+  border: 1px solid var(--axiom-color-border);
+  border-radius: var(--axiom-radius-large);
+  box-shadow: var(--axiom-elevation-raised);
+}
+.axiom-dialog::backdrop { background: rgb(0 0 0 / 0.45); }
+.axiom-dialog > .axiom-dialog-title { margin: 0; }
+.axiom-dialog > .axiom-dialog-description { margin: 0; color: var(--axiom-color-text-subtle); }
+
 .axiom-diagnostic[data-empty="true"] { display: none; }
 .axiom-diagnostic-entry { color: inherit; }
 .axiom-no-route { padding: ${space('large')}; background: var(--axiom-color-surface); border-radius: var(--axiom-radius-medium); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cynodia/axiom-compiler",
-  "version": "0.6.3-alpha.1",
+  "version": "0.7.0-alpha.2",
   "description": "Normalizes an Axiom application graph and emits a self-contained page.",
   "license": "MIT",
   "author": "AskTech AS",
@@ -31,8 +31,8 @@
     }
   },
   "dependencies": {
-    "@cynodia/axiom-core": "0.6.3-alpha.1",
-    "@cynodia/axiom-runtime": "0.6.3-alpha.1"
+    "@cynodia/axiom-core": "0.7.0-alpha.2",
+    "@cynodia/axiom-runtime": "0.7.0-alpha.2"
   },
   "scripts": {
     "build": "tsc -b tsconfig.json tsconfig.test.json",