@kestack/kabuki 0.0.0-stage → 0.0.0

package/dist/core/history/replay.js

@@ -0,0 +1,82 @@
+import { Effect } from 'effect';
+import { actorAt, handle, init, isRestore } from '../snapshot/index.js';
+const make = (root, input, { budget = 8, every = 100 } = {}) => {
+    const played = new Map([[null, init(root, input)]]);
+    /** How many entries of `branch` are already played, and the Snapshot after them. */
+    const nearest = (branch) => {
+        const count = branch.findLastIndex((entry) => played.has(entry.id)) + 1;
+        const after = count === 0 ? null : branch[count - 1].id;
+        return { count, snapshot: played.get(after) };
+    };
+    const at = (branch) => {
+        const { count, snapshot } = nearest(branch);
+        return branch.slice(count).reduce((before, entry) => {
+            const after = play(root, before, entry);
+            played.set(entry.id, after);
+            return after;
+        }, snapshot);
+    };
+    const seek = (branch) => Effect.gen(function* () {
+        let { count, snapshot } = nearest(branch);
+        let since = performance.now();
+        for (const entry of branch.slice(count)) {
+            snapshot = play(root, snapshot, entry);
+            if (++count % every === 0 || count === branch.length)
+                played.set(entry.id, snapshot);
+            if (performance.now() - since >= budget) {
+                yield* Effect.yieldNow;
+                since = performance.now();
+            }
+        }
+        return snapshot;
+    });
+    return {
+        at,
+        seek,
+        remember: (entry, snapshot) => void played.set(entry, snapshot),
+    };
+};
+/**
+ * Handle an Envelope from the History: first check its Message against its
+ * Actor's Schema, as a Send does. Throws when either no longer fits, because
+ * the code changed under the History.
+ */
+const replayed = (root, snapshot, envelope) => {
+    const { destination, message } = envelope;
+    if (!isRestore(message))
+        actorAt(root, snapshot, destination)?.check.message(message, `Message ${JSON.stringify(message._tag)}`);
+    return handle(root, snapshot, envelope);
+};
+/**
+ * What came of an Envelope on this Snapshot: worked out by handling it again,
+ * never kept. One that no longer fits the code, which Replay skips, counts as
+ * ignored.
+ */
+export const outcomeOf = (root, snapshot, envelope) => {
+    try {
+        return replayed(root, snapshot, envelope).outcome;
+    }
+    catch {
+        return 'ignored';
+    }
+};
+/** The Snapshot right after one entry, from the one before it. */
+const play = (root, snapshot, entry) => {
+    try {
+        return replayed(root, snapshot, entry).snapshot;
+    }
+    catch (error) {
+        diverged(entry, error);
+        return snapshot;
+    }
+};
+/** The Snapshot right after a whole Branch, played now from init with the root's Input. */
+const fold = (root, branch, input) => branch.reduce((snapshot, entry) => play(root, snapshot, entry), init(root, input));
+export const Replay = { make, fold };
+const warned = new WeakSet();
+const diverged = (entry, error) => {
+    if (warned.has(entry))
+        return;
+    warned.add(entry);
+    console.warn(`[@kestack/kabuki] Replay diverged at entry ${entry.id}, ${entry.message._tag} for ${entry.destination}, and skips it: ${error.message}`);
+};

package/dist/core/history/saved.d.ts

@@ -0,0 +1,7 @@
+import type { ActorDefinition } from '../actor/index.ts';
+import type { Entry, SavedHistory } from './history.ts';
+export declare const encodeEntry: (root: ActorDefinition, entry: Entry) => Entry;
+export declare const decodeEntry: (root: ActorDefinition, entry: Entry) => Entry;
+/** Throws, saying what is wrong, unless `saved` is a History's shape: entries by position, each after an earlier one, and a Head among them. */
+export declare const checkSaved: (saved: SavedHistory) => void;
+//# sourceMappingURL=saved.d.ts.map

package/dist/core/history/saved.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saved.d.ts","sourceRoot":"","sources":["../../../src/core/history/saved.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,mBAAmB,CAAC;AAG3E,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAexD,eAAO,MAAM,WAAW,SAAU,eAAe,SAAS,KAAK,KAAG,KAqBjE,CAAC;AAGF,eAAO,MAAM,WAAW,SAAU,eAAe,SAAS,KAAK,KAAG,KAmBjE,CAAC;AAwDF,gJAAgJ;AAChJ,eAAO,MAAM,UAAU,UAAW,YAAY,KAAG,IAsBhD,CAAC"}

