worldvm 0.0.0-stage → 0.1.0

package/dist/explain.js

@@ -0,0 +1,225 @@
+import { resolve } from "node:path";
+import { basis, createScenarioRunner, link, proofOf, reconcileSubject, timeOrder, Unknown, workItems, } from "./_internal/reconciler/index.js";
+import { citationView, projectRequirements } from "./manual/projections.js";
+import { loadProject } from "./project.js";
+import { readSnapshot } from "./snapshot.js";
+const plain = (value) => {
+    if (value instanceof Unknown)
+        return { unknown: value.why };
+    if (Array.isArray(value))
+        return value.map(plain);
+    if (value instanceof Map)
+        return Object.fromEntries([...value].map(([k, v]) => [k, plain(v)]));
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, plain(v)]));
+    return value;
+};
+const usage = (code, message, help) => ({
+    code,
+    severity: "error",
+    message,
+    at: null,
+    help,
+    fix: null,
+});
+/** Shapes one reconciliation into located answers: why each status, due date and work item. */
+export const explainReconciliation = (ir, files, recon, subject) => {
+    const views = new Map(projectRequirements(ir, files).map((v) => [v.id, v]));
+    const release = new Map(recon.programs.map((p) => [p.account.name, p.release]));
+    const selected = new Set([...recon.instances.values()]
+        .filter((i) => subject === null || i.attached.includes(subject) || i.id === subject)
+        .map((i) => i.id));
+    const instances = [...recon.results]
+        .filter(([id]) => selected.has(id))
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([id, result]) => {
+        const inst = recon.instances.get(id);
+        return {
+            instance: id,
+            component: inst.component,
+            account: inst.account,
+            attached: [...inst.attached].sort(),
+            wakeAt: result.wakeAt,
+            wakeReason: result.wakeReason,
+            requirements: result.requirements.map((q) => {
+                const view = views.get(`${inst.component}/${q.name}`), definition = ir.components
+                    .find((c) => c.name === inst.component)
+                    ?.requirements.find((r) => r.name === q.name);
+                return {
+                    name: q.name,
+                    label: q.label,
+                    occurrence: q.occurrence,
+                    status: q.status,
+                    due: q.due,
+                    dueUnknown: q.dueUnknown,
+                    dueSteps: q.dueSteps.map((s) => ({
+                        at: s.at,
+                        value: plain(s.value),
+                        branch: s.branch ?? null,
+                        note: s.note ?? null,
+                    })),
+                    remindAt: q.remindAt,
+                    reasons: q.reasons.map((r) => ({
+                        label: r.label,
+                        outcome: r.outcome,
+                        detail: r.detail,
+                        at: r.at ?? null,
+                    })),
+                    evidence: q.evidence
+                        ? {
+                            values: q.evidence.values,
+                            id: q.evidence.id,
+                            type: q.evidence.type,
+                            status: q.evidence.status,
+                            by: q.evidence.by,
+                            at: q.evidence.at,
+                        }
+                        : null,
+                    via: q.via,
+                    awaits: q.awaits,
+                    blocked: result.blocked.find((b) => b.requirement === q.name)?.reason ?? null,
+                    proof: proofOf(release.get(inst.account) ?? "", recon.now, q),
+                    rule: {
+                        at: q.at,
+                        prose: (view?.rows ?? []).map((r) => ({ label: r.label, text: r.description.text })),
+                        cites: (definition?.cites ?? []).map((c) => {
+                            const view = citationView(ir, c);
+                            return { source: c.source, clause: view.clause, title: view.title, at: c.at };
+                        }),
+                    },
+                };
+            }),
+        };
+    });
+    const work = workItems(recon)
+        .filter((w) => w.members.some((m) => selected.has(m.instance)))
+        .map((w) => ({
+        key: w.key,
+        state: w.state,
+        assignee: w.assignee,
+        members: w.members.map((m) => ({
+            instance: m.instance,
+            action: m.action,
+            occurrences: m.occurrences,
+        })),
+        reason: w.reason ?? null,
+    }))
+        .sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+    return { instances, work };
+};
+export const explainDirectory = async (directory, options) => {
+    const project = await loadProject(directory);
+    const base = {
+        format: "worldvm/explain@1",
+        command: "explain",
+        directory: project.directory,
+        subject: options.subject ?? null,
+        requestedAt: options.at ?? null,
+    };
+    const fail = (diagnostics) => ({
+        ...base,
+        ok: false,
+        source: null,
+        now: null,
+        releases: [],
+        instances: [],
+        work: [],
+        diagnostics: [...project.diagnostics, ...diagnostics],
+    });
+    const ir = project.ir;
+    if (!ir || project.diagnostics.some((d) => d.severity === "error"))
+        return fail([]);
+    if ((options.scenario === undefined) === (options.world === undefined))
+        return fail([
+            usage("E_EXPLAIN_SOURCE", "Explain needs exactly one of --scenario or --world.", "Pass --scenario name to explain an authored instant, or --world snapshot.json --subject id --at instant for a live subject."),
+        ]);
+    if (options.scenario !== undefined) {
+        const scenario = ir.scenarios?.find((s) => s.name === options.scenario);
+        if (!scenario)
+            return fail([
+                usage("E_EXPLAIN_SCENARIO", `Unknown scenario ${options.scenario}.`, `Pass one of: ${(ir.scenarios ?? []).map((s) => s.name).join(", ") || "(no scenarios declared)"}.`),
+            ]);
+        const result = createScenarioRunner(ir)(scenario);
+        const steps = result.steps;
+        let index = steps.length - 1;
+        if (options.at !== undefined) {
+            const at = options.at;
+            index = -1;
+            try {
+                steps.forEach((s, i) => {
+                    if (timeOrder(s.date, at) <= 0)
+                        index = i;
+                });
+            }
+            catch (cause) {
+                return fail([
+                    usage("E_EXPLAIN_AT", String(cause), "Pass --at as YYYY-MM-DD or YYYY-MM-DDTHH:MM."),
+                ]);
+            }
+            if (index < 0)
+                return fail([
+                    usage("E_EXPLAIN_AT", `Scenario ${scenario.name} has no step at or before ${at}.`, `Its steps are at ${steps.map((s) => s.date).join(", ") || "(none; the scenario failed to run)"}.`),
+                ]);
+        }
+        const step = steps[index];
+        if (!step)
+            return fail(result.failures.map((f) => ({
+                code: f.code,
+                severity: "error",
+                message: f.message,
+                at: f.at,
+                help: "Run worldvm test --scenario to see why this scenario cannot be replayed.",
+                fix: null,
+            })));
+        const explained = explainReconciliation(ir, project.files, step.reconciliation, options.subject ?? null);
+        return {
+            ...base,
+            ok: true,
+            source: { kind: "scenario", name: scenario.name, step: index },
+            now: step.reconciliation.now,
+            releases: step.reconciliation.releases,
+            ...explained,
+            diagnostics: project.diagnostics,
+        };
+    }
+    const path = resolve(options.world);
+    if (options.subject === undefined || options.at === undefined)
+        return fail([
+            usage("E_EXPLAIN_SUBJECT", "A snapshot explanation needs --subject and --at.", "Name the subject's entity id and the instant to evaluate; the CLI never reads the clock."),
+        ]);
+    const read = await readSnapshot(path, [ir], "E_EXPLAIN_SNAPSHOT");
+    if ("diagnostic" in read)
+        return fail([read.diagnostic]);
+    const snapshot = read.snapshot;
+    // Each account's program evaluates the subject's home; occurrence ids are account-qualified.
+    const parts = [];
+    try {
+        const b = basis(snapshot.world, options.at);
+        for (const account of snapshot.accounts)
+            parts.push(reconcileSubject(link(ir, account), b, options.subject, options.at));
+    }
+    catch (cause) {
+        return fail([
+            usage("E_EXPLAIN_AT", String(cause), "Pass --at as YYYY-MM-DD or YYYY-MM-DDTHH:MM and a snapshot recorded by this world."),
+        ]);
+    }
+    const recon = {
+        ...parts[0],
+        releases: parts.flatMap((p) => p.releases),
+        roots: parts.flatMap((p) => p.roots),
+        instances: new Map(parts.flatMap((p) => [...p.instances])),
+        results: new Map(parts.flatMap((p) => [...p.results])),
+        blockedTotal: parts.reduce((n, p) => n + p.blockedTotal, 0),
+        programs: parts.flatMap((p) => p.programs),
+    };
+    return {
+        ...base,
+        ok: true,
+        source: { kind: "snapshot", path, accounts: snapshot.accounts },
+        now: recon.now,
+        releases: recon.releases,
+        // reconcileSubject already scopes results to the subject's home.
+        ...explainReconciliation(ir, project.files, recon, null),
+        diagnostics: project.diagnostics,
+    };
+};

