@hops-ops/distributed 0.0.0 → 4.0.1

package/dist/replica/commands/receipt.js

@@ -1,4 +1,4 @@
-import { receiptMismatch, sameProjectionMultiset } from './util.js';
+import { receiptMismatch } from './util.js';
 export function verifyReplicaCommandReceipt(prepared, receipt) {
     if (receipt.commandId !== prepared.commandId) {
         receiptMismatch('receipt.commandId');
@@ -6,31 +6,45 @@ export function verifyReplicaCommandReceipt(prepared, receipt) {
     if (receipt.consistency !== prepared.consistency) {
         receiptMismatch('receipt.consistency');
     }
-    const contract = prepared.confirmations;
-    if (contract?.kind === 'unavailable') {
+    if (receipt.projectionDisposition === 'revalidate') {
+        if (prepared.projection === undefined &&
+            !prepared.revalidation.required) {
+            receiptMismatch('receipt.projectionDisposition');
+        }
         return Object.freeze({
-            kind: 'revalidate',
-            revalidate: true,
-            reason: 'confirmation_unavailable'
+            kind: receipt.state === 'succeeded_pending_projection'
+                ? 'deferred'
+                : 'matched',
+            revalidate: true
         });
     }
-    const expected = contract?.kind === 'finite'
-        ? contract.expected.map(({ projector, model }) => ({
-            projection: projector,
-            model
-        }))
-        : [];
     if (receipt.state === 'in_progress' && receipt.expects.length === 0) {
         return Object.freeze({
             kind: 'deferred',
-            revalidate: prepared.revalidation.required
+            revalidate: prepared.revalidation.required ||
+                prepared.projection?.revalidate === true
         });
     }
-    if (!sameProjectionMultiset(expected, receipt.expects)) {
-        receiptMismatch('receipt.expects');
+    if (prepared.projection === undefined) {
+        if (receipt.projection !== undefined || receipt.expects.length !== 0) {
+            receiptMismatch('receipt.expects');
+        }
+    }
+    else if (receipt.projection === undefined) {
+        /*
+         * Ship contract (see server routes: Atomic never persists eventual
+         * modeled projection metadata):
+         * - Eventual: response carries projection-delta (+ expects) when modeled.
+         * - Atomic: response carries typed row + direct `records`; optional
+         *   `.applies` previews use the same IR but seal via the row, not a delta.
+         */
+        if (prepared.consistency !== 'atomic') {
+            receiptMismatch('receipt.expects');
+        }
     }
     return Object.freeze({
         kind: receipt.state === 'in_progress' ? 'deferred' : 'matched',
-        revalidate: prepared.revalidation.required
+        revalidate: prepared.revalidation.required ||
+            prepared.projection?.revalidate === true
     });
 }

package/dist/replica/commands/types.d.ts

@@ -1,5 +1,6 @@
 import type { DistributedCommandConsistency, DistributedTrustedPreset, DistributedTrustedPresetCodec } from '../../protocol.js';
 import type { ReplicaClientSurface, ReplicaValue } from '../types.js';
+import type { PreparedCommandProjection, PreparedProjectionOperation, ReplicaCommandProjection } from '../projection-delta/index.js';
 export type ReplicaCommandScalarCodec = DistributedTrustedPresetCodec;
 /** Static name/codec declaration emitted without a server-derived value. */
 export type ReplicaTrustedPresetDescriptor = {
@@ -127,14 +128,14 @@ export type ReplicaCommandRevalidationPlan = {
     readonly relationships: readonly ReplicaCommandEffectRelationship[];
 };
 /**
- * Framework-neutral executable command descriptor emitted by `dctl client`.
+ * Framework-neutral executable command descriptor emitted by `distributed client`.
  *
  * The compiler has already validated the Rust-owned declaration. Runtime
  * validation remains fail-closed so a stale or hand-edited artifact cannot
  * create optimistic cache truth.
  */
 export type ReplicaCommandArtifact<TInput = void, TOutput = unknown> = {
-    readonly version: 1;
+    readonly version: 2;
     readonly name: string;
     readonly mutationField: string;
     readonly document: string;
@@ -152,8 +153,11 @@ export type ReplicaCommandArtifact<TInput = void, TOutput = unknown> = {
     readonly output: ReplicaCommandShape;
     readonly inputDefaults?: ReplicaCommandInputDefaults;
     readonly consistency: DistributedCommandConsistency;
-    readonly effects: ReplicaCommandEffects;
-    readonly confirmations?: ReplicaCommandConfirmations;
+    /** Compiler-owned projection contract. Absence means no invented delta. */
+    readonly projection?: ReplicaCommandProjection;
+    /** Artifact v1 effects and confirmations are deliberately not decoded. */
+    readonly effects?: never;
+    readonly confirmations?: never;
     readonly directProjection?: ReplicaCommandDirectProjection;
     readonly trustedPresets?: readonly ReplicaTrustedPresetDescriptor[];
     readonly revalidation: ReplicaCommandRevalidationPlan;
@@ -225,9 +229,10 @@ export type ReplicaPreparedCommand<TInput = void, TOutput = unknown> = {
     };
     readonly optimistic: {
         readonly version: 1;
-        readonly operations: readonly ReplicaPreparedCommandEffect[];
+        readonly operations: readonly PreparedProjectionOperation[];
         readonly fallback: 'revalidate';
     };
+    readonly projection?: PreparedCommandProjection;
     readonly confirmations?: ReplicaPreparedConfirmations;
     readonly directProjection?: {
         readonly topology: ReplicaCommandDirectProjection['topology'];

package/dist/replica/commands/validate.d.ts

@@ -7,7 +7,11 @@ export declare function collectTrustedPresetReferences<TInput, TOutput>(artifact
 export declare function validateShape(shape: ReplicaCommandShape, path: string, depth: number, active: Set<ReplicaCommandTypeDefinition>): void;
 export declare function validateDefinition(definition: ReplicaCommandTypeDefinition, path: string, depth: number, active: Set<ReplicaCommandTypeDefinition>): void;
 export declare function validateDefaults(shape: ReplicaCommandShape, defaults: ReplicaCommandInputDefaults | undefined): void;
-export declare function validateConfirmations<TInput, TOutput>(artifact: ReplicaCommandArtifact<TInput, TOutput>): void;
+export declare function validateConfirmations<TInput, TOutput>(artifact: Readonly<{
+    confirmations?: import('./types.js').ReplicaCommandConfirmations;
+    consistency: ReplicaCommandArtifact<TInput, TOutput>['consistency'];
+    input: ReplicaCommandArtifact<TInput, TOutput>['input'];
+}>): void;
 export declare function validateDirectProjection<TInput, TOutput>(artifact: ReplicaCommandArtifact<TInput, TOutput>): void;
 export declare function validateRevalidation<TInput, TOutput>(artifact: ReplicaCommandArtifact<TInput, TOutput>): void;
 export declare function validateEffectArtifact(effect: ReplicaCommandEffect, input: ReplicaCommandShape, path: string): void;

package/dist/replica/commands/validate.js

@@ -3,9 +3,14 @@ import { GRAPHQL_NAME, MAX_TYPE_DEPTH } from './constants.js';
 import { artifactInvalid, hash, isSupportedCodec, nonempty, requiredString } from './util.js';
 import { parseReplicaTrustedPresetDescriptors, trustedPresetName } from './presets.js';
 import { fieldAtPath } from './resolve.js';
+import { ProjectionDeltaValidationError, validateCommandProjectionArtifact } from '../projection-delta/index.js';
 export function validateArtifact(artifact, allowTrustedPresets) {
-    if (artifact.version !== 1)
+    if (artifact.version !== 2)
         artifactInvalid('artifact.version');
+    if (Object.prototype.hasOwnProperty.call(artifact, 'effects') ||
+        Object.prototype.hasOwnProperty.call(artifact, 'confirmations')) {
+        artifactInvalid('artifact.version');
+    }
     nonempty(artifact.name, 'artifact.name');
     if (!GRAPHQL_NAME.test(artifact.mutationField)) {
         artifactInvalid('artifact.mutationField');
@@ -37,23 +42,22 @@ export function validateArtifact(artifact, allowTrustedPresets) {
     if (artifact.output.kind === 'none')
         artifactInvalid('artifact.output.kind');
     validateDefaults(artifact.input, artifact.inputDefaults);
-    if (artifact.consistency !== 'accepted' &&
-        artifact.consistency !== 'fact' &&
-        artifact.consistency !== 'projected') {
+    if (artifact.consistency !== 'succeeded' &&
+        artifact.consistency !== 'eventual' &&
+        artifact.consistency !== 'atomic') {
         artifactInvalid('artifact.consistency');
     }
-    if (artifact.effects.version !== 1)
-        artifactInvalid('artifact.effects.version');
-    if (artifact.effects.fallback !== 'revalidate') {
-        artifactInvalid('artifact.effects.fallback');
-    }
-    if (!Array.isArray(artifact.effects.operations)) {
-        artifactInvalid('artifact.effects.operations');
-    }
-    for (let index = 0; index < artifact.effects.operations.length; index += 1) {
-        validateEffectArtifact(artifact.effects.operations[index], artifact.input, `artifact.effects.operations[${index}]`);
+    if (artifact.projection !== undefined) {
+        try {
+            validateProjectionCapabilities(validateCommandProjectionArtifact(artifact.projection), artifact);
+        }
+        catch (error) {
+            if (error instanceof ProjectionDeltaValidationError) {
+                artifactInvalid(error.path);
+            }
+            throw error;
+        }
     }
-    validateConfirmations(artifact);
     validateDirectProjection(artifact);
     validateRevalidation(artifact);
     validateTrustedPresetReferences(artifact, trustedPresets, allowTrustedPresets);
@@ -66,16 +70,33 @@ export function validateClientSurface(surface, path) {
     if (surface.kind === 'role')
         return;
     if (surface.kind !== 'application' ||
-        !Array.isArray(surface.roles) ||
-        surface.roles.length === 0) {
+        !Array.isArray(surface.eligible_roles) ||
+        !Array.isArray(surface.schema_roles) ||
+        surface.eligible_roles.length === 0 ||
+        surface.schema_roles.length === 0) {
         artifactInvalid(path);
     }
-    const roles = new Set();
-    for (let index = 0; index < surface.roles.length; index += 1) {
-        const role = requiredString(surface.roles[index], `${path}.roles[${index}]`);
-        if (roles.has(role))
-            artifactInvalid(`${path}.roles[${index}]`);
-        roles.add(role);
+    const eligibleRoles = new Set();
+    for (let index = 0; index < surface.eligible_roles.length; index += 1) {
+        const role = requiredString(surface.eligible_roles[index], `${path}.eligible_roles[${index}]`);
+        if (eligibleRoles.has(role))
+            artifactInvalid(`${path}.eligible_roles[${index}]`);
+        if (index > 0 && surface.eligible_roles[index - 1] >= role) {
+            artifactInvalid(`${path}.eligible_roles[${index}]`);
+        }
+        eligibleRoles.add(role);
+    }
+    const schemaRoles = new Set();
+    for (let index = 0; index < surface.schema_roles.length; index += 1) {
+        const role = requiredString(surface.schema_roles[index], `${path}.schema_roles[${index}]`);
+        if (schemaRoles.has(role))
+            artifactInvalid(`${path}.schema_roles[${index}]`);
+        if (index > 0 && surface.schema_roles[index - 1] >= role) {
+            artifactInvalid(`${path}.schema_roles[${index}]`);
+        }
+        if (!eligibleRoles.has(role))
+            artifactInvalid(`${path}.schema_roles[${index}]`);
+        schemaRoles.add(role);
     }
 }
 export function validateTrustedPresetReferences(artifact, descriptors, allowTrustedPresets) {
@@ -102,52 +123,99 @@ export function collectTrustedPresetReferences(artifact) {
             out.push(Object.freeze({ name: value.name, path }));
         }
     };
-    const fields = (value, path) => {
-        for (let index = 0; index < value.length; index += 1) {
-            expression(value[index].value, `${path}[${index}].value`);
+    if (artifact.projection !== undefined) {
+        for (let index = 0; index < artifact.projection.preview.operations.length; index += 1) {
+            const mutation = artifact.projection.preview.operations[index].mutation;
+            collectPreviewMutationPresets(mutation, `artifact.projection.preview.operations[${index}].mutation`, out);
+        }
+    }
+    if (artifact.directProjection?.partition !== undefined) {
+        expression(artifact.directProjection.partition, 'artifact.directProjection.partition');
+    }
+    return Object.freeze(out);
+}
+function collectPreviewMutationPresets(mutation, path, out) {
+    const value = (expression, valuePath) => {
+        switch (expression.kind) {
+            case 'trusted_preset':
+                out.push(Object.freeze({ name: expression.name, path: valuePath }));
+                break;
+            case 'list':
+                expression.values.forEach((item, index) => value(item, `${valuePath}.values[${index}]`));
+                break;
+            case 'object':
+                expression.fields.forEach((field, index) => value(field.value, `${valuePath}.fields[${index}].value`));
+                break;
+            case 'transform':
+                expression.arguments.forEach((item, index) => value(item, `${valuePath}.arguments[${index}]`));
+                break;
+            default:
+                break;
         }
     };
-    const key = (value, path) => {
-        fields(value.fields, `${path}.fields`);
+    const scope = (candidate, scopePath) => {
+        if (candidate.partition.kind === 'expression') {
+            value(candidate.partition.expression, `${scopePath}.partition.expression`);
+        }
+        candidate.key.forEach((field, index) => value(field.value, `${scopePath}.key[${index}].value`));
     };
-    for (let index = 0; index < artifact.effects.operations.length; index += 1) {
-        const effect = artifact.effects.operations[index];
-        const path = `artifact.effects.operations[${index}]`;
-        switch (effect.kind) {
+    switch (mutation.op) {
+        case 'upsert':
+        case 'patch':
+            scope(mutation.scope, `${path}.scope`);
+            (mutation.op === 'upsert' ? mutation.fields : mutation.set).forEach((field, index) => value(field.value, `${path}.fields[${index}].value`));
+            break;
+        case 'delete':
+            scope(mutation.scope, `${path}.scope`);
+            break;
+        case 'link':
+        case 'unlink':
+            scope(mutation.source, `${path}.source`);
+            scope(mutation.target, `${path}.target`);
+            break;
+        case 'invalidate_relationship':
+            scope(mutation.source, `${path}.source`);
+            break;
+        case 'invalidate_model':
+            if (mutation.partition?.kind === 'expression') {
+                value(mutation.partition.expression, `${path}.partition.expression`);
+            }
+            break;
+    }
+}
+function validateProjectionCapabilities(projection, artifact) {
+    const models = new Set(artifact.revalidation.models);
+    const relationships = new Set(artifact.revalidation.relationships.map((item) => `${item.sourceModel}\0${item.field}\0${item.targetModel}`));
+    const requireModel = (model, path) => {
+        if (!models.has(model))
+            artifactInvalid(path);
+    };
+    for (let index = 0; index < projection.preview.operations.length; index += 1) {
+        const mutation = projection.preview.operations[index].mutation;
+        const path = `artifact.projection.preview.operations[${index}].mutation`;
+        switch (mutation.op) {
             case 'upsert':
             case 'patch':
-                key(effect.key, `${path}.key`);
-                fields(effect.fields, `${path}.fields`);
-                break;
             case 'delete':
-                key(effect.key, `${path}.key`);
+                requireModel(mutation.scope.model, `${path}.scope.model`);
                 break;
             case 'link':
             case 'unlink':
-                key(effect.source, `${path}.source`);
-                key(effect.target, `${path}.target`);
-                break;
-            case 'invalidate_relationship':
-                key(effect.source, `${path}.source`);
+                requireModel(mutation.source.model, `${path}.source.model`);
+                requireModel(mutation.target.model, `${path}.target.model`);
+                if (!relationships.has(`${mutation.source.model}\0${mutation.relationship}\0${mutation.target.model}`))
+                    artifactInvalid(`${path}.relationship`);
                 break;
             case 'invalidate_model':
+                requireModel(mutation.model, `${path}.model`);
+                break;
+            case 'invalidate_relationship':
+                requireModel(mutation.source.model, `${path}.source.model`);
+                if (![...relationships].some((relationship) => relationship.startsWith(`${mutation.source.model}\0${mutation.relationship}\0`)))
+                    artifactInvalid(`${path}.relationship`);
                 break;
         }
     }
-    if (artifact.confirmations?.kind === 'finite') {
-        for (let index = 0; index < artifact.confirmations.expected.length; index += 1) {
-            const confirmation = artifact.confirmations.expected[index];
-            const path = `artifact.confirmations.expected[${index}]`;
-            key(confirmation.key, `${path}.key`);
-            if (confirmation.partition !== undefined) {
-                expression(confirmation.partition, `${path}.partition`);
-            }
-        }
-    }
-    if (artifact.directProjection?.partition !== undefined) {
-        expression(artifact.directProjection.partition, 'artifact.directProjection.partition');
-    }
-    return Object.freeze(out);
 }
 export function validateShape(shape, path, depth, active) {
     if (depth > MAX_TYPE_DEPTH)
@@ -236,7 +304,7 @@ export function validateDefaults(shape, defaults) {
 export function validateConfirmations(artifact) {
     const confirmations = artifact.confirmations;
     if (confirmations === undefined) {
-        if (artifact.consistency === 'fact') {
+        if (artifact.consistency === 'eventual') {
             artifactInvalid('artifact.confirmations');
         }
         return;
@@ -259,7 +327,7 @@ export function validateConfirmations(artifact) {
     else {
         artifactInvalid('artifact.confirmations.kind');
     }
-    if (artifact.consistency === 'projected') {
+    if (artifact.consistency === 'atomic') {
         artifactInvalid('artifact.confirmations');
     }
     if (confirmations.kind === 'finite') {
@@ -277,10 +345,10 @@ export function validateConfirmations(artifact) {
 }
 export function validateDirectProjection(artifact) {
     const direct = artifact.directProjection;
-    if (artifact.consistency === 'projected' && direct === undefined) {
+    if (artifact.consistency === 'atomic' && direct === undefined) {
         artifactInvalid('artifact.directProjection');
     }
-    if (artifact.consistency !== 'projected' && direct !== undefined) {
+    if (artifact.consistency !== 'atomic' && direct !== undefined) {
         artifactInvalid('artifact.directProjection');
     }
     if (direct === undefined)
@@ -338,9 +406,8 @@ export function validateRevalidation(artifact) {
     for (const [index, relationship] of plan.relationships.entries()) {
         validateRelationshipArtifact(relationship, `artifact.revalidation.relationships[${index}]`);
     }
-    if ((artifact.effects.operations.length === 0 ||
-        (artifact.consistency !== 'projected' &&
-            artifact.confirmations?.kind !== 'finite')) &&
+    if (((artifact.projection?.preview.operations.length ?? 0) === 0 &&
+        artifact.consistency !== 'atomic') &&
         !plan.required) {
         artifactInvalid('artifact.revalidation.required');
     }

package/dist/replica/diagnostics/inspect.js

@@ -29,43 +29,47 @@ export function inspectReplicaOperationArtifact(artifact) {
     });
 }
 export function inspectReplicaCommandArtifact(artifact) {
-    const effects = artifact.effects.operations.map((effect) => {
+    const effects = (artifact.projection?.preview.operations ?? []).map(({ mutation: effect }) => {
         const models = new Set();
         const fields = new Set();
         const sources = new Set();
-        if ('model' in effect)
+        if (effect.op === 'invalidate_model')
             models.add(effect.model);
-        if ('relationship' in effect) {
-            models.add(effect.relationship.sourceModel);
-            models.add(effect.relationship.targetModel);
-            fields.add(effect.relationship.field);
-        }
-        if ('key' in effect) {
-            for (const field of effect.key.fields) {
+        if ('scope' in effect) {
+            models.add(effect.scope.model);
+            for (const field of effect.scope.key) {
                 fields.add(field.field);
-                sources.add(expressionSource(field.value));
+                collectPreviewValueSources(field.value, sources);
             }
         }
         if ('source' in effect) {
-            for (const field of effect.source.fields) {
+            models.add(effect.source.model);
+            for (const field of effect.source.key) {
                 fields.add(field.field);
-                sources.add(expressionSource(field.value));
+                collectPreviewValueSources(field.value, sources);
             }
         }
         if ('target' in effect) {
-            for (const field of effect.target.fields) {
+            models.add(effect.target.model);
+            for (const field of effect.target.key) {
                 fields.add(field.field);
-                sources.add(expressionSource(field.value));
+                collectPreviewValueSources(field.value, sources);
             }
         }
         if ('fields' in effect) {
             for (const field of effect.fields) {
                 fields.add(field.field);
-                sources.add(expressionSource(field.value));
+                collectPreviewValueSources(field.value, sources);
+            }
+        }
+        if ('set' in effect) {
+            for (const field of effect.set) {
+                fields.add(field.field);
+                collectPreviewValueSources(field.value, sources);
             }
         }
         return Object.freeze({
-            kind: effect.kind,
+            kind: effect.op,
             models: Object.freeze([...models].sort()),
             fields: Object.freeze([...fields].sort()),
             valueSources: Object.freeze([...sources].sort())
@@ -84,6 +88,37 @@ export function inspectReplicaCommandArtifact(artifact) {
         })
     });
 }
+function collectPreviewValueSources(value, out) {
+    switch (value.kind) {
+        case 'input':
+        case 'generated_default':
+            out.add('input');
+            return;
+        case 'trusted_preset':
+            out.add('trusted_preset');
+            return;
+        case 'constant':
+            out.add('constant');
+            return;
+        case 'null':
+            out.add('null');
+            return;
+        case 'list':
+            for (const item of value.values)
+                collectPreviewValueSources(item, out);
+            return;
+        case 'object':
+            for (const field of value.fields) {
+                collectPreviewValueSources(field.value, out);
+            }
+            return;
+        case 'transform':
+            for (const argument of value.arguments) {
+                collectPreviewValueSources(argument, out);
+            }
+            return;
+    }
+}
 function inspectRoot(root, path, injected, dependencies, indexes) {
     for (const dependency of root.dependencies)
         dependencies.add(dependency);
@@ -165,6 +200,3 @@ function inspectSelection(selection, path, injected, dependencies, indexes) {
         inspectSelection(member.selection, memberPath, injected, dependencies, indexes);
     }
 }
-function expressionSource(expression) {
-    return expression.kind;
-}

package/dist/replica/diagnostics/types.d.ts

@@ -99,8 +99,8 @@ export type ReplicaDiagnosticReceiptExpectationInput = Readonly<{
 }>;
 export type ReplicaDiagnosticReceiptInput = Readonly<{
     commandId: string;
-    state: 'optimistic' | 'accepted' | 'accepted_pending_projection';
-    consistency?: 'accepted' | 'fact' | 'projected';
+    state: 'optimistic' | 'succeeded' | 'succeeded_pending_projection';
+    consistency?: 'succeeded' | 'eventual' | 'atomic';
     expectations: readonly ReplicaDiagnosticReceiptExpectationInput[];
 }>;
 /** Engine-independent state contract implemented by DistributedReplica. */
@@ -138,7 +138,7 @@ export type ReplicaDiagnosticEventInput = Readonly<{
 }> | Readonly<{
     kind: 'receipt';
     command: string;
-    state: 'optimistic' | 'accepted' | 'accepted_pending_projection' | 'projected' | 'rejected';
+    state: 'optimistic' | 'succeeded' | 'succeeded_pending_projection' | 'atomic' | 'rejected';
     obligations: number;
     observed: number;
 }> | Readonly<{
@@ -152,7 +152,7 @@ export type ReplicaDiagnosticEventInput = Readonly<{
 }> | Readonly<{
     kind: 'hydration';
     action: 'accepted' | 'rejected';
-    reason: 'accepted' | 'invalid' | 'scope-mismatch' | 'artifact-mismatch' | 'active-scope-mismatch' | 'metadata-mismatch';
+    reason: 'accepted' | 'same-scope-merge' | 'invalid' | 'scope-mismatch' | 'artifact-mismatch' | 'active-scope-mismatch' | 'metadata-mismatch';
 }> | Readonly<{
     kind: 'scope';
     action: 'established' | 'changed' | 'invalidated';
@@ -200,8 +200,8 @@ export type ReplicaDiagnosticLayer = Readonly<{
 }>;
 export type ReplicaDiagnosticReceipt = Readonly<{
     commandId: string;
-    state: 'optimistic' | 'accepted' | 'accepted_pending_projection';
-    consistency?: 'accepted' | 'fact' | 'projected';
+    state: 'optimistic' | 'succeeded' | 'succeeded_pending_projection';
+    consistency?: 'succeeded' | 'eventual' | 'atomic';
     expectations: readonly ReplicaDiagnosticReceiptExpectationInput[];
 }>;
 export type ReplicaArtifactSourceLocation = Readonly<{
@@ -246,7 +246,7 @@ export type ReplicaCommandArtifactInspection = Readonly<{
     kind: 'command';
     name: string;
     operation: string;
-    consistency: 'accepted' | 'fact' | 'projected';
+    consistency: 'succeeded' | 'eventual' | 'atomic';
     effects: readonly ReplicaCommandEffectInspection[];
     revalidation: Readonly<{
         required: boolean;

package/dist/replica/distributed-replica/helpers.js

@@ -272,7 +272,10 @@ export function replicaClientRequestExtensions(artifact) {
         : Object.freeze({
             kind: 'application',
             name: protocol.surface.name,
-            roles: Object.freeze([...protocol.surface.roles])
+            eligible_roles: Object.freeze([
+                ...protocol.surface.eligible_roles
+            ]),
+            schema_roles: Object.freeze([...protocol.surface.schema_roles])
         });
     return Object.freeze({
         extensions: Object.freeze({
@@ -364,14 +367,25 @@ export function validatedSurfaceIdentity(value) {
         return JSON.stringify(['role', value.name]);
     }
     if (value.kind !== 'application' ||
-        !Array.isArray(value.roles) ||
-        value.roles.length === 0 ||
-        value.roles.some((role) => typeof role !== 'string' || role.length === 0) ||
-        new Set(value.roles).size !== value.roles.length ||
-        [...value.roles].sort().some((role, index) => role !== value.roles[index])) {
+        !Array.isArray(value.eligible_roles) ||
+        !Array.isArray(value.schema_roles) ||
+        value.eligible_roles.length === 0 ||
+        value.schema_roles.length === 0 ||
+        value.eligible_roles.some((role) => typeof role !== 'string' || role.length === 0) ||
+        value.schema_roles.some((role) => typeof role !== 'string' || role.length === 0) ||
+        new Set(value.eligible_roles).size !== value.eligible_roles.length ||
+        new Set(value.schema_roles).size !== value.schema_roles.length ||
+        [...value.eligible_roles].sort().some((role, index) => role !== value.eligible_roles[index]) ||
+        [...value.schema_roles].sort().some((role, index) => role !== value.schema_roles[index]) ||
+        value.schema_roles.some((role) => !value.eligible_roles.includes(role))) {
         throw new TypeError('replica artifact client surface is invalid');
     }
-    return JSON.stringify(['application', value.name, value.roles]);
+    return JSON.stringify([
+        'application',
+        value.name,
+        value.eligible_roles,
+        value.schema_roles
+    ]);
 }
 export function snapshotFrom(materialized, state) {
     const status = state.errors.length > 0
@@ -434,7 +448,7 @@ export function graphqlError(error) {
     });
 }
 export function assertWriteSource(source) {
-    if (!['network', 'live', 'ssr', 'restore', 'projected'].includes(source)) {
+    if (!['network', 'live', 'ssr', 'restore', 'atomic'].includes(source)) {
         throw new TypeError(`unsupported replica write source: ${source}`);
     }
 }

package/dist/replica/distributed-replica/hydration.js

@@ -45,13 +45,19 @@ export function serializeOperationProtocolState(state) {
 }
 export function parseAuthoritativeScope(value) {
     try {
-        const scope = hydrationRecord(value, 'authoritativeScope', ['protocolVersion', 'schemaHash', 'cacheScope']);
+        const scope = hydrationRecord(value, 'authoritativeScope', [
+            'protocolVersion',
+            'schemaHash',
+            'authorizationGeneration',
+            'cacheScope'
+        ]);
         if (scope.protocolVersion !== 1) {
             hydrationInvalid('authoritativeScope.protocolVersion');
         }
         return Object.freeze({
             protocolVersion: 1,
             schemaHash: hydrationString(scope.schemaHash, 'authoritativeScope.schemaHash'),
+            authorizationGeneration: hydrationString(scope.authorizationGeneration, 'authoritativeScope.authorizationGeneration'),
             cacheScope: hydrationOpaque(scope.cacheScope, 'authoritativeScope.cacheScope')
         });
     }
@@ -133,13 +139,19 @@ export function parseReplicaHydration(value) {
         const state = hydrationRecord(value, 'state', ['version', 'scope', 'payload']);
         if (state.version !== 1)
             hydrationInvalid('state.version');
-        const scopeValue = hydrationRecord(state.scope, 'state.scope', ['protocolVersion', 'schemaHash', 'cacheScope']);
+        const scopeValue = hydrationRecord(state.scope, 'state.scope', [
+            'protocolVersion',
+            'schemaHash',
+            'authorizationGeneration',
+            'cacheScope'
+        ]);
         if (scopeValue.protocolVersion !== 1) {
             hydrationInvalid('state.scope.protocolVersion');
         }
         const scope = Object.freeze({
             protocolVersion: 1,
             schemaHash: hydrationString(scopeValue.schemaHash, 'state.scope.schemaHash'),
+            authorizationGeneration: hydrationString(scopeValue.authorizationGeneration, 'state.scope.authorizationGeneration'),
             cacheScope: hydrationOpaque(scopeValue.cacheScope, 'state.scope.cacheScope')
         });
         const payload = hydrationRecord(state.payload, 'state.payload', [