@cynodia/axiom-ui 0.7.0-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,83 @@
+# @cynodia/axiom-ui
+
+Semantic UI authoring for [Axiom](https://github.com/cynodia/axiom). Pre-release
+(`0.7.0-alpha.1`); the API may change.
+
+A pattern compresses a recurring UX concept into a declaration and expands it, **at authoring
+time**, into ordinary Axiom UI nodes. It has no runtime existence, renders nothing and owns
+no state. After expansion the application is a canonical Axiom application that validates,
+compiles, executes and renders with this package uninstalled.
+
+```bash
+npm install @cynodia/axiom @cynodia/axiom-ui
+```
+
+```ts
+import { axiomUi } from '@cynodia/axiom-ui';
+
+axiomUi.expand(graph, {
+  pattern: 'page',
+  instance: 'products',
+  title: 'Products',
+  content: [
+    { pattern: 'entity-list', instance: 'product_list', source: STATE_PRODUCTS },
+    { pattern: 'entity-form', instance: 'new_product', draft: STATE_DRAFT, submit: ACTION_ADD },
+  ],
+});
+```
+
+That declaration produces the containers, the heading levels, the landmark roles, the field
+labels, the value formats implied by each field's type, the empty state, the responsive
+stacking, the required markers and the diagnostic region. None of it was ever specific to
+this application, which is what makes it the pattern's business rather than the author's.
+
+## Five patterns
+
+| | |
+| --- | --- |
+| `page` | A titled page: header region, page-level actions, content region. `title` accepts an expression. |
+| `metric-grid` | A reflowing grid of named measures. Labels are inferred from the state each value reads. |
+| `entity-list` | One row per member of a collection, with per-row actions and an empty state. |
+| `entity-form` | Creates a record in a draft state, **or edits an existing one** addressed by expression. Fields can offer a choice drawn from application data. |
+| `action-bar` | A group of controls whose emphasis comes from what the actions *are*. |
+
+Five, deliberately. A new pattern needs evidence that the intent recurs, that its inference is
+meaningful, and that canonical primitives alone are repetitive — not that a composition was
+missing. See [`docs/TOOLKIT_AGENT_REFERENCE.md`](docs/TOOLKIT_AGENT_REFERENCE.md#when-not-to-add-a-pattern).
+
+## When not to use a pattern
+
+```
+pattern            ordinary recurring application UX
+   ↓
+canonical nodes    custom composition that is already expressible
+   ↓
+renderer escape    genuinely unsupported presentation (a class name, and nothing more)
+```
+
+A dialog, a focus trap or a keyboard scheme is **not** a pattern: a pattern can only emit
+nodes that already exist, and interaction behaviour is not a node. Those are canonical
+semantics in `@cynodia/axiom-core` — see `docs/UI.md` in the facade package.
+
+## Ownership
+
+The declaration is the source of truth by default. A generated node is a build artifact:
+re-expansion is authoritative, and editing one is **drift**, which `detectDrift` reports per
+node and per property rather than silently overwriting. `materializePattern` is the explicit
+alternative — it hands the nodes to the graph, after which the declaration is history and
+edits are legitimate. Details in [`docs/OWNERSHIP.md`](docs/OWNERSHIP.md).
+
+## Documentation
+
+| | |
+| --- | --- |
+| [`docs/TOOLKIT_AGENT_REFERENCE.md`](docs/TOOLKIT_AGENT_REFERENCE.md) | Start here. The whole contract. |
+| [`docs/PATTERN_CATALOG.json`](docs/PATTERN_CATALOG.json) | Machine-readable: inputs, inferred values, **and the generated tree**. Generated from the definitions. |
+| [`docs/OWNERSHIP.md`](docs/OWNERSHIP.md) | Who owns a generated node after expansion, and how drift is resolved. |
+| [`docs/PROVENANCE.md`](docs/PROVENANCE.md) | What a node remembers about how it was authored, and why it never ships. |
+| [`docs/PATTERN_AUTHORING.md`](docs/PATTERN_AUTHORING.md) | Defining a pattern outside this package: 0 core, compiler, runtime or renderer changes. |
+
+The catalogue is addressable from outside the package as `@cynodia/axiom-ui/catalog`, and a
+worked reference application as `@cynodia/axiom-ui/example`.
+
+MIT © AskTech AS

package/dist/catalog.d.ts

@@ -0,0 +1,32 @@
+import type { PatternInput } from './pattern.js';
+import type { Toolkit } from './expand.js';
+/**
+ * The machine-readable catalogue.
+ *
+ * The thesis under test (§48): for an agent, a queryable schema is worth more than prose. An
+ * agent that can ask what a pattern requires does not have to read the implementation, guess
+ * from an example, or discover a required input by causing a failure.
+ */
+export interface PatternDescription {
+    name: string;
+    purpose: string;
+    required: string[];
+    optional: string[];
+    inputs: Record<string, PatternInput>;
+    slots: readonly string[];
+    produces: readonly string[];
+    /** The generated tree, part by part. Ids are `ui_<instance>_<part>`. */
+    expansion: readonly {
+        part: string;
+        kind: string;
+        role: string;
+    }[];
+    /** How a generated id is built, so an author can reference one before it exists. */
+    generatedIdFormat: string;
+    /** What the pattern works out for itself, and from what. */
+    inferred: Record<string, string>;
+}
+export declare function listPatterns(toolkit: Toolkit): string[];
+export declare function describePattern(toolkit: Toolkit, name: string): PatternDescription | undefined;
+export declare function describeToolkit(toolkit: Toolkit): PatternDescription[];
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.js

@@ -0,0 +1,29 @@
+export function listPatterns(toolkit) {
+    return [...toolkit.patterns.keys()].sort();
+}
+export function describePattern(toolkit, name) {
+    const definition = toolkit.patterns.get(name);
+    if (!definition) {
+        return undefined;
+    }
+    const entries = Object.entries(definition.inputs);
+    return {
+        name: definition.name,
+        purpose: definition.purpose,
+        required: entries.filter(([, input]) => input.required).map(([key]) => key),
+        optional: entries.filter(([, input]) => !input.required).map(([key]) => key),
+        inputs: definition.inputs,
+        slots: definition.slots,
+        produces: definition.produces,
+        expansion: definition.expansion,
+        generatedIdFormat: 'ui_<instance>_<part>, or ui_<instance>_<part>_<index> for a repeated part',
+        inferred: Object.fromEntries(entries
+            .filter(([, input]) => input.inferredWhenAbsent !== undefined)
+            .map(([key, input]) => [key, input.inferredWhenAbsent])),
+    };
+}
+export function describeToolkit(toolkit) {
+    return listPatterns(toolkit)
+        .map((name) => describePattern(toolkit, name))
+        .filter((entry) => entry !== undefined);
+}

package/dist/example/app.d.ts

@@ -0,0 +1,6 @@
+import type { ApplicationGraph, NodeId } from '@cynodia/axiom-core';
+import type { ExpansionModel } from '../pattern.js';
+export declare function createToolkitApplication(model?: ExpansionModel): ApplicationGraph;
+/** The route parameter a product detail page is addressed by. */
+export declare const PARAM_ROUTE_CODE: NodeId;
+//# sourceMappingURL=app.d.ts.map

package/dist/example/app.js

@@ -0,0 +1,365 @@
+import { binary, call, field, find, groupItems, groupKey, literal, nodeId, ref } from '@cynodia/axiom-core';
+import { axiomUi } from '../toolkit.js';
+import { rowField } from '../patterns/entity-list.js';
+import { ACTION_ADD_PRODUCT, ACTION_ADD_CUSTOMER, ACTION_ASK_CANCEL, ACTION_CANCEL_ORDER, ACTION_CONFIRM_ORDER, ACTION_DELETE_PRODUCT, ACTION_DISMISS_CANCEL, ACTION_PLACE_ORDER, ACTION_RESTOCK_ALL, F_CUSTOMER_ID, F_CUSTOMER_NAME, F_ORDER_CUSTOMER, F_ORDER_ID, F_ORDER_PRODUCT, F_PRODUCT_ID, F_PRODUCT_NAME, F_PRODUCT_PRICE, F_PRODUCT_STOCK, PARAM_AMOUNT, PARAM_ORDER, PARAM_PRODUCT, STATE_CANCELLING, STATE_CUSTOMERS, STATE_DRAFT_CUSTOMER, STATE_DRAFT_ORDER, STATE_DRAFT_PRODUCT, STATE_LOW_STOCK, STATE_LOW_STOCK_PRODUCTS, STATE_ORDERS, STATE_ORDERS_BY_STATUS, STATE_ORDER_COUNT, STATE_PRODUCTS, STATE_REVENUE, createOrderDomain, } from './domain.js';
+/**
+ * The reference application, declared through toolkit patterns.
+ *
+ * Read the two side by side: everything the baseline spells out — the header containers, the
+ * heading levels, the empty states, the labels, the formats a type already implies, the
+ * responsive stacking, the action-group wrappers, the diagnostic regions — is absent here,
+ * not because it is missing from the result but because nothing about it was ever specific
+ * to this application.
+ */
+const NAV = nodeId('ui_nav');
+export function createToolkitApplication(model = 'provenance') {
+    const graph = createOrderDomain();
+    const expand = (declaration) => axiomUi.expand(graph, declaration, { model });
+    // readme-toolkit:start
+    const dashboard = expand({
+        pattern: 'page',
+        instance: 'dashboard',
+        title: 'Dashboard',
+        description: 'Today across the desk.',
+        content: [
+            {
+                pattern: 'metric-grid',
+                instance: 'dash_metrics',
+                // No labels: each of these states is already named in the graph, and prose
+                // duplicated is prose that can disagree.
+                metrics: [
+                    { value: ref(STATE_ORDER_COUNT) },
+                    { value: ref(STATE_REVENUE), format: { kind: 'currency', currency: 'NOK' } },
+                    { value: ref(STATE_LOW_STOCK), emphasis: 'strong' },
+                ],
+            },
+        ],
+    });
+    const products = expand({
+        pattern: 'page',
+        instance: 'products',
+        title: 'Products',
+        content: [
+            {
+                pattern: 'entity-list',
+                instance: 'product_list',
+                source: STATE_PRODUCTS,
+                fields: [F_PRODUCT_NAME, F_PRODUCT_PRICE, F_PRODUCT_STOCK],
+                formats: { [F_PRODUCT_PRICE]: { kind: 'currency', currency: 'NOK' } },
+                rowActions: [ACTION_DELETE_PRODUCT],
+                rowArguments: { [ACTION_DELETE_PRODUCT]: { [PARAM_PRODUCT]: rowField('product_list', F_PRODUCT_ID) } },
+                emptyMessage: 'No products yet.',
+                emptyAction: ACTION_ADD_PRODUCT,
+            },
+            {
+                pattern: 'entity-form',
+                instance: 'new_product',
+                draft: STATE_DRAFT_PRODUCT,
+                submit: ACTION_ADD_PRODUCT,
+                title: 'New product',
+            },
+        ],
+    });
+    const customers = expand({
+        pattern: 'page',
+        instance: 'customers',
+        title: 'Customers',
+        content: [
+            {
+                pattern: 'entity-list',
+                instance: 'customer_list',
+                source: STATE_CUSTOMERS,
+                emptyMessage: 'No customers yet.',
+                emptyAction: ACTION_ADD_CUSTOMER,
+            },
+            {
+                pattern: 'entity-form',
+                instance: 'new_customer',
+                draft: STATE_DRAFT_CUSTOMER,
+                submit: ACTION_ADD_CUSTOMER,
+                title: 'New customer',
+            },
+        ],
+    });
+    const orders = expand({
+        pattern: 'page',
+        instance: 'orders',
+        title: 'Orders',
+        description: 'Everything placed, newest first.',
+        content: [
+            {
+                pattern: 'entity-list',
+                instance: 'order_list',
+                source: STATE_ORDERS,
+                formats: { [nodeId('field_order_total')]: { kind: 'currency', currency: 'NOK' } },
+                rowActions: [ACTION_CONFIRM_ORDER, ACTION_ASK_CANCEL],
+                rowArguments: {
+                    [ACTION_CONFIRM_ORDER]: { [PARAM_ORDER]: rowField('order_list', F_ORDER_ID) },
+                    [ACTION_ASK_CANCEL]: { [PARAM_ORDER]: rowField('order_list', F_ORDER_ID) },
+                },
+                emptyMessage: 'No orders yet.',
+                emptyAction: ACTION_PLACE_ORDER,
+            },
+        ],
+    });
+    const editor = expand({
+        pattern: 'page',
+        instance: 'editor',
+        title: 'New order',
+        content: [
+            {
+                pattern: 'entity-form',
+                instance: 'new_order',
+                draft: STATE_DRAFT_ORDER,
+                submit: ACTION_PLACE_ORDER,
+                // A customer and a product are chosen from application data, not typed. This is the
+                // form Phase 2 had to hand-build, because no pattern input could carry a choice.
+                options: {
+                    [F_ORDER_CUSTOMER]: {
+                        source: ref(STATE_CUSTOMERS),
+                        scopeId: nodeId('scope_customer_option'),
+                        valueFieldId: F_CUSTOMER_ID,
+                        labelFieldId: F_CUSTOMER_NAME,
+                    },
+                    [F_ORDER_PRODUCT]: {
+                        source: ref(STATE_PRODUCTS),
+                        scopeId: nodeId('scope_product_option'),
+                        valueFieldId: F_PRODUCT_ID,
+                        labelFieldId: F_PRODUCT_NAME,
+                    },
+                },
+            },
+        ],
+    });
+    // readme-toolkit:end
+    /**
+     * Everything below exercises capabilities the hand-built baseline does not attempt, so it
+     * sits outside the measured region: the comparison in `test/baseline.ts` stays like for
+     * like, and the compression figure keeps meaning what it says.
+     */
+    const detail = expand({
+        pattern: 'page',
+        // A detail page titled by the record it is about, which needs `title` to be an
+        // expression. It was the most visible compromise Phase 2 found.
+        instance: 'product_detail',
+        title: field(productInRoute(), F_PRODUCT_NAME),
+        description: field(productInRoute(), F_PRODUCT_ID),
+        actions: [
+            {
+                pattern: 'action-bar',
+                instance: 'detail_actions',
+                actions: [ACTION_DELETE_PRODUCT],
+                arguments: { [ACTION_DELETE_PRODUCT]: { [PARAM_PRODUCT]: ref(PARAM_ROUTE_CODE) } },
+            },
+        ],
+        content: [
+            {
+                pattern: 'entity-form',
+                instance: 'edit_product',
+                // Edit, not create: the controls write into the addressed member of the collection.
+                target: { state: STATE_PRODUCTS, identity: ref(PARAM_ROUTE_CODE) },
+                submit: ACTION_ADD_PRODUCT,
+                submitLabel: 'Done',
+                title: 'Details',
+            },
+        ],
+    });
+    const restock = expand({
+        pattern: 'page',
+        instance: 'restock',
+        title: 'Restock',
+        description: 'Everything at or below the reorder threshold.',
+        actions: [
+            {
+                pattern: 'action-bar',
+                instance: 'restock_actions',
+                actions: [ACTION_RESTOCK_ALL],
+                arguments: { [ACTION_RESTOCK_ALL]: { [PARAM_AMOUNT]: literal(25) } },
+            },
+        ],
+        content: [
+            {
+                pattern: 'entity-list',
+                instance: 'low_stock_list',
+                // The derived collection, which is the named calculation again.
+                source: STATE_LOW_STOCK_PRODUCTS,
+                fields: [F_PRODUCT_NAME, F_PRODUCT_STOCK],
+                emptyMessage: 'Nothing needs restocking.',
+                emptyAction: ACTION_ADD_PRODUCT,
+            },
+            groupedOrders(graph),
+        ],
+    });
+    addCancellationDialog(graph);
+    // reference-extras:end
+    addNavigation(graph);
+    addViews(graph, { dashboard, products, customers, orders, editor, detail, restock });
+    return graph;
+}
+/** The route parameter a product detail page is addressed by. */
+export const PARAM_ROUTE_CODE = nodeId('route_param_code');
+const DIALOG = nodeId('ui_cancel_dialog');
+const SCOPE_ROUTE_PRODUCT = nodeId('scope_route_product');
+const SCOPE_STATUS_GROUP = nodeId('scope_status_group');
+const SCOPE_STATUS_MEMBER = nodeId('scope_status_member');
+/** The product the route names. Ordinary semantics: a find over the collection. */
+function productInRoute() {
+    return find(ref(STATE_PRODUCTS), SCOPE_ROUTE_PRODUCT, binary('eq', field(ref(SCOPE_ROUTE_PRODUCT), F_PRODUCT_ID), ref(PARAM_ROUTE_CODE)));
+}
+/**
+ * Orders grouped by status: patterns for the ordinary parts, canonical nodes for this.
+ *
+ * No pattern produces it and none should — this is a `group` expression rendered by a
+ * `repeat`, which is exactly the composition the escape hierarchy exists for. It is also
+ * what the absence of `group` made expensive in Phase 2: a loop over the statuses known at
+ * authoring time, three near-identical filters per status.
+ */
+function groupedOrders(graph) {
+    graph.addNode({
+        id: nodeId('ui_status_heading'),
+        kind: 'text',
+        value: call('concat', groupKey(ref(nodeId('ui_status_rows'))), literal(' — '), call('to-string', call('count', groupItems(ref(nodeId('ui_status_rows')))))),
+        presentation: { textRole: 'heading', headingLevel: 3 },
+    });
+    graph.addNode({
+        id: nodeId('ui_status_rows'),
+        kind: 'repeat',
+        source: ref(STATE_ORDERS_BY_STATUS),
+        templateId: nodeId('ui_status_heading'),
+        presentation: { layout: { kind: 'vertical', gap: 'small' } },
+    });
+    // A section heading, so the outline goes 1 → 2 → 3 rather than skipping a level. The
+    // framework catches that omission as INVALID_HEADING_STRUCTURE; it caught this one.
+    graph.addNode({
+        id: nodeId('ui_status_title'),
+        kind: 'text',
+        value: 'Orders by status',
+        presentation: { textRole: 'heading', headingLevel: 2 },
+    });
+    graph.addNode({
+        id: nodeId('ui_status_section'),
+        kind: 'container',
+        name: 'Orders by status',
+        children: [nodeId('ui_status_title'), nodeId('ui_status_rows')],
+        presentation: { surface: 'inset', padding: 'medium', layout: { kind: 'vertical', gap: 'small' } },
+    });
+    return nodeId('ui_status_section');
+}
+/**
+ * A modal confirmation before a destructive action.
+ *
+ * The graph says what is open, what it is called, what it contains and what closes it. Focus
+ * entry, containment, `Escape`, focus return and the ARIA relationships are the runtime's,
+ * and no application writes a line of them.
+ *
+ * The dialog does not *authorize* anything: `cancelOrder` is guarded on the same state that
+ * opens the dialog, so invoking it without confirming is refused whatever is on screen.
+ */
+function addCancellationDialog(graph) {
+    graph.addNode({
+        id: nodeId('ui_cancel_question'),
+        kind: 'text',
+        value: call('concat', literal('Cancel order '), ref(STATE_CANCELLING), literal('? This cannot be undone.')),
+    });
+    graph.addNode({
+        id: nodeId('ui_cancel_confirm'),
+        kind: 'button',
+        label: 'Cancel order',
+        actionId: ACTION_CANCEL_ORDER,
+        arguments: { [PARAM_ORDER]: ref(STATE_CANCELLING) },
+    });
+    graph.addNode({
+        id: nodeId('ui_cancel_dismiss'),
+        kind: 'button',
+        label: 'Keep order',
+        actionId: ACTION_DISMISS_CANCEL,
+    });
+    graph.addNode({
+        id: DIALOG,
+        kind: 'dialog',
+        openWhen: call('non-empty', ref(STATE_CANCELLING)),
+        title: 'Cancel this order?',
+        description: 'The order is removed. Nothing else changes.',
+        children: [nodeId('ui_cancel_question'), nodeId('ui_cancel_confirm'), nodeId('ui_cancel_dismiss')],
+        closeActionId: ACTION_DISMISS_CANCEL,
+        modal: true,
+        initialFocusId: nodeId('ui_cancel_dismiss'),
+    });
+}
+/**
+ * Navigation is deliberately *not* a pattern.
+ *
+ * It was a candidate, and leaving it out is a finding: a navigation shell is bound to an
+ * application's route table, which the toolkit has no business knowing. Compressing it would
+ * have meant a pattern that reads routes and generates actions — hidden action generation,
+ * which the anti-pattern catalogue rejects.
+ */
+function addNavigation(graph) {
+    const navAction = nodeId('action_navigate');
+    graph.addNode({
+        id: navAction,
+        kind: 'action',
+        name: 'Go',
+        parameters: [{ id: nodeId('param_path'), valueType: { kind: 'primitive', primitive: 'string' } }],
+        operations: [{ kind: 'navigate', path: '/' }],
+    });
+    const entries = [
+        ['ui_nav_dashboard', 'Dashboard', '/'],
+        ['ui_nav_products', 'Products', '/products'],
+        ['ui_nav_customers', 'Customers', '/customers'],
+        ['ui_nav_orders', 'Orders', '/orders'],
+    ];
+    const children = entries.map(([id, label, path]) => {
+        graph.addNode({
+            id: nodeId(id),
+            kind: 'button',
+            label,
+            actionId: navAction,
+            arguments: { [nodeId('param_path')]: literal(path) },
+            presentation: { uxRole: 'navigation-action' },
+        });
+        return nodeId(id);
+    });
+    graph.addNode({
+        id: NAV,
+        kind: 'container',
+        children,
+        presentation: { uxRole: 'navigation-group', layout: { kind: 'horizontal', gap: 'small', wrap: true } },
+    });
+}
+function addViews(graph, pages) {
+    const screens = [
+        ['dashboard', 'Dashboard', pages.dashboard, '/'],
+        ['products', 'Products', pages.products, '/products'],
+        ['customers', 'Customers', pages.customers, '/customers'],
+        ['orders', 'Orders', pages.orders, '/orders'],
+        ['editor', 'New order', pages.editor, '/orders/new'],
+        ['restock', 'Restock', pages.restock, '/restock'],
+    ];
+    for (const [key, name, pageId, path] of screens) {
+        const viewId = nodeId(`ui_view_${key}`);
+        graph.addNode({
+            id: viewId,
+            kind: 'view',
+            name,
+            // The dialog lives on the view whose rows open it. A closed dialog renders nothing.
+            children: key === 'orders' ? [NAV, pageId, DIALOG] : [NAV, pageId],
+        });
+        graph.addNode({ id: nodeId(`route_${key}`), kind: 'route', path, viewId });
+    }
+    // A route with a parameter, which is what the detail page's title and form address.
+    graph.addNode({
+        id: nodeId('ui_view_detail'),
+        kind: 'view',
+        name: 'Product',
+        children: [NAV, pages.detail],
+    });
+    graph.addNode({
+        id: nodeId('route_detail'),
+        kind: 'route',
+        path: '/products/:code',
+        viewId: nodeId('ui_view_detail'),
+        parameters: [{ id: PARAM_ROUTE_CODE, name: 'code', valueType: { kind: 'primitive', primitive: 'string' } }],
+    });
+}
+void field;

package/dist/example/domain.d.ts

@@ -0,0 +1,71 @@
+import { ApplicationGraph } from '@cynodia/axiom-core';
+import type { Expression } from '@cynodia/axiom-core';
+/**
+ * The order-management domain used by both research applications.
+ *
+ * **Business semantics only** — entities, state, actions, constraints. No UI, no
+ * presentation, no routes. Both the baseline application and the toolkit application build
+ * their UI on top of this identical graph, which is what makes the comparison a comparison of
+ * UI authoring rather than of two different applications.
+ */
+export declare const ENTITY_PRODUCT: import("@cynodia/axiom-core").NodeId;
+export declare const F_PRODUCT_ID: import("@cynodia/axiom-core").FieldId;
+export declare const F_PRODUCT_NAME: import("@cynodia/axiom-core").FieldId;
+export declare const F_PRODUCT_PRICE: import("@cynodia/axiom-core").FieldId;
+export declare const F_PRODUCT_STOCK: import("@cynodia/axiom-core").FieldId;
+export declare const F_PRODUCT_ACTIVE: import("@cynodia/axiom-core").FieldId;
+export declare const ENTITY_CUSTOMER: import("@cynodia/axiom-core").NodeId;
+export declare const F_CUSTOMER_ID: import("@cynodia/axiom-core").FieldId;
+export declare const F_CUSTOMER_NAME: import("@cynodia/axiom-core").FieldId;
+export declare const F_CUSTOMER_EMAIL: import("@cynodia/axiom-core").FieldId;
+export declare const F_CUSTOMER_SINCE: import("@cynodia/axiom-core").FieldId;
+export declare const ENTITY_ORDER: import("@cynodia/axiom-core").NodeId;
+export declare const F_ORDER_ID: import("@cynodia/axiom-core").FieldId;
+export declare const F_ORDER_CUSTOMER: import("@cynodia/axiom-core").FieldId;
+export declare const F_ORDER_PRODUCT: import("@cynodia/axiom-core").FieldId;
+export declare const F_ORDER_QUANTITY: import("@cynodia/axiom-core").FieldId;
+export declare const F_ORDER_TOTAL: import("@cynodia/axiom-core").FieldId;
+export declare const F_ORDER_STATUS: import("@cynodia/axiom-core").FieldId;
+export declare const STATE_PRODUCTS: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_CUSTOMERS: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_ORDERS: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_DRAFT_PRODUCT: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_DRAFT_ORDER: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_DRAFT_CUSTOMER: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_ORDER_COUNT: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_REVENUE: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_LOW_STOCK: import("@cynodia/axiom-core").NodeId;
+export declare const STATE_LOW_STOCK_PRODUCTS: import("@cynodia/axiom-core").NodeId;
+/** Orders partitioned by status: a `group` expression, not four filters. */
+export declare const STATE_ORDERS_BY_STATUS: import("@cynodia/axiom-core").NodeId;
+/** Which order the person has asked to cancel. Ephemeral: a UI fact, not a domain one. */
+export declare const STATE_CANCELLING: import("@cynodia/axiom-core").NodeId;
+/** The reorder threshold, so the rule below reads it rather than hard-coding it. */
+export declare const STATE_THRESHOLD: import("@cynodia/axiom-core").NodeId;
+/**
+ * "the products at or below the reorder threshold", named once.
+ *
+ * Three consumers read it: the dashboard figure, the restock warning's visibility, and the
+ * guard on the bulk-restock action. Written out, that is the same filter three times with
+ * three scope ids — which is where the Phase 2 agent collided with itself.
+ */
+export declare const EXPRESSION_LOW_STOCK: import("@cynodia/axiom-core").NodeId;
+export declare const PARAM_STOCK_SOURCE: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_ADD_PRODUCT: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_DELETE_PRODUCT: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_RESTOCK: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_ADD_CUSTOMER: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_PLACE_ORDER: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_CONFIRM_ORDER: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_CANCEL_ORDER: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_ASK_CANCEL: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_DISMISS_CANCEL: import("@cynodia/axiom-core").NodeId;
+export declare const ACTION_RESTOCK_ALL: import("@cynodia/axiom-core").NodeId;
+export declare const PARAM_PRODUCT: import("@cynodia/axiom-core").NodeId;
+export declare const PARAM_ORDER: import("@cynodia/axiom-core").NodeId;
+export declare const PARAM_AMOUNT: import("@cynodia/axiom-core").NodeId;
+/** The one calculation, referenced. Every consumer says this and nothing more. */
+export declare const lowStock: () => Expression;
+/** Entities, state, behaviour and rules. Nothing here knows a UI exists. */
+export declare function createOrderDomain(): ApplicationGraph;
+//# sourceMappingURL=domain.d.ts.map