@cynodia/axiom-core 0.8.0-alpha.1 → 0.8.2-alpha.1

package/dist/diagnostics.d.ts

@@ -101,5 +101,11 @@ export declare const VALIDATION_CODES: {
     readonly unknownEvent: "UNKNOWN_EVENT";
     /** An `event` trigger targeting a client-authority action, or a `route-enter`/`route-leave` trigger targeting a server-authority one. */
     readonly triggerWrongAuthority: "TRIGGER_WRONG_AUTHORITY";
+    /** A trigger — which always invokes with `source: 'system'` — targets an action whose `invocation.allowedSources` excludes `'system'`; the trigger could never succeed. */
+    readonly triggerTargetSourceMismatch: "TRIGGER_TARGET_SOURCE_MISMATCH";
+    /** `ActionDef.invocation.allowedSources` is present but empty — the action could never be invoked at all. */
+    readonly invalidInvocationSource: "INVALID_INVOCATION_SOURCE";
+    /** A client-authority trigger of a kind the intended trigger runtime does not execute — it would validate and compile but never fire (spec 8.1 §31-36). */
+    readonly clientTriggerUnsupported: "CLIENT_TRIGGER_UNSUPPORTED";
 };
 //# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.js

@@ -90,4 +90,10 @@ export const VALIDATION_CODES = {
     unknownEvent: 'UNKNOWN_EVENT',
     /** An `event` trigger targeting a client-authority action, or a `route-enter`/`route-leave` trigger targeting a server-authority one. */
     triggerWrongAuthority: 'TRIGGER_WRONG_AUTHORITY',
+    /** A trigger — which always invokes with `source: 'system'` — targets an action whose `invocation.allowedSources` excludes `'system'`; the trigger could never succeed. */
+    triggerTargetSourceMismatch: 'TRIGGER_TARGET_SOURCE_MISMATCH',
+    /** `ActionDef.invocation.allowedSources` is present but empty — the action could never be invoked at all. */
+    invalidInvocationSource: 'INVALID_INVOCATION_SOURCE',
+    /** A client-authority trigger of a kind the intended trigger runtime does not execute — it would validate and compile but never fire (spec 8.1 §31-36). */
+    clientTriggerUnsupported: 'CLIENT_TRIGGER_UNSUPPORTED',
 };

package/dist/effect-outcome.d.ts

@@ -0,0 +1,43 @@
+import type { FieldId, NodeId } from './ids.js';
+import type { EntityDef } from './nodes.js';
+import type { TypeRef } from './type-ref.js';
+/**
+ * Reserved field ids for an `integration-effect`'s `succeededEventId`/`failedEventId`
+ * payload — spec 8.1 §37-41's structured envelope, replacing the 0.8.0 shape (the raw
+ * adapter result for success, a formatted `"<code>: <message>"` string for failure) that
+ * forced a follow-up action to parse text to correlate a failure back to the effect that
+ * caused it.
+ *
+ * One shape covers both outcomes (spec §40's "structured `EffectOutcome` envelope for both
+ * success/failure"), rather than a distinct entity per outcome: field ids are unique across
+ * a whole graph — like `GROUP_KEY_FIELD`/`GROUP_ITEMS_FIELD` — so two entities could not both
+ * declare `effectId`/`operationId`/`integrationId` without colliding. A success dispatch
+ * populates `result`; a failure dispatch populates `code`/`message`/`retryable`; neither
+ * ever populates both, and none of `result`/`code`/`message`/`retryable` is `required`, so
+ * either shape validates.
+ *
+ * Unlike `GROUP_KEY_FIELD`/`GROUP_ITEMS_FIELD`, these are not runtime-enforced reservations
+ * — a payload is validated as an ordinary `entity` type, the same as any other event. They
+ * are a naming convention plus the builder below, so every application's effect outcome
+ * events share one shape an agent only has to learn once.
+ */
+export declare const EFFECT_ID_FIELD: FieldId;
+export declare const EFFECT_INTEGRATION_ID_FIELD: FieldId;
+export declare const EFFECT_OPERATION_ID_FIELD: FieldId;
+export declare const EFFECT_CODE_FIELD: FieldId;
+export declare const EFFECT_MESSAGE_FIELD: FieldId;
+export declare const EFFECT_RETRYABLE_FIELD: FieldId;
+export declare const EFFECT_IDEMPOTENCY_KEY_FIELD: FieldId;
+export declare const EFFECT_CORRELATION_ID_FIELD: FieldId;
+export declare const EFFECT_RESULT_FIELD: FieldId;
+/**
+ * The canonical entity shape for an `integration-effect`'s `succeededEventId` and
+ * `failedEventId` payload alike. Declare it once with
+ * `graph.addNode(effectOutcomeEntity(ENTITY_ID, resultType))` and reference it from both
+ * `EventDef`s with `entityType(ENTITY_ID)`. `resultType` is the effect operation's own
+ * declared result type — if a graph's effect operations return incompatible result types,
+ * they need either a common supertype here or their own outcome entity each (field ids are
+ * graph-global, so at most one `effectOutcomeEntity` may share a given result shape).
+ */
+export declare function effectOutcomeEntity(id: NodeId, resultType: TypeRef): EntityDef;
+//# sourceMappingURL=effect-outcome.d.ts.map