package/dist/fixes.d.ts

@@ -0,0 +1,4 @@
+import { type Diagnostic, type SourceFile } from "./_internal/forma/world/index.js";
+import type { Fix } from "./project.js";
+/** Mechanical fixes for the authoring diagnostics that have exactly one sensible repair. */
+export declare const authoringFix: (d: Diagnostic, files: readonly SourceFile[]) => Fix | null;

package/dist/fixes.js

@@ -0,0 +1,70 @@
+import { suggestForm } from "./_internal/forma/world/index.js";
+const closers = { "(": ")", "[": "]", "{": "}" };
+/** A minimal reader for one condition: enough to rewrite operator heads, never to evaluate. */
+const read = (text) => {
+    const tokens = text.match(/"(?:\\.|[^"\\])*"|[()[\]{}]|[^\s()[\]{}"]+/g) ?? [];
+    let i = 0;
+    const node = () => {
+        const token = tokens[i++];
+        if (token === undefined || /^[)\]}]$/.test(token))
+            return undefined;
+        if (!closers[token])
+            return token;
+        const items = [];
+        while (tokens[i] !== closers[token]) {
+            if (i >= tokens.length)
+                return undefined;
+            const child = node();
+            if (child === undefined)
+                return undefined;
+            items.push(child);
+        }
+        i++;
+        return { open: token, close: closers[token], items };
+    };
+    const result = node();
+    return i === tokens.length ? result : undefined;
+};
+const print = (n) => typeof n === "string" ? n : `${n.open}${n.items.map(print).join(" ")}${n.close}`;
+const list = (...items) => ({ open: "(", close: ")", items });
+/** Rewrite Bool-only operators to their Truth spellings; the result keeps the author's meaning. */
+const truthy = (n) => {
+    if (typeof n === "string" || n.open !== "(")
+        return n;
+    const [head, ...args] = n.items.map(truthy);
+    if ((head === "=" || head === "!=") && args.length === 2) {
+        const literal = args.findIndex((a) => a === "true" || a === "false");
+        if (literal >= 0 && typeof args[1 - literal] !== "undefined") {
+            const other = args[1 - literal];
+            return (head === "=") === (args[literal] === "true") ? other : list("not", other);
+        }
+    }
+    return head === undefined ? n : { ...n, items: [head, ...args] };
+};
+const located = (d, files) => d.at ? files.find((f) => f.id === d.at.src)?.text.slice(d.at.from, d.at.to) : undefined;
+/** Mechanical fixes for the authoring diagnostics that have exactly one sensible repair. */
+export const authoringFix = (d, files) => {
+    const text = located(d, files);
+    if (!d.at || text === undefined)
+        return null;
+    const { src, from, to } = d.at;
+    if (d.code === "E_ELABORATE_HOLE_TYPE" &&
+        /\bTruth\b/.test(d.message) &&
+        /\bBool\b/.test(d.message)) {
+        const tree = read(text);
+        if (!tree)
+            return null;
+        const rewritten = print(truthy(tree));
+        return rewritten === print(tree) ? null : { src, from, to, text: rewritten, expected: text };
+    }
+    if (d.code === "E_ELABORATE_UNKNOWN_FORM") {
+        const name = /Unknown form '([^']+)'/.exec(d.message)?.[1];
+        const suggestion = name && suggestForm(name);
+        if (!suggestion || !text.startsWith(`(${name}`))
+            return null;
+        return { src, from: from + 1, to: from + 1 + name.length, text: suggestion, expected: name };
+    }
+    if (d.code === "W_ATTESTED_EXPIRING" && text.startsWith("(attested"))
+        return { src, from: from + 1, to: from + 9, text: "valid", expected: "attested" };
+    return null;
+};

