@cynodia/axiom-compiler 0.3.1-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AskTech AS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# Axiom Compiler
+
+Part of [Axiom](https://github.com/cynodia/axiom), an AI-native semantic web application
+framework.
+
+**Status: experimental / alpha.** The API may change between alpha releases.
+
+Validates an Application Graph, normalizes it into a runtime-ready IR, and emits a
+self-contained HTML page with the runtime inlined.
+
+## Installation
+
+```bash
+npm install @cynodia/axiom-compiler@alpha
+```
+
+Most applications should install the facade package instead, which re-exports this one:
+
+```bash
+npm install @cynodia/axiom@alpha
+```
+
+## License
+
+MIT
+
+Copyright (c) 2026 AskTech AS.

package/dist/codegen.d.ts

@@ -0,0 +1,12 @@
+import type { ApplicationGraph, ApplicationIR } from '@cynodia/axiom-core';
+import type { CompileOptions } from './normalize.js';
+export interface HtmlOptions extends CompileOptions {
+    title?: string;
+}
+/**
+ * Emits a self-contained page: the normalized IR as data, plus the generic runtime. No
+ * part of this output is derived from what the application is about.
+ */
+export declare function compileIRToHtml(ir: ApplicationIR, options?: HtmlOptions): string;
+export declare function compileToHtml(graph: ApplicationGraph, options?: HtmlOptions): string;
+//# sourceMappingURL=codegen.d.ts.map

package/dist/codegen.js

@@ -0,0 +1,77 @@
+import { createRuntimeModuleSource } from '@cynodia/axiom-runtime';
+import { compileToIR } from './normalize.js';
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function escapeForScript(value) {
+    return value.replace(/<\/script/gi, '<\\/script');
+}
+/** Domain-neutral styling for the semantic UI vocabulary. */
+const STYLESHEET = `
+:root { color-scheme: light; font-family: Inter, system-ui, sans-serif; }
+body { margin: 0; background: #f4f7fb; color: #1f2937; }
+#app { padding: 24px; max-width: 1100px; margin: 0 auto; }
+.axiom-view { display: grid; gap: 16px; }
+.axiom-container { display: flex; gap: 12px; }
+.axiom-layout-vertical { flex-direction: column; align-items: stretch; }
+.axiom-layout-horizontal { flex-direction: row; align-items: center; flex-wrap: wrap; }
+.axiom-layout-stack { flex-direction: column; gap: 4px; }
+.axiom-view > .axiom-container,
+.axiom-view > .axiom-form { background: #ffffff; border-radius: 16px; padding: 20px; box-shadow: 0 18px 40px rgba(15, 23, 42, 0.08); }
+.axiom-repeat { display: grid; gap: 10px; }
+.axiom-field { display: flex; gap: 8px; align-items: baseline; }
+.axiom-field-label { color: #64748b; font-size: 13px; }
+.axiom-field-value { font-weight: 500; }
+.axiom-form { display: grid; gap: 12px; }
+.axiom-input { display: grid; gap: 6px; }
+.axiom-input-label { font-size: 13px; color: #475569; }
+.axiom-control { font: inherit; border: 1px solid #cbd5e1; border-radius: 10px; padding: 10px 12px; width: 100%; box-sizing: border-box; }
+textarea.axiom-control { min-height: 120px; resize: vertical; }
+input[type="checkbox"].axiom-control { width: auto; }
+.axiom-button { font: inherit; border: none; border-radius: 10px; padding: 10px 14px; background: #2563eb; color: #ffffff; cursor: pointer; }
+.axiom-button.axiom-destructive, .axiom-role-danger { background: #dc2626; }
+.axiom-role-secondary { background: #64748b; }
+.axiom-emphasis-strong { font-weight: 700; font-size: 18px; }
+.axiom-density-compact { padding: 6px 10px; }
+.axiom-no-route { padding: 20px; background: #ffffff; border-radius: 12px; }
+`.trim();
+/**
+ * Emits a self-contained page: the normalized IR as data, plus the generic runtime. No
+ * part of this output is derived from what the application is about.
+ */
+export function compileIRToHtml(ir, options = {}) {
+    const runtimeSource = createRuntimeModuleSource();
+    const payload = escapeForScript(JSON.stringify(ir));
+    const title = options.title ?? ir.name;
+    return [
+        '<!DOCTYPE html>',
+        '<html lang="en">',
+        '<head>',
+        '  <meta charset="utf-8" />',
+        '  <meta name="viewport" content="width=device-width, initial-scale=1" />',
+        `  <title>${escapeHtml(title)}</title>`,
+        '  <style>',
+        STYLESHEET,
+        '  </style>',
+        '</head>',
+        '<body>',
+        '  <div id="app"></div>',
+        '  <script type="module">',
+        runtimeSource,
+        `const __AXIOM_IR__ = ${payload};`,
+        'const __axiomRoot = document.getElementById("app");',
+        'const __axiomApp = createAxiomRuntime({ ir: __AXIOM_IR__, rootElement: __axiomRoot, host: createBrowserHost() });',
+        'globalThis.__AXIOM_APP__ = __axiomApp;',
+        '__axiomApp.start();',
+        '  </script>',
+        '</body>',
+        '</html>',
+    ].join('\n');
+}
+export function compileToHtml(graph, options = {}) {
+    return compileIRToHtml(compileToIR(graph, options), options);
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './normalize.js';
+export * from './codegen.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './normalize.js';
+export * from './codegen.js';

package/dist/normalize.d.ts

@@ -0,0 +1,16 @@
+import type { ApplicationGraph, ApplicationIR, ValidationIssue, ValidationResult } from '@cynodia/axiom-core';
+export declare class GraphValidationError extends Error {
+    readonly problems: ValidationIssue[];
+    constructor(result: ValidationResult);
+}
+export interface CompileOptions {
+    /** Compilation refuses invalid graphs by default; disable only for diagnostics. */
+    validate?: boolean;
+}
+/**
+ * Validates a graph and normalizes it into the runtime-ready IR: references resolved,
+ * lookups indexed, routes pre-compiled and ordered most-specific-first.
+ */
+export declare function compileToIR(graph: ApplicationGraph, options?: CompileOptions): ApplicationIR;
+export declare function serializeIR(ir: ApplicationIR): string;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/normalize.js

@@ -0,0 +1,116 @@
+import { inferLocationType, locationRootStateId, semanticContextFromGraph, validateGraph, } from '@cynodia/axiom-core';
+import { isUINode } from '@cynodia/axiom-core';
+export class GraphValidationError extends Error {
+    problems;
+    constructor(result) {
+        super(`Application graph is invalid:\n${result.errors
+            .map((problem) => `  [${problem.code}] ${problem.message}`)
+            .join('\n')}`);
+        this.name = 'GraphValidationError';
+        this.problems = result.errors;
+    }
+}
+function compileRoute(route) {
+    const parameters = route.parameters ?? [];
+    const segments = route.path
+        .split('/')
+        .filter(Boolean)
+        .map((segment) => {
+        if (!segment.startsWith(':')) {
+            return { kind: 'static', value: segment };
+        }
+        const name = segment.slice(1);
+        const parameter = parameters.find((candidate) => candidate.name === name);
+        return { kind: 'parameter', value: name, ...(parameter ? { parameterId: parameter.id } : {}) };
+    });
+    return {
+        id: route.id,
+        path: route.path,
+        viewId: route.viewId,
+        segments,
+        parameters,
+        specificity: segments.filter((segment) => segment.kind === 'parameter').length,
+    };
+}
+/**
+ * Validates a graph and normalizes it into the runtime-ready IR: references resolved,
+ * lookups indexed, routes pre-compiled and ordered most-specific-first.
+ */
+export function compileToIR(graph, options = {}) {
+    if (options.validate !== false) {
+        const result = validateGraph(graph);
+        if (!result.valid) {
+            throw new GraphValidationError(result);
+        }
+    }
+    const nodes = {};
+    const actions = {};
+    const uiNodes = {};
+    const entities = [];
+    const states = [];
+    const constraints = [];
+    const routes = [];
+    for (const node of graph.listNodes()) {
+        nodes[node.id] = node;
+        if (isUINode(node)) {
+            uiNodes[node.id] = node;
+            continue;
+        }
+        switch (node.kind) {
+            case 'entity':
+                entities.push(node);
+                break;
+            case 'state':
+                states.push(node);
+                break;
+            case 'action':
+                actions[node.id] = node;
+                break;
+            case 'constraint':
+                constraints.push(node);
+                break;
+            case 'route':
+                routes.push(compileRoute(node));
+                break;
+            default:
+        }
+    }
+    routes.sort((left, right) => left.specificity - right.specificity || left.path.localeCompare(right.path));
+    const fields = {};
+    for (const entry of graph.listFields()) {
+        fields[entry.field.id] = entry;
+    }
+    // Resolve what each input writes to, so the runtime carries no type inference itself.
+    const semantics = semanticContextFromGraph(graph);
+    const locationTypes = {};
+    const locationRoots = {};
+    for (const node of Object.values(uiNodes)) {
+        if (node.kind !== 'input') {
+            continue;
+        }
+        const resolved = inferLocationType(node.binding.location, semantics);
+        if (resolved) {
+            locationTypes[node.id] = resolved;
+        }
+        locationRoots[node.id] = locationRootStateId(node.binding.location);
+    }
+    return {
+        id: graph.id,
+        name: graph.name,
+        version: graph.version,
+        nodes,
+        fields,
+        entities,
+        states,
+        actions,
+        uiNodes,
+        constraints,
+        routes,
+        edges: graph.listEdges(),
+        locationTypes,
+        locationRoots,
+    };
+}
+export function serializeIR(ir) {
+    return JSON.stringify(ir);
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@cynodia/axiom-compiler",
+  "version": "0.3.1-alpha.1",
+  "description": "Normalizes an Axiom application graph and emits a self-contained page.",
+  "license": "MIT",
+  "author": "AskTech AS",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cynodia/axiom.git"
+  },
+  "homepage": "https://github.com/cynodia/axiom",
+  "bugs": {
+    "url": "https://github.com/cynodia/axiom/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@cynodia/axiom-core": "0.3.1-alpha.1",
+    "@cynodia/axiom-runtime": "0.3.1-alpha.1"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json tsconfig.test.json",
+    "test": "node --test dist-test/**/*.test.js"
+  }
+}