package/dist/effect-outcome.js

@@ -0,0 +1,57 @@
+import { fieldId } from './ids.js';
+import { primitiveType } from './type-ref.js';
+/**
+ * Reserved field ids for an `integration-effect`'s `succeededEventId`/`failedEventId`
+ * payload — spec 8.1 §37-41's structured envelope, replacing the 0.8.0 shape (the raw
+ * adapter result for success, a formatted `"<code>: <message>"` string for failure) that
+ * forced a follow-up action to parse text to correlate a failure back to the effect that
+ * caused it.
+ *
+ * One shape covers both outcomes (spec §40's "structured `EffectOutcome` envelope for both
+ * success/failure"), rather than a distinct entity per outcome: field ids are unique across
+ * a whole graph — like `GROUP_KEY_FIELD`/`GROUP_ITEMS_FIELD` — so two entities could not both
+ * declare `effectId`/`operationId`/`integrationId` without colliding. A success dispatch
+ * populates `result`; a failure dispatch populates `code`/`message`/`retryable`; neither
+ * ever populates both, and none of `result`/`code`/`message`/`retryable` is `required`, so
+ * either shape validates.
+ *
+ * Unlike `GROUP_KEY_FIELD`/`GROUP_ITEMS_FIELD`, these are not runtime-enforced reservations
+ * — a payload is validated as an ordinary `entity` type, the same as any other event. They
+ * are a naming convention plus the builder below, so every application's effect outcome
+ * events share one shape an agent only has to learn once.
+ */
+export const EFFECT_ID_FIELD = fieldId('field_effect_id');
+export const EFFECT_INTEGRATION_ID_FIELD = fieldId('field_effect_integration_id');
+export const EFFECT_OPERATION_ID_FIELD = fieldId('field_effect_operation_id');
+export const EFFECT_CODE_FIELD = fieldId('field_effect_code');
+export const EFFECT_MESSAGE_FIELD = fieldId('field_effect_message');
+export const EFFECT_RETRYABLE_FIELD = fieldId('field_effect_retryable');
+export const EFFECT_IDEMPOTENCY_KEY_FIELD = fieldId('field_effect_idempotency_key');
+export const EFFECT_CORRELATION_ID_FIELD = fieldId('field_effect_correlation_id');
+export const EFFECT_RESULT_FIELD = fieldId('field_effect_result');
+/**
+ * The canonical entity shape for an `integration-effect`'s `succeededEventId` and
+ * `failedEventId` payload alike. Declare it once with
+ * `graph.addNode(effectOutcomeEntity(ENTITY_ID, resultType))` and reference it from both
+ * `EventDef`s with `entityType(ENTITY_ID)`. `resultType` is the effect operation's own
+ * declared result type — if a graph's effect operations return incompatible result types,
+ * they need either a common supertype here or their own outcome entity each (field ids are
+ * graph-global, so at most one `effectOutcomeEntity` may share a given result shape).
+ */
+export function effectOutcomeEntity(id, resultType) {
+    return {
+        id,
+        kind: 'entity',
+        fields: [
+            { id: EFFECT_ID_FIELD, valueType: primitiveType('string'), required: true },
+            { id: EFFECT_INTEGRATION_ID_FIELD, valueType: primitiveType('string'), required: true },
+            { id: EFFECT_OPERATION_ID_FIELD, valueType: primitiveType('string'), required: true },
+            { id: EFFECT_RESULT_FIELD, valueType: resultType },
+            { id: EFFECT_CODE_FIELD, valueType: primitiveType('string') },
+            { id: EFFECT_MESSAGE_FIELD, valueType: primitiveType('string') },
+            { id: EFFECT_RETRYABLE_FIELD, valueType: primitiveType('boolean') },
+            { id: EFFECT_IDEMPOTENCY_KEY_FIELD, valueType: primitiveType('string') },
+            { id: EFFECT_CORRELATION_ID_FIELD, valueType: primitiveType('string') },
+        ],
+    };
+}