package/dist/fmt.d.ts

@@ -0,0 +1,12 @@
+/** Same visible-source traversal policy as loadProject. Explicit files may be hidden. */
+export declare const formaFiles: (input: string) => Promise<string[]>;
+/** Prepare every result before writing anything; malformed source cannot cause partial formatting. */
+export declare const formatPaths: (inputs: readonly string[], check?: boolean) => Promise<{
+    format: string;
+    ok: boolean;
+    files: {
+        path: string;
+        changed: boolean;
+        text: string;
+    }[];
+}>;

package/dist/fmt.js

@@ -0,0 +1,39 @@
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { formatForma } from "./_internal/forma-tools/index.js";
+/** Same visible-source traversal policy as loadProject. Explicit files may be hidden. */
+export const formaFiles = async (input) => {
+    const path = resolve(input);
+    const info = await stat(path);
+    if (info.isFile()) {
+        if (!path.endsWith(".forma"))
+            throw new Error(`Expected a .forma file: ${path}`);
+        return [path];
+    }
+    if (!info.isDirectory())
+        throw new Error(`Expected a file or directory: ${path}`);
+    const entries = await readdir(path, { withFileTypes: true });
+    const nested = await Promise.all(entries
+        .filter((e) => !e.name.startsWith(".") &&
+        !["node_modules", "dist", "build", "coverage"].includes(e.name))
+        .map((e) => e.isDirectory() || (e.isFile() && e.name.endsWith(".forma"))
+        ? formaFiles(resolve(path, e.name))
+        : Promise.resolve([])));
+    return nested.flat().sort();
+};
+/** Prepare every result before writing anything; malformed source cannot cause partial formatting. */
+export const formatPaths = async (inputs, check = false) => {
+    const paths = [...new Set((await Promise.all(inputs.map(formaFiles))).flat())].sort();
+    if (!paths.length)
+        throw new Error("No .forma source files found.");
+    const files = await Promise.all(paths.map(async (path) => {
+        const original = await readFile(path, "utf8");
+        const text = formatForma(original);
+        return { path, changed: text !== original, text };
+    }));
+    if (!check)
+        for (const file of files)
+            if (file.changed)
+                await writeFile(file.path, file.text);
+    return { format: "worldvm/fmt@1", ok: !check || files.every((f) => !f.changed), files };
+};