package/dist/core/history/saved.js

@@ -0,0 +1,126 @@
+import { isMany, isRestore, restore } from '../snapshot/index.js';
+/*
+ * Saved: a History as plain JSON. In memory every value is decoded; saved,
+ * each Message, and each Instance of a Restore's Snapshot, is its Actor's
+ * Schemas' encoded side. So only that side must be JSON-safe.
+ *
+ * 1. Encode  an entry, through the Schemas of the Actor it is for. One that
+ *            does not fit is saved as it is: it never plays.
+ * 2. Decode  an entry read back. One that no longer fits the code is kept
+ *            as it was saved: Replay warns of it and skips it.
+ * 3. Check   a saved History's shape before it is read.
+ */
+// 1. Encode
+export const encodeEntry = (root, entry) => {
+    const { message } = entry;
+    // A value that does not fit its Schema is saved as it is: it was dropped
+    // live, or Replay skips it, so it never plays.
+    if (isRestore(message))
+        try {
+            return {
+                ...entry,
+                message: restore(convert(root, message.snapshot, 'encode')),
+            };
+        }
+        catch {
+            return entry;
+        }
+    for (const definition of actorsAt(root, entry.destination))
+        try {
+            return {
+                ...entry,
+                message: definition.encoding.message.encode(message),
+            };
+        }
+        catch { }
+    return entry;
+};
+// 2. Decode
+export const decodeEntry = (root, entry) => {
+    const { message } = entry;
+    try {
+        if (isRestore(message))
+            return {
+                ...entry,
+                message: restore(convert(root, message.snapshot, 'decode')),
+            };
+    }
+    catch {
+        return entry;
+    }
+    for (const definition of actorsAt(root, entry.destination))
+        try {
+            return {
+                ...entry,
+                message: definition.encoding.message.decode(message),
+            };
+        }
+        catch { }
+    return entry;
+};
+/** An Instance and every Child under it, each through its own Actor's Schemas. */
+const convert = (definition, instance, way) => {
+    const { model, state, props } = definition.encoding;
+    const next = state[way](instance.state);
+    const slots = definition.children[next._tag] ?? {};
+    const child = (slot, held) => {
+        const wanted = slots[slot];
+        if (!wanted)
+            throw new Error(`no Child "${slot}" in ${next._tag}`);
+        return convert(wanted.definition, held, way);
+    };
+    return {
+        ...instance,
+        state: next,
+        model: model[way](instance.model),
+        ...('props' in instance ? { props: props[way](instance.props) } : {}),
+        children: Object.fromEntries(Object.entries(instance.children).map(([slot, held]) => [
+            slot,
+            isMany(held) ? held.map((one) => child(slot, one)) : child(slot, held),
+        ])),
+    };
+};
+/**
+ * Every Actor an Instance with this ID can be, read from the ID alone: the
+ * Actor of the slot at each step down, in any State. Usually one; a slot
+ * name written in two States for two Actors gives both.
+ */
+const actorsAt = (root, id) => {
+    const [first, ...steps] = id.split('/');
+    if (first !== root.name)
+        return [];
+    let at = [root];
+    for (const step of steps) {
+        const slot = step.slice(0, step.search(/[[#]/));
+        const next = new Set();
+        for (const definition of at)
+            for (const slots of Object.values(definition.children)) {
+                const found = slots?.[slot]?.definition;
+                if (found)
+                    next.add(found);
+            }
+        at = [...next];
+    }
+    return at;
+};
+// 3. Check
+/** Throws, saying what is wrong, unless `saved` is a History's shape: entries by position, each after an earlier one, and a Head among them. */
+export const checkSaved = (saved) => {
+    const fail = (why) => {
+        throw new TypeError(`[@kestack/kabuki] the saved History is corrupt: ${why}`);
+    };
+    if (!saved || !Array.isArray(saved.entries))
+        fail('it has no entries');
+    saved.entries.forEach((entry, index) => {
+        if (entry?.id !== index)
+            fail(`entry ${index} has the id ${entry?.id}`);
+        const { parent } = entry;
+        if (parent !== null &&
+            !(Number.isInteger(parent) && parent >= 0 && parent < index))
+            fail(`entry ${index} follows ${parent}, not an entry before it`);
+    });
+    const { head } = saved;
+    if (head !== null &&
+        !(Number.isInteger(head) && head >= 0 && head < saved.entries.length))
+        fail(`its Head ${head} is not one of its ${saved.entries.length} entries`);
+};

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+export { Actor, Command } from './actor/index.ts';
+export type { ActorOf, AnyActor, Data, Defined, ActorDefinition, Many, Only, Self, Tagged, Types, Worker, WorkerDefinition, Workers, } from './actor/index.ts';
+export { RESTORE, handle, init, instanceAt, isMany, isRestore, restore, } from './snapshot/index.ts';
+export type { Envelope, Handled, Instance, Restore, Snapshot, Source, } from './snapshot/index.ts';
+export { History, Replay, outcomeOf } from './history/index.ts';
+export type { Entry, HistoryOptions, ReplayOptions, SavedHistory, } from './history/index.ts';
+export { Runtime } from './runtime/index.ts';
+export type { Needs, Running, WorkerStatus } from './runtime/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EACV,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,eAAe,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,KAAK,EACL,MAAM,EACN,gBAAgB,EAChB,OAAO,GACR,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,OAAO,EACP,MAAM,EACN,IAAI,EACJ,UAAU,EACV,MAAM,EACN,SAAS,EACT,OAAO,GACR,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,MAAM,GACP,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAChE,YAAY,EACV,KAAK,EACL,cAAc,EACd,aAAa,EACb,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,4 @@
+export { Actor, Command } from './actor/index.js';
+export { RESTORE, handle, init, instanceAt, isMany, isRestore, restore, } from './snapshot/index.js';
+export { History, Replay, outcomeOf } from './history/index.js';
+export { Runtime } from './runtime/index.js';

package/dist/core/runtime/index.d.ts

@@ -0,0 +1,4 @@
+export { Runtime } from './runtime.ts';
+export type { Needs, Running } from './runtime.ts';
+export type { WorkerStatus } from './instance/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/runtime/index.js

@@ -0,0 +1 @@
+export { Runtime } from './runtime.js';

package/dist/core/runtime/instance/command.d.ts

@@ -0,0 +1,4 @@
+import type { Scope } from 'effect';
+import type { Own } from './self.ts';
+export declare const runCommands: (commands: ReadonlyArray<unknown>, own: Own, scope: Scope.Scope) => void;
+//# sourceMappingURL=command.d.ts.map

package/dist/core/runtime/instance/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../src/core/runtime/instance/command.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAGpC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAUrC,eAAO,MAAM,WAAW,aACZ,aAAa,CAAC,OAAO,CAAC,OAC3B,GAAG,SACD,KAAK,CAAC,KAAK,SAanB,CAAC"}

package/dist/core/runtime/instance/command.js

@@ -0,0 +1,12 @@
+import { Effect, Schema } from 'effect';
+import { RUN } from '../../actor/index.js';
+/*
+ * Commands: errands an Update asked for. Each runs once, in its Instance's
+ * Scope, and Sends the Message it ends with. Nothing stops one but its
+ * Instance stopping.
+ */
+const isMessage = Schema.is(Schema.Struct({ _tag: Schema.String }));
+export const runCommands = (commands, own, scope) => {
+    for (const { name, [RUN]: run } of commands)
+        own.fork(scope, `command ${name}`, { kind: 'command', instance: own.self.id, name }, Effect.flatMap(run, (result) => isMessage(result) ? own.self.send(result) : Effect.void));
+};

package/dist/core/runtime/instance/index.d.ts

@@ -0,0 +1,4 @@
+export { ActorInstance } from './instance.ts';
+export type { Host } from './self.ts';
+export type { WorkerStatus } from './worker.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/runtime/instance/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/runtime/instance/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,YAAY,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/core/runtime/instance/index.js

@@ -0,0 +1 @@
+export { ActorInstance } from './instance.js';

package/dist/core/runtime/instance/instance.d.ts

@@ -0,0 +1,16 @@
+import { Effect, Scope } from 'effect';
+import type { ActorDefinition } from '../../actor/index.ts';
+import type { Envelope, Handled, Snapshot } from '../../snapshot/index.ts';
+import type { Host } from './self.ts';
+import type { WorkerStatus } from './worker.ts';
+export interface ActorInstance {
+    readonly receive: (envelope: Envelope) => Handled;
+    readonly workers: (instance: string) => ReadonlyArray<WorkerStatus>;
+    readonly stop: () => Effect.Effect<void>;
+}
+declare const start: (definition: ActorDefinition, snapshot: Snapshot, host: Host, scope: Scope.Scope) => ActorInstance;
+export declare const ActorInstance: {
+    start: typeof start;
+};
+export {};
+//# sourceMappingURL=instance.d.ts.map

package/dist/core/runtime/instance/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../../../src/core/runtime/instance/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,MAAM,EAAe,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,sBAAsB,CAAC;AAE5E,OAAO,KAAK,EACV,QAAQ,EACR,OAAO,EAEP,QAAQ,EACT,MAAM,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EAAE,IAAI,EAAiB,MAAM,WAAW,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiBhD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,aAAa,CAAC,YAAY,CAAC,CAAC;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAC1C;AAoBD,QAAA,MAAM,KAAK,eACG,eAAe,YACjB,QAAQ,QACZ,IAAI,SACH,KAAK,CAAC,KAAK,KACjB,aAmJF,CAAC;AAcF,eAAO,MAAM,aAAa;;CAAY,CAAC"}

package/dist/core/runtime/instance/instance.js

@@ -0,0 +1,113 @@
+import { Context, Deferred, Effect, Exit, Layer, Scope } from 'effect';
+import { handle, isMany, within } from '../../snapshot/index.js';
+import { runCommands } from './command.js';
+import { dataOf, forkIn, makeOwn } from './self.js';
+import { makeWorkers } from './worker.js';
+/** What an Instance's own code reads; a change to any of it reaches its Self and its Workers. */
+const DATA = ['model', 'state', 'props'];
+const start = (definition, snapshot, host, scope) => {
+    // 1. Start
+    const live = (definition, instance, parent) => {
+        const own = makeOwn(instance, host, parent.services);
+        const inside = open(parent, definition.provides, own);
+        const workers = makeWorkers(definition.workers, own, inside.scope);
+        workers.sync(dataOf(instance));
+        const top = children(slotsAt(definition, instance, 'top'), instance, inside);
+        /** A State lasts while the Instance is in it: a Scope inside the Instance's, what it Provides, and its Children. */
+        const enter = (instance) => {
+            const place = open(inside, definition.stateProvides[instance.state._tag], own);
+            return {
+                children: children(slotsAt(definition, instance, 'state'), instance, place),
+                stop: () => Effect.runFork(Scope.close(place.scope, Exit.void)),
+            };
+        };
+        let state = enter(instance);
+        let current = instance;
+        // 3. Follow
+        const follow = (next) => {
+            if (next === current)
+                return;
+            const before = current;
+            current = next;
+            const entered = before.state._tag !== next.state._tag;
+            if (entered)
+                state.stop();
+            if (DATA.some((field) => before[field] !== next[field])) {
+                own.set(next);
+                workers.sync(dataOf(next));
+            }
+            if (entered)
+                state = enter(next);
+            else
+                state.children.follow(next);
+            top.follow(next);
+        };
+        const living = {
+            follow,
+            find: (id) => id === instance.id ? living : (top.find(id) ?? state.children.find(id)),
+            command: (commands) => runCommands(commands, own, inside.scope),
+            workers: workers.statuses,
+            // 4. Stop
+            stop: () => Scope.close(inside.scope, Exit.void),
+        };
+        return living;
+    };
+    /** A Scope inside `outer`, and the Capabilities below it: the ones from above, with what is Provided there built over them. */
+    const open = (outer, provide, own) => {
+        const scope = Scope.forkUnsafe(outer.scope);
+        if (!provide)
+            return { scope, services: outer.services };
+        const services = Deferred.makeUnsafe();
+        forkIn(host, scope, `${own.self.id} provides`, Deferred.await(outer.services).pipe(Effect.flatMap((above) => Layer.buildWithScope(provide(own.self), scope).pipe(Effect.provideContext(above), Effect.map((built) => Context.merge(above, built)))), Effect.flatMap((below) => Deferred.succeed(services, below))));
+        return { scope, services };
+    };
+    /** The Children held in some slots, alive in one Place: they start, follow and stop as the slots change. */
+    const children = (slots, instance, place) => {
+        const alive = new Map();
+        const held = (parent) => Object.keys(slots).flatMap((slot) => {
+            const kids = parent.children[slot];
+            const all = !kids ? [] : isMany(kids) ? kids : [kids];
+            return all.map((kid) => ({ kid, definition: slots[slot].definition }));
+        });
+        const add = ({ kid, definition }) => alive.set(kid.id, live(definition, kid, place));
+        held(instance).forEach(add);
+        return {
+            follow: (parent) => {
+                const next = held(parent);
+                const kept = new Set(next.map(({ kid }) => kid.id));
+                for (const [id, gone] of alive)
+                    if (!kept.has(id)) {
+                        alive.delete(id);
+                        Effect.runFork(gone.stop());
+                    }
+                for (const each of next) {
+                    const known = alive.get(each.kid.id);
+                    if (known)
+                        known.follow(each.kid);
+                    else
+                        add(each);
+                }
+            },
+            find: (id) => [...alive].find(([kid]) => within(kid, id))?.[1].find(id),
+        };
+    };
+    const services = Deferred.makeUnsafe();
+    Deferred.doneUnsafe(services, Effect.succeed(host.services));
+    const root = live(definition, snapshot, { scope, services });
+    let current = snapshot;
+    return {
+        // 2. Receive
+        receive: (envelope) => {
+            const handled = handle(definition, current, envelope);
+            current = handled.snapshot;
+            root.follow(current);
+            root.find(envelope.destination)?.command(handled.commands);
+            return handled;
+        },
+        workers: (id) => root.find(id)?.workers() ?? [],
+        stop: root.stop,
+    };
+};
+/** The slots of an Instance's current State written at its top, or in the State itself. */
+const slotsAt = (definition, instance, where) => Object.fromEntries(Object.entries(definition.children[instance.state._tag] ?? {}).filter(([slot]) => definition.lasting.includes(slot) === (where === 'top')));
+export const ActorInstance = { start };

package/dist/core/runtime/instance/self.d.ts

@@ -0,0 +1,35 @@
+import { Cause, Context, Deferred, Effect, Scope } from 'effect';
+import type { Data, Self, Tagged } from '../../actor/index.ts';
+import type { Instance, Source } from '../../snapshot/index.ts';
+/** What the Runtime gives the Instances it runs. */
+export interface Host {
+    /** Hand a Message to any Instance, through the one Mailbox. */
+    readonly send: (instance: string, message: Tagged, source: Source) => void;
+    /** The app's Time. */
+    readonly now: () => number;
+    /** The Capabilities of the app's Layer. */
+    readonly services: Context.Context<never>;
+}
+/** Capabilities that may still be building: the ones from above, or the ones handed below. */
+export type Services = Deferred.Deferred<Context.Context<never>>;
+export type AnySelf = Self<unknown, Tagged, Tagged, unknown>;
+/**
+ * An Instance's own code: its Self, always reading its current data, and a
+ * way to run its Workers, Commands and Provides as that Instance, once the
+ * Capabilities from above are built.
+ */
+export declare const makeOwn: (instance: Instance, host: Host, above: Services) => {
+    self: AnySelf;
+    set: (next: Instance) => void;
+    fork: (scope: Scope.Scope, label: string, source: Source, effect: Effect.Effect<unknown, never, any>) => import("effect/Fiber").Fiber<unknown, never>;
+};
+export type Own = ReturnType<typeof makeOwn>;
+/** Run an Effect in a Scope, reporting any failure but being stopped. */
+export declare const forkIn: (host: Host, scope: Scope.Scope, label: string, effect: Effect.Effect<unknown>) => import("effect/Fiber").Fiber<unknown, never>;
+/**
+ * Being stopped. In effect 4.0.0 an interrupted Stream of a SubscriptionRef's
+ * changes ends in `Done` instead of an interrupt.
+ */
+export declare const stopped: (cause: Cause.Cause<unknown>) => boolean;
+export declare const dataOf: ({ model, state, props, }: Instance) => Data<unknown, Tagged, unknown>;
+//# sourceMappingURL=self.d.ts.map

package/dist/core/runtime/instance/self.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self.d.ts","sourceRoot":"","sources":["../../../../src/core/runtime/instance/self.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,OAAO,EACP,QAAQ,EACR,MAAM,EAGN,KAAK,EAEN,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEhE,oDAAoD;AACpD,MAAM,WAAW,IAAI;IACnB,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3E,sBAAsB;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;CAC3C;AAED,8FAA8F;AAC9F,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AAEjE,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAU7D;;;;GAIG;AACH,eAAO,MAAM,OAAO,aAAc,QAAQ,QAAQ,IAAI,SAAS,QAAQ;;gBA4CvD,QAAQ;kBApBb,KAAK,CAAC,KAAK,SACX,MAAM,UACL,MAAM,UACN,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC;CAuB7C,CAAC;AAEF,MAAM,MAAM,GAAG,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;AAE7C,yEAAyE;AACzE,eAAO,MAAM,MAAM,SACX,IAAI,SACH,KAAK,CAAC,KAAK,SACX,MAAM,UACL,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,iDAU/B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,UAAW,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,YACQ,CAAC;AAE5D,eAAO,MAAM,MAAM,6BAIhB,QAAQ,KAAG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAA8B,CAAC"}

package/dist/core/runtime/instance/self.js

@@ -0,0 +1,42 @@
+import { Cause, Context, Deferred, Effect, Exit, Pull, Scope, SubscriptionRef, } from 'effect';
+/** The work running now, which `self.send` stamps as the Message's Source. */
+const Sending = Context.Reference('@kestack/kabuki/Sending', {
+    defaultValue: () => undefined,
+});
+/**
+ * An Instance's own code: its Self, always reading its current data, and a
+ * way to run its Workers, Commands and Provides as that Instance, once the
+ * Capabilities from above are built.
+ */
+export const makeOwn = (instance, host, above) => {
+    const data = Effect.runSyncWith(host.services)(SubscriptionRef.make(dataOf(instance)));
+    const self = {
+        id: instance.id,
+        // Outside any Worker or Command, what the Instance Provides Sent it.
+        send: (message) => Effect.flatMap(Effect.service(Sending), (source) => Effect.sync(() => host.send(instance.id, message, source ?? { kind: 'provide', instance: instance.id }))),
+        get: SubscriptionRef.get(data),
+        changes: SubscriptionRef.changes(data),
+        now: Effect.sync(host.now),
+    };
+    const fork = (scope, label, source, effect) => forkIn(host, scope, `${instance.id} ${label}`, Effect.flatMap(Deferred.await(above), (services) => effect.pipe(Effect.provideService(Sending, source), Effect.provideService(Scope.Scope, scope), Effect.provideContext(services))));
+    return {
+        self,
+        set: (next) => Effect.runSyncWith(host.services)(SubscriptionRef.set(data, dataOf(next))),
+        fork,
+    };
+};
+/** Run an Effect in a Scope, reporting any failure but being stopped. */
+export const forkIn = (host, scope, label, effect) => {
+    const fiber = Effect.runSyncWith(host.services)(Effect.forkIn(effect, scope));
+    fiber.addObserver((exit) => {
+        if (Exit.isFailure(exit) && !stopped(exit.cause))
+            console.error(`[@kestack/kabuki] ${label} failed:\n${Cause.pretty(exit.cause)}`);
+    });
+    return fiber;
+};
+/**
+ * Being stopped. In effect 4.0.0 an interrupted Stream of a SubscriptionRef's
+ * changes ends in `Done` instead of an interrupt.
+ */
+export const stopped = (cause) => Cause.hasInterruptsOnly(cause) || Pull.isDoneCause(cause);
+export const dataOf = ({ model, state, props, }) => ({ model, state, props });

package/dist/core/runtime/instance/worker.d.ts

@@ -0,0 +1,16 @@
+import type { Scope } from 'effect';
+import type { Data, Tagged, WorkerDefinition } from '../../actor/index.ts';
+import type { Own } from './self.ts';
+/** What a Worker is doing, live. */
+export interface WorkerStatus {
+    readonly name: string;
+    /** The key it runs for; `''` for the one Worker of a kind other than `each`. */
+    readonly key: string;
+    readonly status: 'running' | 'finished' | 'failed';
+}
+export declare const makeWorkers: (definitions: Readonly<Record<string, WorkerDefinition>>, own: Own, scope: Scope.Scope) => {
+    /** Start the Workers whose keys appeared, and stop those whose keys went. */
+    sync: (data: Data<unknown, Tagged, unknown>) => void;
+    statuses: () => ReadonlyArray<WorkerStatus>;
+};
+//# sourceMappingURL=worker.d.ts.map

package/dist/core/runtime/instance/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../../src/core/runtime/instance/worker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,KAAK,EAAW,GAAG,EAAE,MAAM,WAAW,CAAC;AAS9C,oCAAoC;AACpC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;CACpD;AAOD,eAAO,MAAM,WAAW,gBACT,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,OAClD,GAAG,SACD,KAAK,CAAC,KAAK;IAsDhB,6EAA6E;IAC7E,IAAI,SAAS,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC;IAa3C,QAAQ,QAAM,aAAa,CAAC,YAAY,CAAC;CAK5C,CAAC"}

package/dist/core/runtime/instance/worker.js

@@ -0,0 +1,52 @@
+import { Effect, Exit } from 'effect';
+import { stopped } from './self.js';
+export const makeWorkers = (definitions, own, scope) => {
+    const running = new Map(Object.keys(definitions).map((name) => [name, new Map()]));
+    const start = (name, worker, key) => {
+        const label = key === '' ? name : `${name}#${key}`;
+        let closing = false;
+        let status = 'running';
+        const self = {
+            ...own.self,
+            send: (message) => Effect.suspend(() => closing
+                ? Effect.die(new Error(`[@kestack/kabuki] Worker ${label} of ${own.self.id} sent a Message after it stopped. Finalizers may not send.`))
+                : own.self.send(message)),
+        };
+        const ended = (exit) => Effect.sync(() => {
+            closing = true;
+            status =
+                Exit.isFailure(exit) && !stopped(exit.cause) ? 'failed' : 'finished';
+        });
+        const fiber = own.fork(scope, `worker ${label}`, {
+            kind: 'worker',
+            instance: own.self.id,
+            name,
+            ...(key === '' ? {} : { key }),
+        }, Effect.scoped(worker.run(self, key).pipe(Effect.onExit(ended))));
+        return {
+            status: () => status,
+            stop: () => {
+                closing = true;
+                fiber.interruptUnsafe();
+            },
+        };
+    };
+    return {
+        /** Start the Workers whose keys appeared, and stop those whose keys went. */
+        sync: (data) => {
+            for (const [name, worker] of Object.entries(definitions)) {
+                const wanted = new Set(worker.keys(data));
+                const live = running.get(name);
+                for (const [key, each] of live)
+                    if (!wanted.has(key)) {
+                        each.stop();
+                        live.delete(key);
+                    }
+                for (const key of wanted)
+                    if (!live.has(key))
+                        live.set(key, start(name, worker, key));
+            }
+        },
+        statuses: () => [...running].flatMap(([name, live]) => [...live].map(([key, each]) => ({ name, key, status: each.status() }))),
+    };
+};

package/dist/core/runtime/mailbox.d.ts

@@ -0,0 +1,10 @@
+import type { Tagged } from '../actor/index.ts';
+import type { Envelope, Source } from '../snapshot/index.ts';
+export declare const makeMailbox: (now: () => number, deliver: (envelope: Envelope) => void, drained: () => void) => {
+    open: () => void;
+    close: () => void;
+    send: (destination: string, message: Tagged, source: Source) => void;
+    /** Run `f` without handling Messages, then handle what it sent. */
+    hold: (f: () => void) => void;
+};
+//# sourceMappingURL=mailbox.d.ts.map

package/dist/core/runtime/mailbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailbox.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/mailbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAY7D,eAAO,MAAM,WAAW,QACjB,MAAM,MAAM,WACR,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,WAC5B,MAAM,IAAI;IAyBjB,IAAI;IAGJ,KAAK;IAIL,IAAI,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM;IAK3D,mEAAmE;IACnE,IAAI,MAAM,MAAM,IAAI;CAWvB,CAAC"}