ankka 0.11.0 → 0.13.0

package/dist/consumer.d.ts

@@ -3,8 +3,10 @@ import type { Contract, Publication } from "./contract.ts";
 import type { Shape } from "./codec.ts";
 import type { Metadata } from "./effects/common.ts";
 import { type ComponentClient, type ComponentRef, type Secrets } from "./client.ts";
+import { type Buckets } from "./storage.ts";
 import { ConsumerEffects, type ConsumerEffect } from "./effects/stateless.ts";
 import { type Services } from "./services.ts";
+import type { Standing } from "./standing.ts";
 type MaybePromise<T> = T | Promise<T>;
 /** The metadata entry a runtime sets on a consumer's request to say what it speaks: its protocol version. */
 export declare const PROTOCOL_KEY = "ankka.protocol";
@@ -26,13 +28,23 @@ export declare abstract class Consumer<M, Out = never> {
     /** The message's metadata: `ce-subject` is the source instance's id, `ankka.sequence` its sequence number. */
     get metadata(): Metadata;
     get subject(): string;
+    /** Of a change from a workflow: where it stood once the effect that recorded the state was applied. `undefined` for a change from an entity or a topic. */
+    get standing(): Standing | undefined;
     /** The change's sequence number: an event's, or a key value state's revision. `0n` for a topic's message. */
     get sequenceNumber(): bigint | undefined;
+    /** Of a replicated entity's change (1.19): the installation that wrote it. `undefined` otherwise. */
+    get installation(): string | undefined;
+    /** Whether the change was written at this installation: `false` only for a replicated entity's mirrored change. */
+    get localOrigin(): boolean;
     get client(): ComponentClient;
     /** The service's secret store: values kept encrypted in the service's own database, never in a journal or a view. */
     get secrets(): Secrets;
     /** A unit test's store in place of the runtime's: `component.secrets = new InMemorySecrets()`. */
     set secrets(store: Secrets);
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage(): Buckets;
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets: Buckets);
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services(): Services;
     /** A unit test's in place of the runtime's: `component.services = new ScriptedServices()`. */
@@ -43,7 +55,7 @@ export declare abstract class Consumer<M, Out = never> {
     /** The source was deleted. Ignored unless this says otherwise. */
     onDelete(): MaybePromise<ConsumerEffect<Out>>;
     /** @internal */
-    _bind(metadata: Metadata, client: ComponentClient): void;
+    _bind(metadata: Metadata, client: ComponentClient, standing?: Standing): void;
 }
 export interface ConsumerClass<M = unknown, Out = unknown, C extends Consumer<M, Out> = Consumer<M, Out>> {
     new (): C;
@@ -58,6 +70,11 @@ export interface ConsumerClass<M = unknown, Out = unknown, C extends Consumer<M,
     readonly contract?: Contract;
     /** The declared broker the topic read is on; absent is the installation's. */
     readonly broker?: string;
+    /**
+     * Another project's topic (1.15): the id of the project whose topic `topic` is. The broker serves it
+     * while that project grants this service consume on it.
+     */
+    readonly project?: string;
     /** Whether the partitions an instance holds are handled at once, each in order. */
     readonly parallel?: boolean;
     readonly message: Shape<M>;
@@ -65,5 +82,10 @@ export interface ConsumerClass<M = unknown, Out = unknown, C extends Consumer<M,
     readonly out?: Shape<Out>;
     /** The topic produced to: its name, or a `Publication` with the contract stated for it and its broker. */
     readonly producesTo?: string | Publication;
+    /**
+     * A consumer that publishes is given a replicated entity's changes written at other installations
+     * too only when this says so (1.19); otherwise each is published once, where it was written.
+     */
+    readonly mirroredChanges?: boolean;
 }
 export {};

package/dist/consumer.js

@@ -1,5 +1,6 @@
 // A consumer: reacts to a source's changes, optionally producing onward to a topic.
 import { secretsFor } from "./client.js";
+import { processStorage } from "./storage.js";
 import { ConsumerEffects } from "./effects/stateless.js";
 import { servicesFor } from "./services.js";
 /** The metadata entry a runtime sets on a consumer's request to say what it speaks: its protocol version. */