package/dist/handle/open.d.ts

@@ -0,0 +1,18 @@
+import type { WorldTypes, TypedWorld } from "./types.js";
+import type { SourceFile } from "../_internal/forma/world/index.js";
+import type * as K from "../_internal/reconciler/index.js";
+import { type HostOptions, type World } from "./world.js";
+export interface OpenOptions extends Omit<HostOptions, "ir" | "files"> {
+    /** A directory of .forma sources. Omit source, files and ir to use the store’s deployed release. */
+    readonly source?: string;
+    /** In-memory sources, for hosts without a filesystem. */
+    readonly files?: readonly SourceFile[];
+    /** An already compiled release. */
+    readonly ir?: K.IR.WorldIR;
+}
+/**
+ * Open a world: compile (or accept) a release, attach a store, and return the handle that
+ * records facts, offers work and explains statuses. A source with errors is refused, with
+ * the same diagnostics `worldvm check` prints.
+ */
+export declare function open<T extends WorldTypes = WorldTypes>(options: OpenOptions): Promise<WorldTypes extends T ? World : TypedWorld<T>>;

package/dist/handle/open.js

@@ -0,0 +1,28 @@
+import { compileProject, loadProject } from "../project.js";
+import { host, WorldError } from "./world.js";
+export async function open(options) {
+    const { source, files, ir, ...rest } = options;
+    if ([source, files, ir].every((x) => x === undefined)) {
+        const store = options.store;
+        if (!store || !("deployed" in store) || typeof store.deployed !== "function")
+            throw new WorldError("E_OPEN", "Pass source, files or ir, or a store with a deployed release.");
+        const deployed = await store.deployed();
+        if (!deployed)
+            throw new WorldError("E_OPEN", "No deployed release. Run worldvm deploy first.");
+        if (options.account && options.account !== deployed.account)
+            throw new WorldError("E_ACCOUNT", `The deployed account is ${deployed.account}.`);
+        return host({ ...rest, ir: deployed.ir, account: deployed.account });
+    }
+    if ([source, files, ir].filter((x) => x !== undefined).length !== 1)
+        throw new WorldError("E_OPEN", "Pass exactly one of source, files or ir.");
+    if (ir)
+        return host({ ...rest, ir });
+    const project = source ? await loadProject(source) : compileProject("", files);
+    const errors = project.diagnostics.filter((d) => d.severity === "error");
+    if (!project.ir || errors.length)
+        throw new WorldError("E_CHECK", `The world has ${errors.length} error${errors.length === 1 ? "" : "s"}: ${errors
+            .slice(0, 3)
+            .map((d) => `${d.code} ${d.message}`)
+            .join("; ")}`, errors);
+    return host({ ...rest, ir: project.ir, files: project.files });
+}