package/dist/graph.js

@@ -23,7 +23,7 @@ export class ApplicationGraph {
     /** Bumped by every change, so the derived edge index can never serve stale data. */
     revision = 0;
     semanticIndex;
-    constructor(id, name, version = '0.8.0') {
+    constructor(id, name, version = '0.8.2') {
         this.data = { id, name, version, nodes: {}, edges: {} };
     }
     get id() {

package/dist/index.d.ts

@@ -8,9 +8,11 @@ export * from './group.js';
 export * from './expressions.js';
 export * from './nodes.js';
 export * from './integrations.js';
+export * from './effect-outcome.js';
 export * from './events.js';
 export * from './triggers.js';
 export * from './renderer-capabilities.js';
+export * from './trigger-capabilities.js';
 export * from './authoring-metadata.js';
 export * from './ui.js';
 export * from './types.js';

package/dist/index.js

@@ -8,9 +8,11 @@ export * from './group.js';
 export * from './expressions.js';
 export * from './nodes.js';
 export * from './integrations.js';
+export * from './effect-outcome.js';
 export * from './events.js';
 export * from './triggers.js';
 export * from './renderer-capabilities.js';
+export * from './trigger-capabilities.js';
 export * from './authoring-metadata.js';
 export * from './ui.js';
 export * from './types.js';

package/dist/nodes.d.ts

@@ -174,6 +174,27 @@ export interface ActionGuard {
     condition: Expression;
     failureMode?: FailureMode;
 }
+/**
+ * `'client'` is an ordinary `InvokeRequest`; `'system'` is a trigger-, event- or
+ * effect-outcome-originated invocation. Server-computed and client-unforgeable — see
+ * `ExecutionContext.source` in `@cynodia/axiom-server`.
+ */
+export type InvocationSource = 'client' | 'system';
+export declare const INVOCATION_SOURCES: readonly InvocationSource[];
+/** Both sources, the default when `ActionDef.invocation` is absent (spec 8.1 §5). */
+export declare const DEFAULT_ALLOWED_INVOCATION_SOURCES: readonly InvocationSource[];
+/**
+ * Restricts who may invoke an action, independently of `authorization`'s identity check.
+ *
+ * `authorization` answers "may this caller invoke this action"; `invocation` answers "may
+ * an invocation reaching the authority this way invoke this action at all" — the trust
+ * boundary a trigger-only or effect-outcome-only action needs, since otherwise any anonymous
+ * client that knows its id can invoke it directly (spec 8.1 §3-9).
+ */
+export interface ActionInvocationPolicy {
+    /** Absent means both — identical to omitting `invocation` entirely. */
+    allowedSources?: readonly InvocationSource[];
+}
 /**
  * Behaviour expressed as data, executed as a transaction.
  *
@@ -210,12 +231,20 @@ export interface ActionDef extends NodeBase {
     authorization?: Expression;
     /** What the confirmation says, when a plain message is not enough. */
     confirmation?: ConfirmationPresentation;
+    /** Restricts which invocation sources may reach this action. Absent means both. */
+    invocation?: ActionInvocationPolicy;
 }
 /**
  * The conditions an action checks, however they were written. `guards` pairs each
  * condition with its failure; the older parallel arrays are matched by position.
  */
 export declare function actionGuards(action: ActionDef): ActionGuard[];
+/** The invocation sources this action accepts — both, unless `invocation` restricts it. */
+export declare function allowedInvocationSources(action: ActionDef): readonly InvocationSource[];
+/** Whether an ordinary client `InvokeRequest` may name this action at all. */
+export declare function isClientInvocable(action: ActionDef): boolean;
+/** Whether this action accepts only trigger-, event- or effect-outcome-originated calls. */
+export declare function isSystemOnlyAction(action: ActionDef): boolean;
 export type Operation = SetOperation | InsertOperation | RemoveOperation | ForEachOperation | InvokeOperation | NavigateOperation | NativeOperation | IntegrationQueryOperation | IntegrationEffectOperation;
 export type OperationKind = Operation['kind'];
 /** Every operation kind the runtime is required to execute. */

package/dist/nodes.js

@@ -1,3 +1,6 @@
+export const INVOCATION_SOURCES = ['client', 'system'];
+/** Both sources, the default when `ActionDef.invocation` is absent (spec 8.1 §5). */
+export const DEFAULT_ALLOWED_INVOCATION_SOURCES = INVOCATION_SOURCES;
 /**
  * The conditions an action checks, however they were written. `guards` pairs each
  * condition with its failure; the older parallel arrays are matched by position.
@@ -11,6 +14,19 @@ export function actionGuards(action) {
         ...(action.failureModes?.[index] ? { failureMode: action.failureModes[index] } : {}),
     }));
 }
+/** The invocation sources this action accepts — both, unless `invocation` restricts it. */
+export function allowedInvocationSources(action) {
+    return action.invocation?.allowedSources ?? DEFAULT_ALLOWED_INVOCATION_SOURCES;
+}
+/** Whether an ordinary client `InvokeRequest` may name this action at all. */
+export function isClientInvocable(action) {
+    return allowedInvocationSources(action).includes('client');
+}
+/** Whether this action accepts only trigger-, event- or effect-outcome-originated calls. */
+export function isSystemOnlyAction(action) {
+    const sources = allowedInvocationSources(action);
+    return sources.includes('system') && !sources.includes('client');
+}
 /** Every operation kind the runtime is required to execute. */
 export const OPERATION_KINDS = [
     'set',

package/dist/server-ir.d.ts

@@ -20,7 +20,7 @@ import type { TriggerDef } from './triggers.js';
  * Every existing application therefore still compiles to a byte-identical
  * `axiom.server.v1` document, and the frozen conformance fixtures stay frozen.
  */
-export declare const SERVER_IR_CONTRACTS: readonly ["axiom.server.v1", "axiom.server.v2", "axiom.server.v3"];
+export declare const SERVER_IR_CONTRACTS: readonly ["axiom.server.v1", "axiom.server.v2", "axiom.server.v3", "axiom.server.v4"];
 export type ServerIRContract = (typeof SERVER_IR_CONTRACTS)[number];
 /** The oldest contract, and the one a document declares unless it needs more. */
 export declare const SERVER_IR_CONTRACT: ServerIRContract;
@@ -46,6 +46,28 @@ export declare function usesIntegrationVocabulary(ir: {
     events?: readonly unknown[];
     triggers?: readonly unknown[];
 }): boolean;
+/**
+ * Whether any action declares `invocation` at all, restrictive or not — `axiom.server.v1`
+ * is frozen and its schema carries no such property, so even a redundant, fully-permissive
+ * `invocation: { allowedSources: ['client', 'system'] }` requires at least `v2`, the same
+ * tier a document that merely uses `group`/`expression-ref` requires.
+ */
+export declare function usesInvocationVocabulary(ir: {
+    actions: Record<string, ActionDef>;
+}): boolean;
+/**
+ * Whether a document restricts any action's invocation sources, or gives it a structured
+ * effect-outcome payload — both incompatible changes to `axiom.server.v3` execution
+ * semantics (spec 8.1 §50-52): a v3 runtime that ignored `invocation.allowedSources` would
+ * let a client forge a system-only action, and one expecting the v3 string/raw effect
+ * payload would misread the v4 structured envelope. Computed from the document, the same
+ * way `usesIntegrationVocabulary` decides v3 — a document that uses neither still labels
+ * itself `axiom.server.v3`.
+ */
+export declare function usesV4Semantics(ir: {
+    actions: Record<string, ActionDef>;
+    integrationOperations?: Record<string, IntegrationOperationDef>;
+}): boolean;
 /** The higher of two contracts, ordered by `SERVER_IR_CONTRACTS`. */
 export declare function maxContract(a: ServerIRContract, b: ServerIRContract): ServerIRContract;
 /** Every expression a Server IR document contains, in no particular order. */

package/dist/server-ir.js

@@ -14,11 +14,16 @@ import { walkExpression } from './expressions.js';
  * Every existing application therefore still compiles to a byte-identical
  * `axiom.server.v1` document, and the frozen conformance fixtures stay frozen.
  */
-export const SERVER_IR_CONTRACTS = ['axiom.server.v1', 'axiom.server.v2', 'axiom.server.v3'];
+export const SERVER_IR_CONTRACTS = [
+    'axiom.server.v1',
+    'axiom.server.v2',
+    'axiom.server.v3',
+    'axiom.server.v4',
+];
 /** The oldest contract, and the one a document declares unless it needs more. */
 export const SERVER_IR_CONTRACT = 'axiom.server.v1';
 /** The newest contract this implementation produces and executes. */
-export const SERVER_IR_LATEST_CONTRACT = 'axiom.server.v3';
+export const SERVER_IR_LATEST_CONTRACT = 'axiom.server.v4';
 /** Expression kinds that `axiom.server.v1` does not contain. */
 export const SERVER_IR_V2_EXPRESSION_KINDS = ['group', 'expression-ref'];
 /**
@@ -49,6 +54,32 @@ export function usesIntegrationVocabulary(ir) {
         (ir.events?.length ?? 0) > 0 ||
         (ir.triggers?.length ?? 0) > 0);
 }
+/**
+ * Whether any action declares `invocation` at all, restrictive or not — `axiom.server.v1`
+ * is frozen and its schema carries no such property, so even a redundant, fully-permissive
+ * `invocation: { allowedSources: ['client', 'system'] }` requires at least `v2`, the same
+ * tier a document that merely uses `group`/`expression-ref` requires.
+ */
+export function usesInvocationVocabulary(ir) {
+    return Object.values(ir.actions).some((action) => action.invocation !== undefined);
+}
+/**
+ * Whether a document restricts any action's invocation sources, or gives it a structured
+ * effect-outcome payload — both incompatible changes to `axiom.server.v3` execution
+ * semantics (spec 8.1 §50-52): a v3 runtime that ignored `invocation.allowedSources` would
+ * let a client forge a system-only action, and one expecting the v3 string/raw effect
+ * payload would misread the v4 structured envelope. Computed from the document, the same
+ * way `usesIntegrationVocabulary` decides v3 — a document that uses neither still labels
+ * itself `axiom.server.v3`.
+ */
+export function usesV4Semantics(ir) {
+    const restrictsInvocation = Object.values(ir.actions).some((action) => {
+        const sources = action.invocation?.allowedSources;
+        return sources !== undefined && sources.length < 2;
+    });
+    const usesEffects = Object.values(ir.integrationOperations ?? {}).some((operation) => operation.mode === 'effect');
+    return restrictsInvocation || usesEffects;
+}
 /** The higher of two contracts, ordered by `SERVER_IR_CONTRACTS`. */
 export function maxContract(a, b) {
     return SERVER_IR_CONTRACTS.indexOf(b) > SERVER_IR_CONTRACTS.indexOf(a) ? b : a;

package/dist/trigger-capabilities.d.ts

@@ -0,0 +1,28 @@
+import type { TriggerKind } from './triggers.js';
+/**
+ * What a trigger runtime can actually execute, for client-authority triggers.
+ *
+ * A server-authority trigger always executes on the authority, which implements every
+ * kind, so this only ever gates client-authority triggers — the ones a compiled client IR
+ * would otherwise have to execute itself. Before spec 8.1, a client-authority `interval`/
+ * `delay`/`lifecycle` trigger validated, compiled into `ApplicationIR.triggers`, and then
+ * silently never fired: no client runtime implemented any trigger kind at all. That is
+ * exactly the "publicly declared, typechecks, passes validation, has no defined runtime
+ * behaviour" shape the framework forbids — the same gap `RendererCapabilities` closed for
+ * UI node kinds.
+ *
+ * A trigger runtime that implements a kind publishes it here; one that has not cannot
+ * silently accept it.
+ */
+export interface TriggerRuntimeCapabilities {
+    /** Names the runtime, so a diagnostic can say which target refused. */
+    target: string;
+    supportedTriggerKinds: readonly TriggerKind[];
+}
+/**
+ * Every kind, for a caller that does not know or care about a target — validation is never
+ * rejected for a trigger runtime nobody named. Compiling for a real target supplies the
+ * real set.
+ */
+export declare const ALL_TRIGGER_KINDS_SUPPORTED: TriggerRuntimeCapabilities;
+//# sourceMappingURL=trigger-capabilities.d.ts.map

package/dist/trigger-capabilities.js

@@ -0,0 +1,10 @@
+import { TRIGGER_KINDS } from './triggers.js';
+/**
+ * Every kind, for a caller that does not know or care about a target — validation is never
+ * rejected for a trigger runtime nobody named. Compiling for a real target supplies the
+ * real set.
+ */
+export const ALL_TRIGGER_KINDS_SUPPORTED = {
+    target: 'any',
+    supportedTriggerKinds: TRIGGER_KINDS,
+};

package/dist/validate-authority.d.ts

@@ -1,5 +1,6 @@
 import type { ValidationIssue } from './diagnostics.js';
 import type { NodeId } from './ids.js';
+import type { TriggerRuntimeCapabilities } from './trigger-capabilities.js';
 import type { AnyNode } from './types.js';
 /**
  * Validation of the authority boundary.
@@ -9,7 +10,7 @@ import type { AnyNode } from './types.js';
  * correctly — and the point of the boundary is that its correctness does not depend on an
  * author remembering where to bind an input.
  */
-export declare function validateAuthority(nodes: readonly AnyNode[], principalEntityId: NodeId | undefined): {
+export declare function validateAuthority(nodes: readonly AnyNode[], principalEntityId: NodeId | undefined, triggerRuntime?: TriggerRuntimeCapabilities): {
     errors: ValidationIssue[];
     warnings: ValidationIssue[];
 };

package/dist/validate-authority.js

@@ -2,6 +2,8 @@ import { PRINCIPAL, actionAuthority, authorityContext, stateAuthority, statesRea
 import { referencedIds } from './derive-edges.js';
 import { VALIDATION_CODES } from './diagnostics.js';
 import { locationRootStateId } from './location.js';
+import { allowedInvocationSources } from './nodes.js';
+import { ALL_TRIGGER_KINDS_SUPPORTED } from './trigger-capabilities.js';
 import { isUINode } from './ui.js';
 /**
  * Validation of the authority boundary.
@@ -11,7 +13,7 @@ import { isUINode } from './ui.js';
  * correctly — and the point of the boundary is that its correctness does not depend on an
  * author remembering where to bind an input.
  */
-export function validateAuthority(nodes, principalEntityId) {
+export function validateAuthority(nodes, principalEntityId, triggerRuntime = ALL_TRIGGER_KINDS_SUPPORTED) {
     const errors = [];
     const warnings = [];
     const context = authorityContext(nodes, principalEntityId);
@@ -164,6 +166,31 @@ export function validateAuthority(nodes, principalEntityId) {
                 details: { actionId: target.id, authority },
             });
         }
+        // A trigger of any kind always invokes with `source: 'system'` (spec 8.1 §3-9). An
+        // action that has opted out of system invocation could never be reached by it.
+        if (!allowedInvocationSources(target).includes('system')) {
+            errors.push({
+                code: VALIDATION_CODES.triggerTargetSourceMismatch,
+                message: `Trigger ${node.name ?? node.id} targets ${target.name ?? target.id}, which does not accept 'system'-sourced invocations, so this trigger could never invoke it`,
+                nodeId: node.id,
+                details: { actionId: target.id },
+            });
+        }
+        // A client-authority trigger executes in the trigger runtime the graph is compiled
+        // for. A kind that runtime does not implement would validate, compile, and then
+        // silently never fire (spec 8.1 §31-36) — exactly what a renderer capability gate
+        // already prevents for UI node kinds.
+        if (authority === 'client' && !triggerRuntime.supportedTriggerKinds.includes(node.when.kind)) {
+            errors.push({
+                code: VALIDATION_CODES.clientTriggerUnsupported,
+                message: `Trigger ${node.name ?? node.id} is a client-authority '${node.when.kind}' trigger, which the ` +
+                    `${triggerRuntime.target} trigger runtime does not execute. Move ${target.name ?? target.id} to ` +
+                    `server-authoritative execution (so the trigger becomes server-authority), or compile for a ` +
+                    `trigger runtime that publishes '${node.when.kind}' in its supportedTriggerKinds.`,
+                nodeId: node.id,
+                details: { actionId: target.id, kind: node.when.kind, target: triggerRuntime.target },
+            });
+        }
     }
     // The principal exists only where an authority evaluates. Reading it anywhere a client
     // evaluates would be a rule the client could simply not apply.

package/dist/validate.d.ts

@@ -1,4 +1,5 @@
 import type { RendererCapabilities } from './renderer-capabilities.js';
+import type { TriggerRuntimeCapabilities } from './trigger-capabilities.js';
 import type { ValidationResult } from './diagnostics.js';
 import type { ApplicationGraph } from './graph.js';
 /**
@@ -13,6 +14,13 @@ export interface ValidateOptions {
      * real capabilities, which is where an unrenderable node kind is caught.
      */
     renderer?: RendererCapabilities;
+    /**
+     * The trigger runtime the graph is intended for. Absent, every trigger kind is accepted —
+     * a graph is not rejected for a trigger runtime nobody named. `compileToIR` supplies the
+     * browser's real (empty) capability set, which is where a client-authority trigger kind
+     * no browser runtime executes is caught, rather than silently compiling inert.
+     */
+    triggerRuntime?: TriggerRuntimeCapabilities;
 }
 export declare function validateGraph(graph: ApplicationGraph, options?: ValidateOptions): ValidationResult;
 //# sourceMappingURL=validate.d.ts.map

package/dist/validate.js

@@ -102,7 +102,7 @@ export function validateGraph(graph, options = {}) {
     warnings.push(...presentation.warnings);
     // The authority boundary. A graph that could let a client commit server state, or that
     // would make an authority read state it does not own, cannot execute safely.
-    const authority = validateAuthority(allNodes, graph.principalEntityId);
+    const authority = validateAuthority(allNodes, graph.principalEntityId, options.triggerRuntime);
     errors.push(...authority.errors);
     warnings.push(...authority.warnings);
     return { valid: errors.length === 0, errors, warnings };
@@ -230,6 +230,13 @@ function validateAction(action, context) {
     if (action.authorization) {
         validateExpression(action.authorization, action.id, context, new Set());
     }
+    if (action.invocation?.allowedSources && action.invocation.allowedSources.length === 0) {
+        context.errors.push({
+            code: VALIDATION_CODES.invalidInvocationSource,
+            message: `Action ${action.name ?? action.id} declares an empty invocation.allowedSources, so it could never be invoked`,
+            nodeId: action.id,
+        });
+    }
     const local = emptyScope(new Set((action.parameters ?? []).map((parameter) => parameter.id)));
     for (const parameter of action.parameters ?? []) {
         if (parameter.valueType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cynodia/axiom-core",
-  "version": "0.8.0-alpha.1",
+  "version": "0.8.2-alpha.1",
   "description": "Application Graph, semantic types, locations and validation for Axiom.",
   "license": "MIT",
   "author": "AskTech AS",