@cynodia/axiom-core 0.8.2-alpha.1 → 0.9.0-alpha.2

package/dist/authority.d.ts

@@ -45,6 +45,8 @@ export declare function authorityContext(nodes: readonly AnyNode[], principalEnt
 export declare function statesReadBy(expressions: readonly Expression[], context: AuthorityContext): Set<NodeId>;
 /** Whether an action calls out to an integration anywhere in its top-level operations. */
 export declare function actionUsesIntegration(action: ActionDef): boolean;
+/** Whether an action reaches an object store anywhere in its top-level operations. */
+export declare function actionUsesStorage(action: ActionDef): boolean;
 /** The states an action writes, following `for-each`, `invoke` and declared native effects. */
 export declare function statesWrittenBy(action: ActionDef, context: AuthorityContext, visited?: Set<NodeId>): Set<NodeId>;
 /** The states an action reads: its guards, its values, its selectors, its authorization. */

package/dist/authority.js

@@ -121,6 +121,11 @@ function operationExpressions(operation) {
                 found.push(operation.idempotencyKey);
             }
             break;
+        case 'blob-metadata':
+        case 'blob-commit':
+        case 'blob-delete':
+            found.push(operation.blobKey);
+            break;
         default:
     }
     return found;
@@ -129,6 +134,12 @@ function operationExpressions(operation) {
 export function actionUsesIntegration(action) {
     return (action.operations ?? []).some((operation) => operation.kind === 'integration-query' || operation.kind === 'integration-effect');
 }
+/** Whether an action reaches an object store anywhere in its top-level operations. */
+export function actionUsesStorage(action) {
+    return (action.operations ?? []).some((operation) => operation.kind === 'blob-metadata' ||
+        operation.kind === 'blob-commit' ||
+        operation.kind === 'blob-delete');
+}
 /** The states an action writes, following `for-each`, `invoke` and declared native effects. */
 export function statesWrittenBy(action, context, visited = new Set()) {
     const found = new Set();
@@ -167,9 +178,12 @@ export function statesWrittenBy(action, context, visited = new Set()) {
                     break;
                 case 'integration-query':
                 case 'integration-effect':
-                    // Neither writes Axiom state directly: a query's result is a transaction-local
-                    // scope binding, and an effect's outcome reaches state only through a follow-up
-                    // action invoked from its success/failure event.
+                case 'blob-metadata':
+                case 'blob-commit':
+                case 'blob-delete':
+                    // None of these writes Axiom state directly: a query's (or a metadata lookup's)
+                    // result is a transaction-local scope binding, and an effect's outcome reaches
+                    // state only through a follow-up action invoked from its success/failure event.
                     break;
                 default:
             }
@@ -213,10 +227,10 @@ export function statesReadByAction(action, context, visited = new Set()) {
  * cannot disagree with what the action actually does.
  */
 export function actionAuthority(action, context) {
-    // Integrations default server-only (spec §65: secrets, trust, CORS, auditability,
-    // deterministic authority), so an action that calls one is unconditionally server —
-    // independent of what it writes.
-    if (actionUsesIntegration(action)) {
+    // Integrations and object stores are both server-only by default (spec §65: secrets,
+    // trust, CORS, auditability, deterministic authority), so an action that reaches either
+    // is unconditionally server — independent of what it writes.
+    if (actionUsesIntegration(action) || actionUsesStorage(action)) {
         return 'server';
     }
     for (const stateId of statesWrittenBy(action, context)) {

package/dist/derive-edges.js

@@ -161,6 +161,22 @@ export function deriveEdges(nodes) {
                     reads(node.id, node.enabledWhen, rootScope);
                 }
                 break;
+            case 'subscription':
+                link(node.id, node.integrationId, 'references');
+                link(node.id, node.eventId, 'references');
+                for (const argument of Object.values(node.arguments ?? {})) {
+                    reads(node.id, argument, rootScope);
+                }
+                break;
+            case 'storage':
+                link(node.id, node.blobEntityId, 'references');
+                if (node.readAuthorization) {
+                    reads(node.id, node.readAuthorization, new Map([...rootScope, [node.id, []]]));
+                }
+                if (node.uploadAuthorization) {
+                    reads(node.id, node.uploadAuthorization, rootScope);
+                }
+                break;
             case 'integration':
             case 'event':
                 break;
@@ -457,6 +473,21 @@ function linkOperations(actionId, operations, linker, scope) {
                     linker.link(actionId, operation.failedEventId, 'references');
                 }
                 break;
+            case 'blob-metadata':
+                linker.link(actionId, operation.storageId, 'references');
+                linker.reads(actionId, operation.blobKey, scope);
+                break;
+            case 'blob-commit':
+            case 'blob-delete':
+                linker.link(actionId, operation.storageId, 'references');
+                linker.reads(actionId, operation.blobKey, scope);
+                if (operation.succeededEventId) {
+                    linker.link(actionId, operation.succeededEventId, 'references');
+                }
+                if (operation.failedEventId) {
+                    linker.link(actionId, operation.failedEventId, 'references');
+                }
+                break;
             default:
         }
     }

package/dist/diagnostics.d.ts

@@ -107,5 +107,17 @@ export declare const VALIDATION_CODES: {
     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";
+    /** A `SubscriptionDef` whose event has no trigger bound to it: a live source feeding nothing. */
+    readonly subscriptionEventUnreachable: "SUBSCRIPTION_EVENT_UNREACHABLE";
+    /** A `SubscriptionDef` in a graph with no server authority — nothing would ever activate it. */
+    readonly subscriptionWithoutAuthority: "SUBSCRIPTION_WITHOUT_AUTHORITY";
+    /** A delivery or lifecycle policy that cannot be executed as written — a non-positive queue, a dedup field that is not on the payload entity. */
+    readonly subscriptionInvalidPolicy: "SUBSCRIPTION_INVALID_POLICY";
+    /** A `StorageDef.blobEntityId`, or a blob operation's `storageId`, that does not resolve. */
+    readonly unknownStorage: "UNKNOWN_STORAGE";
+    /** A `StorageDef` whose `blobEntityId` is not the canonical `blobRefEntity()` shape. */
+    readonly invalidBlobEntity: "INVALID_BLOB_ENTITY";
+    /** A blob operation that cannot execute as written — inside a `for-each`, or with no readable key. */
+    readonly invalidBlobOperation: "INVALID_BLOB_OPERATION";
 };
 //# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.js

@@ -96,4 +96,17 @@ export const VALIDATION_CODES = {
     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',
+    // Subscriptions and blob storage (0.9).
+    /** A `SubscriptionDef` whose event has no trigger bound to it: a live source feeding nothing. */
+    subscriptionEventUnreachable: 'SUBSCRIPTION_EVENT_UNREACHABLE',
+    /** A `SubscriptionDef` in a graph with no server authority — nothing would ever activate it. */
+    subscriptionWithoutAuthority: 'SUBSCRIPTION_WITHOUT_AUTHORITY',
+    /** A delivery or lifecycle policy that cannot be executed as written — a non-positive queue, a dedup field that is not on the payload entity. */
+    subscriptionInvalidPolicy: 'SUBSCRIPTION_INVALID_POLICY',
+    /** A `StorageDef.blobEntityId`, or a blob operation's `storageId`, that does not resolve. */
+    unknownStorage: 'UNKNOWN_STORAGE',
+    /** A `StorageDef` whose `blobEntityId` is not the canonical `blobRefEntity()` shape. */
+    invalidBlobEntity: 'INVALID_BLOB_ENTITY',
+    /** A blob operation that cannot execute as written — inside a `for-each`, or with no readable key. */
+    invalidBlobOperation: 'INVALID_BLOB_OPERATION',
 };

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.2') {
+    constructor(id, name, version = '0.9.0') {
         this.data = { id, name, version, nodes: {}, edges: {} };
     }
     get id() {

package/dist/index.d.ts

@@ -11,6 +11,8 @@ export * from './integrations.js';
 export * from './effect-outcome.js';
 export * from './events.js';
 export * from './triggers.js';
+export * from './subscriptions.js';
+export * from './storage.js';
 export * from './renderer-capabilities.js';
 export * from './trigger-capabilities.js';
 export * from './authoring-metadata.js';

package/dist/index.js

@@ -11,6 +11,8 @@ export * from './integrations.js';
 export * from './effect-outcome.js';
 export * from './events.js';
 export * from './triggers.js';
+export * from './subscriptions.js';
+export * from './storage.js';
 export * from './renderer-capabilities.js';
 export * from './trigger-capabilities.js';
 export * from './authoring-metadata.js';

package/dist/nodes.d.ts

@@ -245,10 +245,12 @@ export declare function allowedInvocationSources(action: ActionDef): readonly In
 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 Operation = SetOperation | InsertOperation | RemoveOperation | ForEachOperation | InvokeOperation | NavigateOperation | NativeOperation | IntegrationQueryOperation | IntegrationEffectOperation | BlobMetadataOperation | BlobCommitOperation | BlobDeleteOperation;
 export type OperationKind = Operation['kind'];
 /** Every operation kind the runtime is required to execute. */
 export declare const OPERATION_KINDS: readonly OperationKind[];
+/** The storage operations, which address a `StorageDef` rather than an integration. */
+export declare const BLOB_OPERATION_KINDS: readonly OperationKind[];
 /** Every mutation is a set, an insert or a remove against an addressed Location. */
 export type MutationOperation = SetOperation | InsertOperation | RemoveOperation;
 /**
@@ -357,6 +359,55 @@ export interface IntegrationEffectOperation {
     succeededEventId?: NodeId;
     failedEventId?: NodeId;
 }
+/**
+ * Reads a stored object's metadata and binds it into scope, exactly as an
+ * `integration-query` binds a query result.
+ *
+ * It is query-like because it is: a finite question with a finite answer, resolved before
+ * the transaction opens, whose result may inform the mutations that follow. It returns the
+ * `BlobRef` — key, media type, size, filename, checksum — and never the bytes. A key that
+ * names nothing, or names a `staged` object, fails the invocation rather than binding a
+ * plausible-looking empty record. Never legal inside `for-each`.
+ */
+export interface BlobMetadataOperation {
+    kind: 'blob-metadata';
+    storageId: NodeId;
+    /** The opaque key. Usually `field(ref(…), BLOB_KEY_FIELD)` of a stored `BlobRef`. */
+    blobKey: Expression;
+    bindAs: NodeId;
+}
+/**
+ * Promotes a staged upload to a stored object, post-commit.
+ *
+ * It is effect-like for the reason every effect is: external object storage cannot join an
+ * Axiom transaction, so the promotion is recorded as intent, committed atomically with the
+ * state that references the object, and dispatched only once that state is durable. A
+ * transaction that rolls back dispatches nothing and leaves the upload `staged`, where the
+ * host's sweep reclaims it. Never legal inside `for-each`.
+ */
+export interface BlobCommitOperation {
+    kind: 'blob-commit';
+    storageId: NodeId;
+    blobKey: Expression;
+    succeededEventId?: NodeId;
+    failedEventId?: NodeId;
+}
+/**
+ * Removes a stored object, post-commit.
+ *
+ * The inverse asymmetry to `blob-commit`, and just as deliberate: the authoritative state
+ * that stopped referencing the object is committed first, and the external deletion follows.
+ * If the deletion fails, state is still correct and the orphan is visible in
+ * `AxiomServer.blobLog()` — state correctness and external cleanup stay separately
+ * observable rather than being falsely coupled. Never legal inside `for-each`.
+ */
+export interface BlobDeleteOperation {
+    kind: 'blob-delete';
+    storageId: NodeId;
+    blobKey: Expression;
+    succeededEventId?: NodeId;
+    failedEventId?: NodeId;
+}
 export type NativeEffect = {
     kind: 'reads-state';
     stateId: NodeId;

package/dist/nodes.js

@@ -38,6 +38,15 @@ export const OPERATION_KINDS = [
     'native',
     'integration-query',
     'integration-effect',
+    'blob-metadata',
+    'blob-commit',
+    'blob-delete',
+];
+/** The storage operations, which address a `StorageDef` rather than an integration. */
+export const BLOB_OPERATION_KINDS = [
+    'blob-metadata',
+    'blob-commit',
+    'blob-delete',
 ];
 export function isMutationOperation(operation) {
     return operation.kind === 'set' || operation.kind === 'insert' || operation.kind === 'remove';

package/dist/server-ir.d.ts

@@ -5,6 +5,8 @@ import type { FieldIndexEntry } from './graph.js';
 import type { EventDef } from './events.js';
 import type { IntegrationDef, IntegrationOperationDef } from './integrations.js';
 import type { TriggerDef } from './triggers.js';
+import type { SubscriptionDef } from './subscriptions.js';
+import type { StorageDef } from './storage.js';
 /**
  * The contracts a Server IR may declare. A runtime that does not recognize the value MUST
  * refuse the IR rather than interpret it partially.
@@ -20,12 +22,14 @@ 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", "axiom.server.v4"];
+export declare const SERVER_IR_CONTRACTS: readonly ["axiom.server.v1", "axiom.server.v2", "axiom.server.v3", "axiom.server.v4", "axiom.server.v5"];
 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;
 /** The newest contract this implementation produces and executes. */
 export declare const SERVER_IR_LATEST_CONTRACT: ServerIRContract;
+/** Operation kinds no contract before `axiom.server.v5` contains. */
+export declare const SERVER_IR_V5_OPERATION_KINDS: readonly string[];
 /** Expression kinds that `axiom.server.v1` does not contain. */
 export declare const SERVER_IR_V2_EXPRESSION_KINDS: readonly string[];
 /**
@@ -68,6 +72,19 @@ export declare function usesV4Semantics(ir: {
     actions: Record<string, ActionDef>;
     integrationOperations?: Record<string, IntegrationOperationDef>;
 }): boolean;
+/**
+ * Whether a document uses 0.9's external-I/O vocabulary — subscriptions, object stores, or
+ * any of the three blob operations. A v4 runtime knows none of it: it would start an
+ * application with a declared live event source it never activates, or execute an action
+ * whose `blob-commit` it silently skips, leaving state referencing an object that stays
+ * staged forever. Both are exactly the silent divergence a contract label exists to
+ * prevent, so any of it present is enough to require `axiom.server.v5`.
+ */
+export declare function usesExternalIOVocabulary(ir: {
+    subscriptions?: readonly unknown[];
+    storages?: readonly unknown[];
+    actions: Record<string, ActionDef>;
+}): 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. */
@@ -78,6 +95,8 @@ export declare function serverIRExpressions(ir: {
     transitionConstraints: readonly TransitionConstraintDef[];
     expressionDefs?: Record<NodeId, ExpressionDef>;
     triggers?: readonly TriggerDef[];
+    subscriptions?: readonly SubscriptionDef[];
+    storages?: readonly StorageDef[];
 }): Expression[];
 /**
  * The normalized form an authority executes: everything required to decide a mutation, and
@@ -132,5 +151,17 @@ export interface ServerIR {
     events?: EventDef[];
     /** Server-authority triggers only — interval, delay, lifecycle and event triggers whose target action executes here. */
     triggers?: TriggerDef[];
+    /**
+     * Long-lived external event sources this authority maintains. Absent below
+     * `axiom.server.v5`, which has no way to describe one. Names a capability domain and a
+     * semantic source, never a broker, a topic, a URL or a socket.
+     */
+    subscriptions?: SubscriptionDef[];
+    /**
+     * Object stores this document reads, commits into or deletes from. Carries the
+     * authorization rules a host evaluates before serving a byte, and nothing about the
+     * provider that holds the bytes.
+     */
+    storages?: StorageDef[];
 }
 //# sourceMappingURL=server-ir.d.ts.map

package/dist/server-ir.js

@@ -19,11 +19,18 @@ export const SERVER_IR_CONTRACTS = [
     'axiom.server.v2',
     'axiom.server.v3',
     'axiom.server.v4',
+    'axiom.server.v5',
 ];
 /** 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.v4';
+export const SERVER_IR_LATEST_CONTRACT = 'axiom.server.v5';
+/** Operation kinds no contract before `axiom.server.v5` contains. */
+export const SERVER_IR_V5_OPERATION_KINDS = [
+    'blob-metadata',
+    'blob-commit',
+    'blob-delete',
+];
 /** Expression kinds that `axiom.server.v1` does not contain. */
 export const SERVER_IR_V2_EXPRESSION_KINDS = ['group', 'expression-ref'];
 /**
@@ -80,6 +87,20 @@ export function usesV4Semantics(ir) {
     const usesEffects = Object.values(ir.integrationOperations ?? {}).some((operation) => operation.mode === 'effect');
     return restrictsInvocation || usesEffects;
 }
+/**
+ * Whether a document uses 0.9's external-I/O vocabulary — subscriptions, object stores, or
+ * any of the three blob operations. A v4 runtime knows none of it: it would start an
+ * application with a declared live event source it never activates, or execute an action
+ * whose `blob-commit` it silently skips, leaving state referencing an object that stays
+ * staged forever. Both are exactly the silent divergence a contract label exists to
+ * prevent, so any of it present is enough to require `axiom.server.v5`.
+ */
+export function usesExternalIOVocabulary(ir) {
+    if ((ir.subscriptions?.length ?? 0) > 0 || (ir.storages?.length ?? 0) > 0) {
+        return true;
+    }
+    return Object.values(ir.actions).some((action) => (action.operations ?? []).some((operation) => SERVER_IR_V5_OPERATION_KINDS.includes(operation.kind)));
+}
 /** 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;
@@ -110,6 +131,17 @@ export function serverIRExpressions(ir) {
             found.push(trigger.enabledWhen);
         }
     }
+    for (const subscription of ir.subscriptions ?? []) {
+        found.push(...Object.values(subscription.arguments ?? {}));
+    }
+    for (const storage of ir.storages ?? []) {
+        if (storage.readAuthorization) {
+            found.push(storage.readAuthorization);
+        }
+        if (storage.uploadAuthorization) {
+            found.push(storage.uploadAuthorization);
+        }
+    }
     return found;
 }
 function actionExpressions(action) {
@@ -148,6 +180,11 @@ function actionExpressions(action) {
                         found.push(operation.idempotencyKey);
                     }
                     break;
+                case 'blob-metadata':
+                case 'blob-commit':
+                case 'blob-delete':
+                    found.push(operation.blobKey);
+                    break;
                 default:
             }
         }

package/dist/storage.d.ts

@@ -0,0 +1,101 @@
+import type { Expression } from './expressions.js';
+import type { FieldId, NodeId } from './ids.js';
+import type { RetryPolicy } from './integrations.js';
+import type { EntityDef, NodeBase } from './nodes.js';
+/**
+ * Binary application data — an attachment, a document, a photograph, a diagnostic log —
+ * given a semantic home.
+ *
+ * The abstraction is a **stored object addressed by an opaque key**, never a path, an
+ * inode or a file descriptor. That is what lets the same graph run against a local
+ * directory in development, an S3-like store in production and an in-memory store in a
+ * test without a single graph edit, and it is why `readFile(path)` is not, and will not
+ * become, graph vocabulary.
+ *
+ * Bytes never enter the graph, the Server IR or canonical state. What state holds is a
+ * `BlobRef`: a small record of key, media type, size and optional filename/checksum.
+ * Transfer of the bytes themselves is out of band, through the host's own upload and
+ * download transport — which is why an application declares no HTTP route for either.
+ */
+/**
+ * Reserved field ids of the canonical `BlobRef` record.
+ *
+ * They follow the `EFFECT_*` convention rather than the `GROUP_*` one: a naming convention
+ * plus the builder below, not a runtime-enforced reservation. Field ids are graph-global,
+ * so one graph declares **one** blob entity with `blobRefEntity()` and every store and every
+ * attachment field references it.
+ *
+ * `key` is the whole public identity of a stored object. It is opaque: nothing may parse
+ * it, and it deliberately reveals no bucket, container, region, account, path or provider —
+ * a client that holds one has learned nothing about where the bytes live, and holding one
+ * grants no permission (see `StorageDef.readAuthorization`).
+ */
+export declare const BLOB_KEY_FIELD: FieldId;
+export declare const BLOB_MEDIA_TYPE_FIELD: FieldId;
+export declare const BLOB_SIZE_FIELD: FieldId;
+export declare const BLOB_FILENAME_FIELD: FieldId;
+export declare const BLOB_CHECKSUM_FIELD: FieldId;
+/** Every field of a canonical `BlobRef`, in declaration order. */
+export declare const BLOB_REF_FIELDS: readonly FieldId[];
+/**
+ * The canonical reference-to-a-stored-object entity. Declare it once with
+ * `graph.addNode(blobRefEntity(ENTITY_ID))`, name it from every `StorageDef.blobEntityId`,
+ * and store it wherever an attachment belongs:
+ *
+ * ```ts
+ * // Document { id, title, attachment: BlobRef }
+ * { id: F_DOCUMENT_ATTACHMENT, valueType: optionalType(entityType(ENTITY_BLOB)) }
+ * ```
+ *
+ * `key` is the identity field, so an attachment can be addressed by it the way any other
+ * entity instance can. `checksum` is offered and never required: content addressing is a
+ * legitimate storage model and a poor universal one, so a store that computes a digest
+ * publishes it here and a store that does not simply omits it.
+ */
+export declare function blobRefEntity(id: NodeId): EntityDef;
+/**
+ * Where a stored object is in its lifecycle.
+ *
+ * An upload lands `staged`: it exists, it has a key, and nothing references it yet. A
+ * `blob-commit` operation promotes it to `stored`. That two-step exists because external
+ * object storage does **not** participate in an Axiom transaction and pretending otherwise
+ * would be a lie: if the transaction that meant to reference the upload rolls back, the
+ * commit never dispatches, the object stays `staged`, and staged objects are swept. The
+ * failure mode is a temporary orphan the host can enumerate, not a state referencing bytes
+ * that were never stored.
+ */
+export type BlobLifecycle = 'staged' | 'stored';
+export declare const BLOB_LIFECYCLES: readonly BlobLifecycle[];
+/**
+ * A named object store.
+ *
+ * It is to blobs what `IntegrationDef` is to external operations: the semantic capability,
+ * never the provider. No bucket, endpoint, region, credential or directory appears here or
+ * anywhere else in a graph — a `BlobStorageAdapter` supplies all of it.
+ *
+ * **Authorization is declared, not routed.** `readAuthorization` is evaluated by the host
+ * before a single byte is served, with the caller bound to `PRINCIPAL` and the requested
+ * `BlobRef` bound to `ref(<this storage's id>)`. That is what makes "possession of a key is
+ * not permission" enforceable: a guessed or leaked key still has to satisfy a rule written
+ * over authoritative state.
+ */
+export interface StorageDef extends NodeBase {
+    kind: 'storage';
+    /** The entity every `BlobRef` of this store conforms to — built with `blobRefEntity()`. */
+    blobEntityId: NodeId;
+    /**
+     * Who may read this object's bytes or metadata through the transport. Absent means **no
+     * one**: a store that declares no rule serves nothing, because the safe default for a
+     * missing access rule is refusal, not disclosure.
+     */
+    readAuthorization?: Expression;
+    /** Who may upload into this store. Absent means no one, for the same reason. */
+    uploadAuthorization?: Expression;
+    /** Media types the upload transport accepts. Absent accepts any. */
+    acceptedMediaTypes?: string[];
+    /** The largest upload the transport accepts, in bytes. */
+    maxSizeBytes?: number;
+    /** Retry policy for a failed `blob-commit`/`blob-delete`. Absent means `'none'`. */
+    retry?: RetryPolicy;
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.js

@@ -0,0 +1,74 @@
+import { fieldId } from './ids.js';
+import { primitiveType } from './type-ref.js';
+/**
+ * Binary application data — an attachment, a document, a photograph, a diagnostic log —
+ * given a semantic home.
+ *
+ * The abstraction is a **stored object addressed by an opaque key**, never a path, an
+ * inode or a file descriptor. That is what lets the same graph run against a local
+ * directory in development, an S3-like store in production and an in-memory store in a
+ * test without a single graph edit, and it is why `readFile(path)` is not, and will not
+ * become, graph vocabulary.
+ *
+ * Bytes never enter the graph, the Server IR or canonical state. What state holds is a
+ * `BlobRef`: a small record of key, media type, size and optional filename/checksum.
+ * Transfer of the bytes themselves is out of band, through the host's own upload and
+ * download transport — which is why an application declares no HTTP route for either.
+ */
+/**
+ * Reserved field ids of the canonical `BlobRef` record.
+ *
+ * They follow the `EFFECT_*` convention rather than the `GROUP_*` one: a naming convention
+ * plus the builder below, not a runtime-enforced reservation. Field ids are graph-global,
+ * so one graph declares **one** blob entity with `blobRefEntity()` and every store and every
+ * attachment field references it.
+ *
+ * `key` is the whole public identity of a stored object. It is opaque: nothing may parse
+ * it, and it deliberately reveals no bucket, container, region, account, path or provider —
+ * a client that holds one has learned nothing about where the bytes live, and holding one
+ * grants no permission (see `StorageDef.readAuthorization`).
+ */
+export const BLOB_KEY_FIELD = fieldId('field_blob_key');
+export const BLOB_MEDIA_TYPE_FIELD = fieldId('field_blob_media_type');
+export const BLOB_SIZE_FIELD = fieldId('field_blob_size');
+export const BLOB_FILENAME_FIELD = fieldId('field_blob_filename');
+export const BLOB_CHECKSUM_FIELD = fieldId('field_blob_checksum');
+/** Every field of a canonical `BlobRef`, in declaration order. */
+export const BLOB_REF_FIELDS = [
+    BLOB_KEY_FIELD,
+    BLOB_MEDIA_TYPE_FIELD,
+    BLOB_SIZE_FIELD,
+    BLOB_FILENAME_FIELD,
+    BLOB_CHECKSUM_FIELD,
+];
+/**
+ * The canonical reference-to-a-stored-object entity. Declare it once with
+ * `graph.addNode(blobRefEntity(ENTITY_ID))`, name it from every `StorageDef.blobEntityId`,
+ * and store it wherever an attachment belongs:
+ *
+ * ```ts
+ * // Document { id, title, attachment: BlobRef }
+ * { id: F_DOCUMENT_ATTACHMENT, valueType: optionalType(entityType(ENTITY_BLOB)) }
+ * ```
+ *
+ * `key` is the identity field, so an attachment can be addressed by it the way any other
+ * entity instance can. `checksum` is offered and never required: content addressing is a
+ * legitimate storage model and a poor universal one, so a store that computes a digest
+ * publishes it here and a store that does not simply omits it.
+ */
+export function blobRefEntity(id) {
+    return {
+        id,
+        kind: 'entity',
+        name: 'BlobRef',
+        identityFieldId: BLOB_KEY_FIELD,
+        fields: [
+            { id: BLOB_KEY_FIELD, name: 'Key', valueType: primitiveType('string'), required: true },
+            { id: BLOB_MEDIA_TYPE_FIELD, name: 'Media type', valueType: primitiveType('string'), required: true },
+            { id: BLOB_SIZE_FIELD, name: 'Size', valueType: primitiveType('number'), required: true },
+            { id: BLOB_FILENAME_FIELD, name: 'Filename', valueType: primitiveType('string') },
+            { id: BLOB_CHECKSUM_FIELD, name: 'Checksum', valueType: primitiveType('string') },
+        ],
+    };
+}
+export const BLOB_LIFECYCLES = ['staged', 'stored'];

package/dist/subscriptions.d.ts

@@ -0,0 +1,173 @@
+import type { Expression } from './expressions.js';
+import type { FieldId, NodeId } from './ids.js';
+import type { RetryPolicy } from './integrations.js';
+import type { NodeBase } from './nodes.js';
+/**
+ * The third direction of external interaction.
+ *
+ * A **query** asks the outside world a question and waits for the answer; an **effect**
+ * tells it to do something and does not; a **subscription** is the opposite direction
+ * entirely — Axiom declares a standing semantic interest in a long-lived external source,
+ * and deliveries arrive while that interest is active.
+ *
+ * It is a node of its own rather than a third `IntegrationOperationMode`, because a
+ * subscription has correctness concerns neither of the other two has: activation, stopping,
+ * reconnection, duplicate delivery, ordering, backpressure and a lifecycle state an
+ * operator can observe. Folding all of that onto `IntegrationOperationDef` would have made
+ * most of its fields meaningless for most of its values.
+ *
+ * Nothing here names a socket, a topic, a broker, a URL, a file descriptor or a serial
+ * port. Those are host configuration, supplied to a `SubscriptionAdapter`; the graph says
+ * only *which capability domain*, *which semantic source within it*, and *which `EventDef`
+ * a delivery becomes.
+ */
+/**
+ * What a subscription is doing, as an operator or agent can observe it.
+ *
+ * The state machine is deliberately small — six states, and only the transitions below:
+ *
+ * ```
+ * inactive ──start──▶ starting ──ok──▶ active ──stop──▶ stopped
+ *                        │                │
+ *                        │ fail           │ transport lost
+ *                        ▼                ▼
+ *                     failed ◀──exhausted── reconnecting ──ok──▶ active
+ * ```
+ *
+ * `inactive` is a subscription the graph declares but startup did not activate
+ * (`lifecycle.autoStart: false`). `failed` is terminal for this process: the reconnect
+ * policy is spent. `stopped` is a deliberate shutdown, and a stopped subscription never
+ * delivers again — that is what makes shutdown observable rather than merely likely.
+ */
+export type SubscriptionLifecycleState = 'inactive' | 'starting' | 'active' | 'reconnecting' | 'failed' | 'stopped';
+export declare const SUBSCRIPTION_LIFECYCLE_STATES: readonly SubscriptionLifecycleState[];
+/**
+ * What happens when deliveries arrive faster than the authority commits the actions they
+ * cause. Every mode is explicit and none of them is unbounded buffering.
+ *
+ * | Policy | Behaviour when the queue is full | Loses events? |
+ * | ------ | -------------------------------- | ------------- |
+ * | `block` | The adapter's `deliver` call does not resolve until there is room. | No |
+ * | `reject` | The delivery is refused; the adapter decides whether to redeliver. | No — the source still holds it |
+ * | `drop-oldest` | The oldest queued delivery is discarded to make room. | **Yes** |
+ * | `drop-newest` | The arriving delivery is discarded. | **Yes** |
+ *
+ * `block` is the default, because the default may not silently lose an authoritative
+ * event. The two dropping modes are legitimate for genuinely lossy sources — a sensor
+ * feed where only the newest reading matters — and both report
+ * `SUBSCRIPTION_DELIVERY_DROPPED`, so a discarded event is never silent.
+ */
+export type SubscriptionBackpressurePolicy = 'block' | 'reject' | 'drop-oldest' | 'drop-newest';
+export declare const SUBSCRIPTION_BACKPRESSURE_POLICIES: readonly SubscriptionBackpressurePolicy[];
+/** Modes that may discard an accepted delivery. Declaring one is declaring loss. */
+export declare const LOSSY_BACKPRESSURE_POLICIES: readonly SubscriptionBackpressurePolicy[];
+/**
+ * What to do with a delivery whose action keeps failing — a poison event.
+ *
+ * `report` (the default) records the failure, reports `SUBSCRIPTION_DELIVERY_FAILED` and
+ * moves on to the next delivery; `pause` additionally stops the subscription, so a source
+ * producing payloads this application cannot process does not spin. Neither ever retries
+ * without bound: `delivery.maxAttempts` is the ceiling, and it defaults to 1.
+ */
+export type SubscriptionFailurePolicy = 'report' | 'pause';
+export declare const SUBSCRIPTION_FAILURE_POLICIES: readonly SubscriptionFailurePolicy[];
+/** Queue depth a subscription gets when it declares none. */
+export declare const DEFAULT_SUBSCRIPTION_QUEUE_LIMIT = 64;
+/** Delivery keys a subscription remembers when it declares no window. */
+export declare const DEFAULT_SUBSCRIPTION_DEDUPLICATION_WINDOW = 512;
+/** Reconnect policy a subscription gets when it declares none. */
+export declare const DEFAULT_SUBSCRIPTION_RECONNECT: RetryPolicy;
+export interface SubscriptionDeliveryPolicy {
+    /** Accepted-but-unprocessed deliveries held at once. Must be above zero. */
+    maxQueued?: number;
+    /** What a full queue does. Defaults to `'block'`, which cannot lose an event. */
+    backpressure?: SubscriptionBackpressurePolicy;
+    /**
+     * The field of the event's payload entity carrying the **external** delivery identity —
+     * a broker message id, a webhook delivery id, a sequence number. Two deliveries with the
+     * same value are one event: the second is acknowledged and never dispatched.
+     *
+     * Deliberately a payload field rather than an Axiom transaction id: the provider decides
+     * what identifies a delivery, and Axiom cannot invent one that survives a redelivery it
+     * did not cause. Absent, no deduplication is performed and the documented at-least-once
+     * guarantee applies unchanged.
+     */
+    deduplicateBy?: FieldId;
+    /** How many recent keys are remembered. Deduplication is bounded, never unbounded. */
+    deduplicationWindow?: number;
+    /** How many times one delivery's action may be attempted. Defaults to 1 — no retry. */
+    maxAttempts?: number;
+    /** What a delivery that exhausts `maxAttempts` does to the subscription. */
+    onFailure?: SubscriptionFailurePolicy;
+}
+export interface SubscriptionLifecyclePolicy {
+    /** Whether startup activates it. Defaults to true. */
+    autoStart?: boolean;
+    /**
+     * Whether the application may be considered ready without it.
+     *
+     * `false` (the default) is spec 0.9 §79's preferred behaviour: a source that cannot be
+     * reached leaves the application running and the subscription `failed`/`reconnecting`,
+     * because an unreachable feed is not a reason to refuse every request. `true` says this
+     * application is not meaningfully running without this source, and `start()` rejects.
+     */
+    required?: boolean;
+    /**
+     * Semantic reconnect policy — Axiom's, not the adapter's. The adapter owns transport
+     * mechanics (what a reconnect *is* for MQTT versus a WebSocket); Axiom owns how many
+     * times and how long apart, so the answer does not change with the provider.
+     */
+    reconnect?: RetryPolicy;
+}
+/**
+ * A long-lived external event source, declared semantically.
+ *
+ * ```ts
+ * graph.addNode<SubscriptionDef>({
+ *   id: SUBSCRIPTION_DEVICE_STATUS,
+ *   kind: 'subscription',
+ *   integrationId: INTEGRATION_DEVICE_PROVIDER,
+ *   source: 'device-status',
+ *   eventId: EVENT_DEVICE_STATUS_CHANGED,
+ *   delivery: { deduplicateBy: F_CHANGE_DELIVERY_ID, maxQueued: 32 },
+ * });
+ * ```
+ *
+ * A delivery becomes an `EventDef` payload and enters the existing
+ * `EventDef → TriggerDef → ActionDef` pipeline. There is no second event system, no
+ * callback and no application-authored handler.
+ */
+export interface SubscriptionDef extends NodeBase {
+    kind: 'subscription';
+    /** The capability domain whose adapter maintains the source. */
+    integrationId: NodeId;
+    /**
+     * Which semantic source within that integration — `'device-status'`, `'inbound-orders'`.
+     * It is a name the adapter maps to a topic, a URL, a queue or a device; the graph never
+     * learns which. Absent, the subscription's own id is the name.
+     */
+    source?: string;
+    /**
+     * Configuration evaluated once, when the subscription activates: a filter, a device set,
+     * a starting offset. Expressions, so configuration can follow authoritative state — but
+     * evaluated at activation, not per delivery, because a live source is not re-negotiated
+     * on every message.
+     */
+    arguments?: Record<string, Expression>;
+    /** The `EventDef` a delivery becomes. Its `payloadType` is what a payload must satisfy. */
+    eventId: NodeId;
+    lifecycle?: SubscriptionLifecyclePolicy;
+    delivery?: SubscriptionDeliveryPolicy;
+}
+export declare function subscriptionSourceName(subscription: SubscriptionDef): string;
+export declare function subscriptionQueueLimit(subscription: SubscriptionDef): number;
+export declare function subscriptionBackpressure(subscription: SubscriptionDef): SubscriptionBackpressurePolicy;
+export declare function subscriptionMaxAttempts(subscription: SubscriptionDef): number;
+export declare function subscriptionFailurePolicy(subscription: SubscriptionDef): SubscriptionFailurePolicy;
+export declare function subscriptionDeduplicationWindow(subscription: SubscriptionDef): number;
+export declare function subscriptionAutoStart(subscription: SubscriptionDef): boolean;
+export declare function subscriptionIsRequired(subscription: SubscriptionDef): boolean;
+export declare function subscriptionReconnectPolicy(subscription: SubscriptionDef): RetryPolicy;
+/** Whether this subscription's declared backpressure policy may discard an event. */
+export declare function subscriptionMayLoseEvents(subscription: SubscriptionDef): boolean;
+//# sourceMappingURL=subscriptions.d.ts.map

package/dist/subscriptions.js

@@ -0,0 +1,61 @@
+export const SUBSCRIPTION_LIFECYCLE_STATES = [
+    'inactive',
+    'starting',
+    'active',
+    'reconnecting',
+    'failed',
+    'stopped',
+];
+export const SUBSCRIPTION_BACKPRESSURE_POLICIES = [
+    'block',
+    'reject',
+    'drop-oldest',
+    'drop-newest',
+];
+/** Modes that may discard an accepted delivery. Declaring one is declaring loss. */
+export const LOSSY_BACKPRESSURE_POLICIES = [
+    'drop-oldest',
+    'drop-newest',
+];
+export const SUBSCRIPTION_FAILURE_POLICIES = ['report', 'pause'];
+/** Queue depth a subscription gets when it declares none. */
+export const DEFAULT_SUBSCRIPTION_QUEUE_LIMIT = 64;
+/** Delivery keys a subscription remembers when it declares no window. */
+export const DEFAULT_SUBSCRIPTION_DEDUPLICATION_WINDOW = 512;
+/** Reconnect policy a subscription gets when it declares none. */
+export const DEFAULT_SUBSCRIPTION_RECONNECT = {
+    policy: 'exponential',
+    maxAttempts: 5,
+    delayMs: 1000,
+};
+export function subscriptionSourceName(subscription) {
+    return subscription.source ?? String(subscription.id);
+}
+export function subscriptionQueueLimit(subscription) {
+    return subscription.delivery?.maxQueued ?? DEFAULT_SUBSCRIPTION_QUEUE_LIMIT;
+}
+export function subscriptionBackpressure(subscription) {
+    return subscription.delivery?.backpressure ?? 'block';
+}
+export function subscriptionMaxAttempts(subscription) {
+    return Math.max(1, subscription.delivery?.maxAttempts ?? 1);
+}
+export function subscriptionFailurePolicy(subscription) {
+    return subscription.delivery?.onFailure ?? 'report';
+}
+export function subscriptionDeduplicationWindow(subscription) {
+    return subscription.delivery?.deduplicationWindow ?? DEFAULT_SUBSCRIPTION_DEDUPLICATION_WINDOW;
+}
+export function subscriptionAutoStart(subscription) {
+    return subscription.lifecycle?.autoStart !== false;
+}
+export function subscriptionIsRequired(subscription) {
+    return subscription.lifecycle?.required === true;
+}
+export function subscriptionReconnectPolicy(subscription) {
+    return subscription.lifecycle?.reconnect ?? DEFAULT_SUBSCRIPTION_RECONNECT;
+}
+/** Whether this subscription's declared backpressure policy may discard an event. */
+export function subscriptionMayLoseEvents(subscription) {
+    return LOSSY_BACKPRESSURE_POLICIES.includes(subscriptionBackpressure(subscription));
+}

package/dist/types.d.ts

@@ -5,11 +5,13 @@ import type { ThemeInput } from './theme.js';
 import type { EventDef } from './events.js';
 import type { IntegrationDef, IntegrationOperationDef } from './integrations.js';
 import type { TriggerDef } from './triggers.js';
-export type SemanticNodeKind = 'entity' | 'state' | 'action' | 'constraint' | 'transition-constraint' | 'route' | 'expression' | 'integration' | 'integration-operation' | 'event' | 'trigger';
+import type { SubscriptionDef } from './subscriptions.js';
+import type { StorageDef } from './storage.js';
+export type SemanticNodeKind = 'entity' | 'state' | 'action' | 'constraint' | 'transition-constraint' | 'route' | 'expression' | 'integration' | 'integration-operation' | 'event' | 'trigger' | 'subscription' | 'storage';
 /** Every semantic node kind, enumerated so tests can walk them. */
 export declare const SEMANTIC_NODE_KINDS: readonly SemanticNodeKind[];
 export type NodeKind = SemanticNodeKind | UINodeKind;
-export type AnyNode = EntityDef | StateDef | ActionDef | ConstraintDef | TransitionConstraintDef | RouteDef | ExpressionDef | IntegrationDef | IntegrationOperationDef | EventDef | TriggerDef | UINode;
+export type AnyNode = EntityDef | StateDef | ActionDef | ConstraintDef | TransitionConstraintDef | RouteDef | ExpressionDef | IntegrationDef | IntegrationOperationDef | EventDef | TriggerDef | SubscriptionDef | StorageDef | UINode;
 export type NodeOfKind<K extends NodeKind> = Extract<AnyNode, {
     kind: K;
 }>;

package/dist/types.js

@@ -11,4 +11,6 @@ export const SEMANTIC_NODE_KINDS = [
     'integration-operation',
     'event',
     'trigger',
+    'subscription',
+    'storage',
 ];

package/dist/validate-authority.js

@@ -192,6 +192,34 @@ export function validateAuthority(nodes, principalEntityId, triggerRuntime = ALL
             });
         }
     }
+    // A subscription is an authority-side construct with no client half at all: the browser
+    // runtime maintains no long-lived external source, and 0.9 deliberately declines to
+    // invent a portable client lifecycle for one (spec 0.9 §62-64). Both of the ways a
+    // subscription could validate and then do nothing are rejected here rather than
+    // discovered as silence at run time.
+    const boundEventIds = new Set(nodes
+        .filter((node) => node.kind === 'trigger' && node.when.kind === 'event')
+        .map((node) => node.when.eventId));
+    for (const node of nodes) {
+        if (node.kind !== 'subscription') {
+            continue;
+        }
+        if (!hasServerState) {
+            errors.push({
+                code: VALIDATION_CODES.subscriptionWithoutAuthority,
+                message: `Subscription ${node.name ?? node.id} declares an external event source, but this graph has no server-authoritative state, so no authority would ever activate it`,
+                nodeId: node.id,
+            });
+        }
+        if (!boundEventIds.has(node.eventId)) {
+            errors.push({
+                code: VALIDATION_CODES.subscriptionEventUnreachable,
+                message: `Subscription ${node.name ?? node.id} delivers ${node.eventId}, which no trigger is bound to, so every delivery would be validated and then discarded`,
+                nodeId: node.id,
+                details: { eventId: node.eventId },
+            });
+        }
+    }
     // The principal exists only where an authority evaluates. Reading it anywhere a client
     // evaluates would be a rule the client could simply not apply.
     reportPrincipalOnClient(nodes, context, errors);

package/dist/validate.js

@@ -1,6 +1,8 @@
 import { AGGREGATE_FUNCTIONS, BUILTIN_FUNCTIONS, expressionDefsIn } from './expressions.js';
 import { VALIDATION_CODES } from './diagnostics.js';
 import { EDGE_KINDS, actionGuards, isMutationOperation } from './nodes.js';
+import { SUBSCRIPTION_BACKPRESSURE_POLICIES, subscriptionBackpressure, subscriptionQueueLimit, } from './subscriptions.js';
+import { BLOB_REF_FIELDS } from './storage.js';
 import { entityType } from './type-ref.js';
 import { GROUP_ITEMS_FIELD, GROUP_KEY_FIELD, isGroupFieldId } from './group.js';
 import { isUINode, uiChildIds } from './ui.js';
@@ -146,6 +148,12 @@ function validateNode(node, context) {
         case 'trigger':
             validateTrigger(node, context);
             return;
+        case 'subscription':
+            validateSubscription(node, context);
+            return;
+        case 'storage':
+            validateStorage(node, context);
+            return;
         default:
             context.errors.push({
                 code: VALIDATION_CODES.danglingNodeRef,
@@ -404,6 +412,25 @@ function validateOperation(operation, action, context, local) {
             }
             return local;
         }
+        case 'blob-metadata': {
+            requireKind(operation.storageId, 'storage', action.id, context, VALIDATION_CODES.unknownStorage);
+            validateExpression(operation.blobKey, action.id, context, local);
+            const storage = context.nodes.get(operation.storageId);
+            const resultType = storage?.kind === 'storage' ? entityType(storage.blobEntityId) : undefined;
+            return resultScope(local, operation.bindAs, resultType, context, action.id);
+        }
+        case 'blob-commit':
+        case 'blob-delete': {
+            requireKind(operation.storageId, 'storage', action.id, context, VALIDATION_CODES.unknownStorage);
+            validateExpression(operation.blobKey, action.id, context, local);
+            if (operation.succeededEventId) {
+                requireKind(operation.succeededEventId, 'event', action.id, context, VALIDATION_CODES.unknownEvent);
+            }
+            if (operation.failedEventId) {
+                requireKind(operation.failedEventId, 'event', action.id, context, VALIDATION_CODES.unknownEvent);
+            }
+            return local;
+        }
         default:
             context.errors.push({
                 code: VALIDATION_CODES.danglingNodeRef,
@@ -662,6 +689,91 @@ function validateTrigger(trigger, context) {
     }
 }
 /** Missing required arguments, and arguments the operation declares no parameter for. */
+/**
+ * A subscription's own declaration. Whether it can actually reach an action — and whether
+ * this graph even has an authority to activate it — is decided in `validate-authority.ts`,
+ * with the rest of the authority boundary.
+ */
+function validateSubscription(subscription, context) {
+    requireKind(subscription.integrationId, 'integration', subscription.id, context, VALIDATION_CODES.unknownIntegration);
+    requireKind(subscription.eventId, 'event', subscription.id, context, VALIDATION_CODES.unknownEvent);
+    // Configuration is evaluated once, at activation, in the root scope: there is no delivery
+    // to read yet, so nothing beyond state can be in scope.
+    for (const argument of Object.values(subscription.arguments ?? {})) {
+        validateExpression(argument, subscription.id, context, emptyScope());
+    }
+    if (subscriptionQueueLimit(subscription) < 1) {
+        context.errors.push({
+            code: VALIDATION_CODES.subscriptionInvalidPolicy,
+            message: `Subscription ${subscription.name ?? subscription.id} declares a queue depth below one, which could hold no delivery at all`,
+            nodeId: subscription.id,
+            details: { maxQueued: subscription.delivery?.maxQueued },
+        });
+    }
+    const backpressure = subscriptionBackpressure(subscription);
+    if (!SUBSCRIPTION_BACKPRESSURE_POLICIES.includes(backpressure)) {
+        context.errors.push({
+            code: VALIDATION_CODES.subscriptionInvalidPolicy,
+            message: `Subscription ${subscription.name ?? subscription.id} declares an unknown backpressure policy "${String(backpressure)}"`,
+            nodeId: subscription.id,
+            details: { known: [...SUBSCRIPTION_BACKPRESSURE_POLICIES] },
+        });
+    }
+    if ((subscription.delivery?.maxAttempts ?? 1) < 1) {
+        context.errors.push({
+            code: VALIDATION_CODES.subscriptionInvalidPolicy,
+            message: `Subscription ${subscription.name ?? subscription.id} declares fewer than one delivery attempt, so no delivery could ever be processed`,
+            nodeId: subscription.id,
+        });
+    }
+    // A deduplication key names a field of the payload, so it has to be one. A key that
+    // resolved to nothing would silently deduplicate every delivery against `undefined`.
+    const deduplicateBy = subscription.delivery?.deduplicateBy;
+    if (deduplicateBy !== undefined) {
+        const event = context.nodes.get(subscription.eventId);
+        const payloadType = event?.kind === 'event' ? event.payloadType : undefined;
+        const resolved = payloadType ? resolveKnownType(payloadType) : undefined;
+        const entity = resolved?.kind === 'entity' ? context.nodes.get(resolved.entityId) : undefined;
+        const declared = entity?.kind === 'entity' && entity.fields.some((field) => field.id === deduplicateBy);
+        if (!declared) {
+            context.errors.push({
+                code: VALIDATION_CODES.subscriptionInvalidPolicy,
+                message: `Subscription ${subscription.name ?? subscription.id} deduplicates on ${deduplicateBy}, which is not a field of ${subscription.eventId}'s payload entity`,
+                nodeId: subscription.id,
+                fieldId: deduplicateBy,
+            });
+        }
+    }
+}
+/** A store's own declaration: a canonical blob entity, and rules written over real state. */
+function validateStorage(storage, context) {
+    requireKind(storage.blobEntityId, 'entity', storage.id, context, VALIDATION_CODES.unknownStorage);
+    const entity = context.nodes.get(storage.blobEntityId);
+    if (entity?.kind === 'entity') {
+        const declared = new Set(entity.fields.map((field) => field.id));
+        const missing = BLOB_REF_FIELDS.filter((field) => !declared.has(field));
+        if (missing.length > 0) {
+            context.errors.push({
+                code: VALIDATION_CODES.invalidBlobEntity,
+                message: `Storage ${storage.name ?? storage.id} names ${storage.blobEntityId} as its BlobRef entity, but it does not declare ${missing.join(', ')}; build it with blobRefEntity()`,
+                nodeId: storage.id,
+                details: { missing: missing.map(String) },
+            });
+        }
+    }
+    // The requested blob is bound to the store's own id, the way an event trigger binds its
+    // payload to the trigger's id.
+    const scope = emptyScope(new Set([storage.id]));
+    if (entity?.kind === 'entity') {
+        scope.types.set(storage.id, entityType(storage.blobEntityId));
+    }
+    if (storage.readAuthorization) {
+        validateExpression(storage.readAuthorization, storage.id, context, scope);
+    }
+    if (storage.uploadAuthorization) {
+        validateExpression(storage.uploadAuthorization, storage.id, context, emptyScope());
+    }
+}
 function checkIntegrationArguments(operation, args, ownerId, context) {
     const declared = new Set((operation.parameters ?? []).map((parameter) => String(parameter.id)));
     const missing = (operation.parameters ?? [])

package/package.json

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