package/dist/handle/protocol.d.ts

@@ -0,0 +1,12 @@
+import { type ProtocolError, type Result, type Verb } from "../_internal/protocol/index.js";
+import { type Actor, type World } from "./world.js";
+export declare const failure: (code: ProtocolError["code"], message: string, details?: readonly string[]) => {
+    ok: false;
+    error: {
+        details?: readonly string[];
+        code: "invalid-request" | "unauthenticated" | "human-required" | "forbidden" | "not-found" | "command-duplicate" | "proposal-resolved" | "write-refused" | "internal";
+        message: string;
+    };
+};
+/** Transport-independent execution. The actor comes from the trusted host, never the body. */
+export declare function operate<V extends Verb>(world: World, verb: V, input: unknown, identity: Actor): Promise<Result<V>>;

package/dist/handle/protocol.js

@@ -0,0 +1,96 @@
+import { decodeActor, decodeRequest, errorCodes, mutations, } from "../_internal/protocol/index.js";
+import { WorldError } from "./world.js";
+export const failure = (code, message, details) => ({ ok: false, error: { code, message, ...(details ? { details } : {}) } });
+/** Transport-independent execution. The actor comes from the trusted host, never the body. */
+export async function operate(world, verb, input, identity) {
+    let by;
+    try {
+        by = decodeActor(typeof identity === "string"
+            ? { id: identity, kind: "human" }
+            : { ...identity, kind: identity.kind ?? "human" });
+    }
+    catch {
+        return failure("unauthenticated", "Supply a trusted actor with id and kind.");
+    }
+    let args;
+    try {
+        args = decodeRequest(verb, input);
+    }
+    catch (cause) {
+        return failure("invalid-request", String(cause));
+    }
+    if (by.kind === "agent" && mutations.includes(verb) && verb !== "propose")
+        return failure("human-required", "Agents propose; a human must authorize this write.");
+    try {
+        const run = async () => {
+            if (verb === "subjects")
+                return world.subjects(args.type);
+            if (verb === "changes")
+                return { revision: world.revision(), nextWake: world.nextWake() };
+            if (verb === "proposals") {
+                const a = args;
+                return world
+                    .proposals()
+                    .filter((p) => (!a.type || p.type === a.type) &&
+                    (!a.subject || p.subject === a.subject) &&
+                    (!a.state || p.state === a.state));
+            }
+            const a = args;
+            if (!mutations.includes(verb) && !world.canRead(by, a.type, a.subject))
+                throw new ReadDenied();
+            const subject = world.subject(a.type, a.subject);
+            switch (verb) {
+                case "facts":
+                    return subject.facts(a.at);
+                case "status":
+                    return subject.status(a.at);
+                case "work":
+                    return subject.work(a.at);
+                case "operations":
+                    return subject.operations(a.at);
+                case "explain":
+                    return subject.explain(args.requirement, a.at);
+                case "assert": {
+                    const { values, kind, id } = args;
+                    return subject.assert(values, { by, id, ...(kind ? { kind } : {}) });
+                }
+                case "perform": {
+                    const { operation, type: _t, subject: _s, ...options } = args;
+                    return subject.perform(operation, { ...options, by });
+                }
+                case "signal": {
+                    const { machine, state, id, instance } = args;
+                    return subject.signal(machine, state, { by, id, ...(instance ? { instance } : {}) });
+                }
+                case "propose": {
+                    const { draft, rationale, id } = args;
+                    return subject.propose(draft, rationale, { by, id });
+                }
+                case "accept-proposal": {
+                    const { proposal, id, signature } = args;
+                    return subject.acceptProposal(proposal, { by, id, ...(signature ? { signature } : {}) });
+                }
+                case "reject-proposal": {
+                    const { proposal, reason, id } = args;
+                    return subject.rejectProposal(proposal, reason, { by, id });
+                }
+            }
+        };
+        const value = await run();
+        if (value && typeof value === "object" && "accepted" in value && !value.accepted) {
+            const codes = value.codes;
+            const code = codes.find((c) => errorCodes.includes(c)) ?? "write-refused";
+            return failure(code, codes.join(", "), codes);
+        }
+        return { ok: true, value };
+    }
+    catch (cause) {
+        if (cause instanceof ReadDenied)
+            return failure("forbidden", "Subject read denied.");
+        if (cause instanceof WorldError)
+            return failure("not-found", cause.message, [cause.code]);
+        return failure("internal", "World operation failed.");
+    }
+}
+class ReadDenied extends Error {
+}