@@ -31,6 +32,7 @@ export function sequenceNumberOf(metadata) {
 export class Consumer {
     effects = new ConsumerEffects();
     #metadata = {};
+    #standing = undefined;
     #client;
     /** The message's metadata: `ce-subject` is the source instance's id, `ankka.sequence` its sequence number. */
     get metadata() {
@@ -39,10 +41,22 @@ export class Consumer {
     get subject() {
         return this.#metadata["ce-subject"] ?? "";
     }
+    /** Of a change from a workflow: where it stood once the effect that recorded the state was applied. `undefined` for a change from an entity or a topic. */
+    get standing() {
+        return this.#standing;
+    }
     /** The change's sequence number: an event's, or a key value state's revision. `0n` for a topic's message. */
     get sequenceNumber() {
         return sequenceNumberOf(this.#metadata);
     }
+    /** Of a replicated entity's change (1.19): the installation that wrote it. `undefined` otherwise. */
+    get installation() {
+        return this.#metadata["ankka.installation"];
+    }
+    /** Whether the change was written at this installation: `false` only for a replicated entity's mirrored change. */
+    get localOrigin() {
+        return this.#metadata["ankka.local"] !== "false";
+    }
     get client() {
         if (!this.#client)
             throw new Error("client is only available inside onMessage or onDelete");
@@ -57,6 +71,15 @@ export class Consumer {
     set secrets(store) {
         this.#secrets = store;
     }
+    #storage;
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage() {
+        return this.#storage ?? processStorage();
+    }
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets) {
+        this.#storage = buckets;
+    }
     #services;
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services() {
@@ -75,8 +98,9 @@ export class Consumer {
         return this.effects.ignore();
     }
     /** @internal */
-    _bind(metadata, client) {
+    _bind(metadata, client, standing) {
         this.#metadata = metadata;
+        this.#standing = standing;
         this.#client = client;
     }
 }

package/dist/context.d.ts

@@ -10,8 +10,26 @@ export interface CommandContext {
     readonly metadata: Metadata;
     /** The current instant; a seam a test can replace. */
     now(): Instant;
+    /** The installation handling the command, for a replicated entity (1.19); `null` when none is named. */
+    readonly installation: string | null;
+    /**
+     * Whether this installation is the replicated entity's home. A command that may persist runs only at
+     * the home, so this is `false` only for a query a follower answers; `true` for an entity not replicated.
+     */
+    readonly isHome: boolean;
 }
-export declare function commandContext(componentId: string, entityId: string, sequenceNumber: bigint, metadata: Metadata, now?: () => Instant): CommandContext;
+export declare function commandContext(componentId: string, entityId: string, sequenceNumber: bigint, metadata: Metadata, now?: () => Instant, installation?: string | null, isHome?: boolean): CommandContext;
+/**
+ * Where the event `applyEvent` is applying was written (1.19): the installation (`null` when none is
+ * named; an event from before replication reads as written at the home), whether that was this
+ * installation, and its sequence number. The third argument of `applyEvent`.
+ */
+export interface EventContext {
+    readonly installation: string | null;
+    readonly isLocal: boolean;
+    readonly sequence: bigint;
+}
+export declare function eventContext(installation: string | null, isLocal: boolean, sequence: bigint): EventContext;
 export declare function metadataFromProto(proto: ProtoMetadata | undefined): Metadata;
 export declare function metadataToProto(metadata: Metadata | undefined): {
     entries: {
@@ -41,6 +59,12 @@ export type Caller = {
     readonly kind: "service";
     readonly project: string;
     readonly name: string;
+}
+/** A machine registered on an organization, proven by a token the control plane issued (protocol 1.15). */
+ | {
+    readonly kind: "machine";
+    readonly organization: string;
+    readonly name: string;
 } | {
     readonly kind: "local";
 };

package/dist/context.js

@@ -4,8 +4,11 @@
 // request per asynchronous context, and work handed to another context cannot see it.
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Instant } from "./time.js";
-export function commandContext(componentId, entityId, sequenceNumber, metadata, now = Instant.now) {
-    return Object.freeze({ componentId, entityId, sequenceNumber, metadata, now });
+export function commandContext(componentId, entityId, sequenceNumber, metadata, now = Instant.now, installation = null, isHome = true) {
+    return Object.freeze({ componentId, entityId, sequenceNumber, metadata, now, installation, isHome });
+}
+export function eventContext(installation, isLocal, sequence) {
+    return Object.freeze({ installation, isLocal, sequence });
 }
 export function metadataFromProto(proto) {
     const out = {};

package/dist/contract.d.ts

@@ -31,6 +31,10 @@ export interface Publication {
     readonly topic: string;
     readonly contract?: Contract;
     readonly broker?: string;
+    /** Another project's topic (1.15), which that project must grant this service produce on. */
+    readonly project?: string;
 }
+/** The first protocol in which a process can read or publish to another project's topic. */
+export declare const GRANTS_PROTOCOL: readonly [number, number];
 /** The first protocol in which a process can declare a contract, a broker or parallel reading. */
 export declare const CONTRACT_PROTOCOL: readonly [number, number];

package/dist/contract.js

@@ -54,5 +54,7 @@ export function fingerprintOf(document) {
         throw new TypeError("a schema document must be JSON");
     return "sha256:" + createHash("sha256").update(canonical, "utf8").digest("hex");
 }
+/** The first protocol in which a process can read or publish to another project's topic. */
+export const GRANTS_PROTOCOL = [1, 15];
 /** The first protocol in which a process can declare a contract, a broker or parallel reading. */
 export const CONTRACT_PROTOCOL = [1, 14];

package/dist/effects/common.d.ts

@@ -9,6 +9,10 @@ export declare const ErrorCode: Readonly<{
     readonly Conflict: "CONFLICT";
     readonly Timeout: "TIMEOUT";
     readonly Unavailable: "UNAVAILABLE";
+    /** A workflow a caller waited for failed or was deleted (protocol 1.18); the step and the reason are in `details`. */
+    readonly WorkflowFailed: "WORKFLOW_FAILED";
+    /** A replicated entity's copy here cannot answer (1.19): its home is unreachable, or the read is outside the replication set. */
+    readonly NotHome: "NOT_HOME";
 }>;
 export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
 export declare function httpStatusOf(code: ErrorCode): number;
@@ -16,10 +20,13 @@ export declare function httpStatusOf(code: ErrorCode): number;
 export interface ErrorDetail {
     readonly message: string;
     readonly code: ErrorCode;
+    /** What a caller reads without parsing the message: a failed workflow's `step`, `reason` and `deleted`. */
+    readonly details?: Readonly<Record<string, string>>;
 }
 /** Thrown by the component client when the callee refused. */
 export declare class CommandError extends Error {
     readonly code: ErrorCode;
+    readonly details: Readonly<Record<string, string>>;
     constructor(detail: ErrorDetail);
     get detail(): ErrorDetail;
 }

package/dist/effects/common.js

@@ -10,6 +10,10 @@ export const ErrorCode = Object.freeze({
     Conflict: "CONFLICT",
     Timeout: "TIMEOUT",
     Unavailable: "UNAVAILABLE",
+    /** A workflow a caller waited for failed or was deleted (protocol 1.18); the step and the reason are in `details`. */
+    WorkflowFailed: "WORKFLOW_FAILED",
+    /** A replicated entity's copy here cannot answer (1.19): its home is unreachable, or the read is outside the replication set. */
+    NotHome: "NOT_HOME",
 });
 const HTTP_STATUS = Object.freeze({
     INTERNAL: 500,
@@ -20,6 +24,8 @@ const HTTP_STATUS = Object.freeze({
     CONFLICT: 409,
     TIMEOUT: 504,
     UNAVAILABLE: 503,
+    WORKFLOW_FAILED: 424,
+    NOT_HOME: 421,
 });
 export function httpStatusOf(code) {
     return HTTP_STATUS[code];
@@ -27,13 +33,15 @@ export function httpStatusOf(code) {
 /** Thrown by the component client when the callee refused. */
 export class CommandError extends Error {
     code;
+    details;
     constructor(detail) {
         super(detail.message);
         this.name = "CommandError";
         this.code = detail.code;
+        this.details = detail.details ?? {};
     }
     get detail() {
-        return { message: this.message, code: this.code };
+        return { message: this.message, code: this.code, details: this.details };
     }
 }
 export const Outcome = Object.freeze({

package/dist/effects/eventSourced.d.ts

@@ -1,11 +1,21 @@
 import type { Duration } from "../time.ts";
 import { done, type Done } from "../schema.ts";
 import { ErrorCode, Outcome, Retention, type EffectLike, type Metadata, type ReadOnlyLike } from "./common.ts";
+/** What a replicated entity's handler asks of its home beside the events it persists (1.19). */
+export type ReplicationChange = {
+    readonly kind: "hand-over";
+    readonly to: string;
+} | {
+    readonly kind: "set";
+    readonly add: readonly string[];
+    readonly remove: readonly string[];
+};
 export interface PersistEffect<S, E, R> extends EffectLike<R> {
     readonly kind: "persist";
     readonly events: readonly E[];
     readonly retention: Retention | null;
     readonly outcome: Outcome<S, R>;
+    readonly replication?: ReplicationChange;
 }
 export interface ReadOnlyEffect<S, E, R> extends ReadOnlyLike<R> {
     readonly kind: "read-only";
@@ -18,11 +28,20 @@ export type EventSourcedEffect<S, E, R> = PersistEffect<S, E, R> | ReadOnlyEffec
 /** `effects.persist(e)` returns one of these; finish it with `thenReply`, `thenReplyState` or `thenNoReply`. */
 export declare class PersistBuilder<S, E> {
     #private;
-    constructor(events: readonly E[], retention?: Retention | null);
+    constructor(events: readonly E[], retention?: Retention | null, replication?: ReplicationChange);
     /** Delete the entity once these events are persisted. */
     deleteEntity(): PersistBuilder<S, E>;
     /** Expire the entity a while after these events are persisted. */
     expireAfter(after: Duration): PersistBuilder<S, E>;
+    /**
+     * Persist these events, then hand a replicated entity's home to `installation`, which must be in its
+     * replication set. Recorded once the new home holds everything before it.
+     */
+    handOverTo(installation: string): PersistBuilder<S, E>;
+    /** Persist these events, then add `installation` to a replicated entity's replication set. */
+    replicateTo(installation: string): PersistBuilder<S, E>;
+    /** Persist these events, then take `installation` out of a replicated entity's replication set; it keeps its copy. */
+    stopReplicatingTo(installation: string): PersistBuilder<S, E>;
     /** Reply with a value computed from the state *after* the events. */
     thenReply<R>(compute: (state: S) => R, metadata?: Metadata): PersistEffect<S, E, R>;
     /** Reply with the state after the events. */
@@ -46,5 +65,11 @@ export declare class EventSourcedEffects<S, E> {
     deleteEntity(): PersistBuilder<S, E>;
     /** Expire the entity after a while, persisting nothing more. */
     expireAfter(after: Duration): PersistBuilder<S, E>;
+    /** Hand a replicated entity's home to `installation`, with no event of its own. */
+    handOverTo(installation: string): PersistBuilder<S, E>;
+    /** Add `installation` to a replicated entity's replication set, with no event of its own. */
+    replicateTo(installation: string): PersistBuilder<S, E>;
+    /** Take `installation` out of a replicated entity's replication set; it keeps its copy. */
+    stopReplicatingTo(installation: string): PersistBuilder<S, E>;
 }
 export { done, type Done };

package/dist/effects/eventSourced.js

@@ -1,27 +1,67 @@
 // The effects an event sourced entity's handlers return: persist these events and then reply from the
 // state after them, or answer without persisting. Inert values. `ReadOnlyEffect` is a distinct type
 // with `kind: "read-only"`, which is what lets `query` refuse a persisting handler at compile time.
+var _a;
 import { done } from "../schema.js";
 import { ErrorCode, Outcome, Retention } from "./common.js";
 /** `effects.persist(e)` returns one of these; finish it with `thenReply`, `thenReplyState` or `thenNoReply`. */
 export class PersistBuilder {
     #events;
     #retention;
-    constructor(events, retention = null) {
+    #replication;
+    constructor(events, retention = null, replication) {
         this.#events = events;
         this.#retention = retention;
+        this.#replication = replication;
     }
     /** Delete the entity once these events are persisted. */
     deleteEntity() {
-        return new PersistBuilder(this.#events, Retention.deleteNow);
+        return new _a(this.#events, Retention.deleteNow, this.#replication);
     }
     /** Expire the entity a while after these events are persisted. */
     expireAfter(after) {
-        return new PersistBuilder(this.#events, Retention.expireAfter(after));
+        return new _a(this.#events, Retention.expireAfter(after), this.#replication);
+    }
+    /**
+     * Persist these events, then hand a replicated entity's home to `installation`, which must be in its
+     * replication set. Recorded once the new home holds everything before it.
+     */
+    handOverTo(installation) {
+        if (this.#replication)
+            throw new Error(`a command asks for one handover or one change to the replication set; it asked for ${JSON.stringify(this.#replication)}`);
+        return new _a(this.#events, this.#retention, Object.freeze({ kind: "hand-over", to: installation }));
+    }
+    /** Persist these events, then add `installation` to a replicated entity's replication set. */
+    replicateTo(installation) {
+        return this.#setChange([installation], []);
+    }
+    /** Persist these events, then take `installation` out of a replicated entity's replication set; it keeps its copy. */
+    stopReplicatingTo(installation) {
+        return this.#setChange([], [installation]);
+    }
+    #setChange(add, remove) {
+        const current = this.#replication;
+        if (current?.kind === "hand-over")
+            throw new Error(`a command asks for one handover or one change to the replication set; it asked for ${JSON.stringify(current)}`);
+        const adding = [...new Set([...(current?.add ?? []), ...add])].sort();
+        const removing = [...new Set([...(current?.remove ?? []), ...remove])].sort();
+        const both = adding.filter((name) => removing.includes(name));
+        if (both.length > 0)
+            throw new Error(`a command both adds and removes ${both.join(", ")} in the replication set`);
+        return new _a(this.#events, this.#retention, Object.freeze({ kind: "set", add: Object.freeze(adding), remove: Object.freeze(removing) }));
+    }
+    #effect(outcome) {
+        return Object.freeze({
+            kind: "persist",
+            events: this.#events,
+            retention: this.#retention,
+            outcome,
+            ...(this.#replication ? { replication: this.#replication } : {}),
+        });
     }
     /** Reply with a value computed from the state *after* the events. */
     thenReply(compute, metadata) {
-        return Object.freeze({ kind: "persist", events: this.#events, retention: this.#retention, outcome: Outcome.reply(compute, metadata) });
+        return this.#effect(Outcome.reply(compute, metadata));
     }
     /** Reply with the state after the events. */
     thenReplyState() {
@@ -29,9 +69,10 @@ export class PersistBuilder {
     }
     /** Persist and answer nothing. */
     thenNoReply() {
-        return Object.freeze({ kind: "persist", events: this.#events, retention: this.#retention, outcome: Outcome.noReply() });
+        return this.#effect(Outcome.noReply());
     }
 }
+_a = PersistBuilder;
 /** The factory a handler reaches as `this.effects`. */
 export class EventSourcedEffects {
     /** Persist one or more events. */
@@ -62,5 +103,17 @@ export class EventSourcedEffects {
     expireAfter(after) {
         return new PersistBuilder(Object.freeze([]), Retention.expireAfter(after));
     }
+    /** Hand a replicated entity's home to `installation`, with no event of its own. */
+    handOverTo(installation) {
+        return new PersistBuilder(Object.freeze([])).handOverTo(installation);
+    }
+    /** Add `installation` to a replicated entity's replication set, with no event of its own. */
+    replicateTo(installation) {
+        return new PersistBuilder(Object.freeze([])).replicateTo(installation);
+    }
+    /** Take `installation` out of a replicated entity's replication set; it keeps its copy. */
+    stopReplicatingTo(installation) {
+        return new PersistBuilder(Object.freeze([])).stopReplicatingTo(installation);
+    }
 }
 export { done };

package/dist/endpoint.d.ts

@@ -1,4 +1,6 @@
+import { type ClientKeys } from "./client-keys.ts";
 import { type ComponentClient, type Secrets } from "./client.ts";
+import { type Buckets } from "./storage.ts";
 import { type RequestContext } from "./context.ts";
 import type { Acl, RouteTable } from "./routes.ts";
 import { type Services } from "./services.ts";
@@ -12,10 +14,18 @@ export declare abstract class Endpoint {
     get secrets(): Secrets;
     /** A unit test's store in place of the runtime's: `component.secrets = new InMemorySecrets()`. */
     set secrets(store: Secrets);
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage(): Buckets;
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets: Buckets);
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services(): Services;
     /** A unit test's in place of the runtime's: `component.services = new ScriptedServices()`. */
     set services(services: Services);
+    /** The service's client keys (1.20): issued for its MCP endpoint, kept by the runtime, each shown once. */
+    get clientKeys(): ClientKeys;
+    /** A unit test's in place of the runtime's: `component.clientKeys = new InMemoryClientKeys()`. */
+    set clientKeys(keys: ClientKeys);
     /** @internal */
     _bindClient(client: ComponentClient | undefined): void;
 }

package/dist/endpoint.js

@@ -8,7 +8,9 @@
 //     static readonly routes = { getCart: get("/{cartId}", ShoppingCart, (ep: ShoppingCartEndpoint, req) => ep.getCart(req.params.cartId)) }
 //     getCart(cartId: string) { return this.client.of(ShoppingCartEntity, cartId).call(ShoppingCartEntity.handlers.getCart).invoke() }
 //   }
+import { clientKeysFor } from "./client-keys.js";
 import { secretsFor } from "./client.js";
+import { processStorage } from "./storage.js";
 import { currentRequest, requestIfAny } from "./context.js";
 import { servicesFor } from "./services.js";
 export class Endpoint {
@@ -33,6 +35,15 @@ export class Endpoint {
     set secrets(store) {
         this.#secrets = store;
     }
+    #storage;
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage() {
+        return this.#storage ?? processStorage();
+    }
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets) {
+        this.#storage = buckets;
+    }
     #services;
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services() {
@@ -42,6 +53,15 @@ export class Endpoint {
     set services(services) {
         this.#services = services;
     }
+    #clientKeys;
+    /** The service's client keys (1.20): issued for its MCP endpoint, kept by the runtime, each shown once. */
+    get clientKeys() {
+        return this.#clientKeys ?? clientKeysFor(this.client);
+    }
+    /** A unit test's in place of the runtime's: `component.clientKeys = new InMemoryClientKeys()`. */
+    set clientKeys(keys) {
+        this.#clientKeys = keys;
+    }
     /** @internal */
     _bindClient(client) {
         this.#client = client;

package/dist/eventSourcedEntity.d.ts

@@ -1,5 +1,5 @@
 import type { Shape } from "./codec.ts";
-import type { CommandContext } from "./context.ts";
+import type { CommandContext, EventContext } from "./context.ts";
 import type { HandlerTable } from "./handlers.ts";
 import type { ComponentClient } from "./client.ts";
 import { EventSourcedEffects } from "./effects/eventSourced.ts";
@@ -19,8 +19,11 @@ export declare abstract class EventSourcedEntity<S, E> {
     get _kind(): "event-sourced";
     /** The state of an instance with no events yet. `this.entityId` is available here. */
     abstract emptyState(): S;
-    /** The fold: the state after `event`, given the state before it. Must not read `this.state`. */
-    abstract applyEvent(state: S, event: E): S;
+    /**
+     * The fold: the state after `event`, given the state before it. Must not read `this.state`. The third
+     * argument, which a two-argument fold may leave out, says where the event was written (1.19).
+     */
+    abstract applyEvent(state: S, event: E, context?: EventContext): S;
     /** @internal Bound by the runtime and the testkit before `emptyState`. */
     _bindInstance(entityId: string): void;
     /** @internal Bound by the runtime and the testkit for the duration of one handler call. */
@@ -37,4 +40,6 @@ export interface EventSourcedEntityClass<S = unknown, E = unknown, C extends Eve
     readonly handlers: HandlerTable<C>;
     /** Ask for a snapshot every N events; absent or 0: never. */
     readonly snapshotEvery?: number;
+    /** Held at every installation in its replication set and written only at its home (1.19). */
+    readonly replicated?: boolean;
 }

package/dist/graph.d.ts

@@ -2,7 +2,9 @@ import type { StartFrom } from "./startFrom.ts";
 import { type Codec, type Shape } from "./codec.ts";
 import type { EffectLike, Metadata } from "./effects/common.ts";
 import { type ComponentClient, type ComponentRef, type Secrets } from "./client.ts";
+import { type Buckets } from "./storage.ts";
 import { type Services } from "./services.ts";
+import type { Standing } from "./standing.ts";
 type MaybePromise<T> = T | Promise<T>;
 /** The contract's name: the manifest and the `ce-type` of every delta. */
 export declare const GRAPH_DELTA_SCHEMA = "ankka.graph-delta.v1";
@@ -136,6 +138,8 @@ export declare abstract class GraphConsumer<M> {
     /** The change's metadata: `ce-subject` is the source instance's id, `ankka.sequence` its sequence number. */
     get metadata(): Metadata;
     get subject(): string;
+    /** Of a change from a workflow: where it stood once the effect that recorded the state was applied. `undefined` for a change from an entity or a topic. */
+    get standing(): Standing | undefined;
     /** The change's sequence number, which is the version of every element that states none. */
     get sequenceNumber(): bigint | undefined;
     get client(): ComponentClient;
@@ -143,6 +147,10 @@ export declare abstract class GraphConsumer<M> {
     get secrets(): Secrets;
     /** A unit test's store in place of the runtime's: `component.secrets = new InMemorySecrets()`. */
     set secrets(store: Secrets);
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage(): Buckets;
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets: Buckets);
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services(): Services;
     /** A unit test's in place of the runtime's: `component.services = new ScriptedServices()`. */
@@ -153,7 +161,7 @@ export declare abstract class GraphConsumer<M> {
     /** The source was deleted. Ignored unless this says otherwise; publish tombstones here. */
     onDelete(): MaybePromise<GraphEffect>;
     /** @internal */
-    _bind(metadata: Metadata, client: ComponentClient): void;
+    _bind(metadata: Metadata, client: ComponentClient, standing?: Standing): void;
 }
 export interface GraphConsumerClass<M = unknown, C extends GraphConsumer<M> = GraphConsumer<M>> {
     new (): C;
@@ -167,5 +175,10 @@ export interface GraphConsumerClass<M = unknown, C extends GraphConsumer<M> = Gr
     readonly message: Shape<M>;
     /** The delta topic. It must be compacted to hold the graph; the pipeline that reads it creates it so. */
     readonly producesTo: string;
+    /**
+     * Given a replicated entity's changes written at other installations too (1.19); otherwise each delta
+     * is published once, from the installation that wrote the change.
+     */
+    readonly mirroredChanges?: boolean;
 }
 export {};

package/dist/graph.js

@@ -16,6 +16,7 @@
 //   }
 import { JSON_CONTENT } from "./codec.js";
 import { secretsFor } from "./client.js";
+import { processStorage } from "./storage.js";
 import { sequenceNumberOf } from "./consumer.js";
 import { renderDouble, reviver } from "./json.js";
 import { servicesFor } from "./services.js";
@@ -395,6 +396,7 @@ export class GraphConsumer {
     graph = new Graph();
     effects = new GraphEffects();
     #metadata = {};
+    #standing = undefined;
     #client;
     /** The change's metadata: `ce-subject` is the source instance's id, `ankka.sequence` its sequence number. */
     get metadata() {
@@ -403,6 +405,10 @@ export class GraphConsumer {
     get subject() {
         return this.#metadata["ce-subject"] ?? "";
     }
+    /** Of a change from a workflow: where it stood once the effect that recorded the state was applied. `undefined` for a change from an entity or a topic. */
+    get standing() {
+        return this.#standing;
+    }
     /** The change's sequence number, which is the version of every element that states none. */
     get sequenceNumber() {
         return sequenceNumberOf(this.#metadata);
@@ -421,6 +427,15 @@ export class GraphConsumer {
     set secrets(store) {
         this.#secrets = store;
     }
+    #storage;
+    /** The service's buckets: `this.storage.default`, or `this.storage.bucket("photos")`. */
+    get storage() {
+        return this.#storage ?? processStorage();
+    }
+    /** A unit test's store in place of the runtime's: `component.storage = new InMemoryBuckets()`. */
+    set storage(buckets) {
+        this.#storage = buckets;
+    }
     #services;
     /** Other services, called as this one, through the runtime: `this.services.service("orders")`. */
     get services() {
@@ -439,8 +454,9 @@ export class GraphConsumer {
         return this.effects.ignore();
     }
     /** @internal */
-    _bind(metadata, client) {
+    _bind(metadata, client, standing) {
         this.#metadata = metadata;
+        this.#standing = standing;
         this.#client = client;
     }
 }