package/dist/handle/store.d.ts

@@ -0,0 +1,31 @@
+import type { World as Records } from "../_internal/reconciler/index.js";
+import type { Proposal } from "../_internal/protocol/index.js";
+import type { Outcome } from "./world.js";
+/** The outcome kept for a command id, so a retry returns the first answer. */
+export interface Receipt {
+    readonly digest: string;
+    readonly accepted: boolean;
+    readonly codes: readonly string[];
+    readonly outcome: Outcome;
+}
+/** Everything a host must keep for one account: its records, its release and its receipts. */
+export interface StoreState {
+    /** The release these records were last written under. */
+    readonly release: string;
+    /** Count of committed writes; a reader can tell whether it has seen a change. */
+    readonly revision: number;
+    readonly records: Records;
+    readonly receipts: Readonly<Record<string, Receipt>>;
+    readonly proposals: Readonly<Record<string, Proposal>>;
+}
+/**
+ * A store keeps one account's state. `commit` must be atomic: after a crash, `load` returns
+ * either the state before the commit or the state after it, never a mixture.
+ */
+export interface Store {
+    readonly load: () => StoreState | null | Promise<StoreState | null>;
+    readonly commit: (state: StoreState) => void | Promise<void>;
+    readonly close: () => void | Promise<void>;
+}
+/** Process-lifetime storage for tests and previews. Nothing survives the process. */
+export declare const memory: (initial?: StoreState | null) => Store;

package/dist/handle/store.js

@@ -0,0 +1,11 @@
+/** Process-lifetime storage for tests and previews. Nothing survives the process. */
+export const memory = (initial = null) => {
+    let state = initial;
+    return {
+        load: () => state,
+        commit: (next) => {
+            state = next;
+        },
+        close: () => { },
+    };
+};

package/dist/handle/types.d.ts

@@ -0,0 +1,37 @@
+import type { Outcome, PerformOptions, Subject, WorkItem, World, WriteOptions } from "./world.js";
+/** Structural contract implemented by `worldvm codegen` output. */
+export interface WorldTypes {
+    readonly entities: object;
+    readonly operations: object;
+}
+type Retractions<T> = {
+    readonly [F in keyof T]?: T[F] | null;
+};
+/** A work id carries its operation's input type without changing its string value. */
+export type WorkId<O extends string> = string & {
+    readonly __worldvmOperation: O;
+};
+type TypedWork<T extends WorldTypes> = {
+    [O in keyof T["operations"] & string]: Omit<WorkItem, "id" | "operation" | "kind" | "proposal"> & {
+        readonly id: WorkId<O>;
+        readonly operation: O;
+        readonly kind: Exclude<WorkItem["kind"], "proposal">;
+    };
+}[keyof T["operations"] & string] | (Omit<WorkItem, "kind" | "operation"> & {
+    readonly kind: "proposal";
+    readonly operation: "accept-proposal";
+    readonly proposal: string;
+});
+type Input<T> = Omit<PerformOptions, "values" | "reason"> & T;
+export type TypedSubject<T extends WorldTypes, E extends keyof T["entities"]> = Omit<Subject, "assert" | "perform" | "work"> & {
+    readonly assert: (values: Retractions<T["entities"][E]>, options: WriteOptions & {
+        readonly kind?: string;
+    }) => Promise<Outcome>;
+    readonly perform: <O extends keyof T["operations"] & string>(operation: O | WorkId<O>, options: Input<T["operations"][O]>) => Promise<Outcome>;
+    readonly work: (at?: string) => readonly TypedWork<T>[];
+};
+export type TypedWorld<T extends WorldTypes> = Omit<World, "subject" | "subjects"> & {
+    readonly subject: <E extends keyof T["entities"] & string>(type: E, id: string) => TypedSubject<T, E>;
+    readonly subjects: (type: keyof T["entities"] & string) => readonly string[];
+};
+export {};

package/dist/handle/types.js

@@ -0,0 +1 @@
+export {};