@kubun/engine 0.10.3 → 0.12.0

package/lib/errors.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Thrown at the end of a `mutateGraph` transaction callback to force the whole
+ * transaction to roll back when any write resolver failed, while carrying the
+ * graphql execution result so the caller still receives the `errors` payload.
+ *
+ * graphql-js swallows a resolver throw into `result.errors` and resolves the
+ * execution promise, so a multi-field mutation whose first field applied and
+ * whose second field threw would otherwise commit a partial write. Throwing
+ * this sentinel out of the transaction callback makes the apply all-or-nothing
+ * (matching the RPC batch path) without throwing to the app.
+ */
+export declare class MutateGraphWriteRollback extends Error {
+    #private;
+    constructor(result: unknown);
+    get result(): unknown;
+}
+/**
+ * Marker a plugin mutation resolver throws to force its whole `mutateGraph`
+ * transaction to roll back. graphql-js swallows a resolver throw into
+ * `result.errors`, so a plugin op that performs several writes (e.g. an MLS
+ * ratchet advance followed by a roster write) could otherwise commit a partial
+ * result when a later step fails. A resolver that wraps such an op rethrows this
+ * marker on any internal failure; `mutateGraph` scans the execution errors for
+ * it and rolls back, matching the core-model write-failure path.
+ */
+export declare class TransactionFatalError extends Error {
+    #private;
+    constructor(message: string, options?: {
+        cause?: unknown;
+        extensions?: Record<string, unknown>;
+    });
+    get extensions(): Record<string, unknown> | undefined;
+}
+/** Whether `err` is a {@link TransactionFatalError} marker. */
+export declare function isTransactionFatal(err: unknown): boolean;

package/lib/errors.js

@@ -0,0 +1,52 @@
+/**
+ * Thrown at the end of a `mutateGraph` transaction callback to force the whole
+ * transaction to roll back when any write resolver failed, while carrying the
+ * graphql execution result so the caller still receives the `errors` payload.
+ *
+ * graphql-js swallows a resolver throw into `result.errors` and resolves the
+ * execution promise, so a multi-field mutation whose first field applied and
+ * whose second field threw would otherwise commit a partial write. Throwing
+ * this sentinel out of the transaction callback makes the apply all-or-nothing
+ * (matching the RPC batch path) without throwing to the app.
+ */ export class MutateGraphWriteRollback extends Error {
+    #result;
+    constructor(result){
+        super('mutateGraph write resolver failed');
+        this.name = 'MutateGraphWriteRollback';
+        this.#result = result;
+    }
+    get result() {
+        return this.#result;
+    }
+}
+/**
+ * Marker a plugin mutation resolver throws to force its whole `mutateGraph`
+ * transaction to roll back. graphql-js swallows a resolver throw into
+ * `result.errors`, so a plugin op that performs several writes (e.g. an MLS
+ * ratchet advance followed by a roster write) could otherwise commit a partial
+ * result when a later step fails. A resolver that wraps such an op rethrows this
+ * marker on any internal failure; `mutateGraph` scans the execution errors for
+ * it and rolls back, matching the core-model write-failure path.
+ */ export class TransactionFatalError extends Error {
+    /**
+   * Extensions to carry onto the `GraphQLError` graphql-js wraps this throw in.
+   *
+   * `locatedError` copies `originalError.extensions` when it builds that
+   * wrapper, so this is what lets a TYPED refusal — an access code an app
+   * matches on — survive a rollback. Without it, every refusal raised inside a
+   * wrapped body reaches the client as a bare message, and the only way to keep
+   * a code was to run the check before the `try`, which a check that must read
+   * the state it is refusing cannot do.
+   */ #extensions;
+    constructor(message, options){
+        super(message, options);
+        this.name = 'TransactionFatalError';
+        this.#extensions = options?.extensions;
+    }
+    get extensions() {
+        return this.#extensions;
+    }
+}
+/** Whether `err` is a {@link TransactionFatalError} marker. */ export function isTransactionFatal(err) {
+    return err instanceof TransactionFatalError;
+}

package/lib/events.d.ts

@@ -1,12 +1,12 @@
-import { type UnsubscribeFunction } from '@enkaku/event';
 import type { Logger } from '@kubun/logger';
+import { type UnsubscribeFunction } from '@sozai/event';
 /**
  * Map of event names to their data types.
  * Uses `Record<string, unknown>` so any namespaced string key is valid.
  */
 type EventMap = Record<string, unknown>;
 /**
- * Transaction-aware event bus built on top of `@enkaku/event`.
+ * Transaction-aware event bus built on top of `@sozai/event`.
  *
  * Events emitted outside a transaction fire immediately.
  * Events emitted inside a transaction are buffered until commit,
@@ -42,7 +42,7 @@ export declare class EngineEventBus<TEvents extends EventMap = EventMap> {
      * in the order they were emitted.
      *
      * Listener errors do not prevent remaining buffered events from firing.
-     * Since `@enkaku/event` uses `Promise.allSettled` internally, all listeners
+     * Since `@sozai/event` uses `Promise.allSettled` internally, all listeners
      * for a given event run even if some throw. Errors from individual event
      * emissions are caught so the full buffer is always drained.
      */

package/lib/events.js

@@ -1 +1,85 @@
-import{EventEmitter as t}from"@enkaku/event";export class EngineEventBus{#t;#r;#n;constructor(r){this.#t=new t,this.#r=r?.logger,this.#n=new Map}on(t,r){return this.#t.on(t,r)}async emit(t,r){await this.#t.emit(t,r)}beginTransaction(t){if(this.#n.has(t))throw Error(`Transaction already exists: ${t}`);this.#n.set(t,[])}emitBuffered(t,r,n){let e=this.#n.get(t);if(null==e)throw Error(`Transaction not found: ${t}`);e.push({name:r,data:n})}async commit(t){let r=this.#n.get(t);if(null==r)throw Error(`Transaction not found: ${t}`);for(let n of(this.#n.delete(t),r))try{await this.#t.emit(n.name,n.data)}catch(t){this.#r?.warn("event listener error during commit for {event}: {error}",{event:n.name,error:String(t)})}}rollback(t){if(!this.#n.has(t))throw Error(`Transaction not found: ${t}`);this.#n.delete(t)}}
+import { EventEmitter } from '@sozai/event';
+/**
+ * Transaction-aware event bus built on top of `@sozai/event`.
+ *
+ * Events emitted outside a transaction fire immediately.
+ * Events emitted inside a transaction are buffered until commit,
+ * and discarded on rollback.
+ */ export class EngineEventBus {
+    #emitter;
+    #logger;
+    #transactions;
+    constructor(options){
+        this.#emitter = new EventEmitter();
+        this.#logger = options?.logger;
+        this.#transactions = new Map();
+    }
+    /**
+   * Subscribe to a namespaced event.
+   * Returns an unsubscribe function.
+   */ on(name, listener) {
+        return this.#emitter.on(name, listener);
+    }
+    /**
+   * Emit an event immediately (not inside any transaction).
+   */ async emit(name, data) {
+        await this.#emitter.emit(name, data);
+    }
+    /**
+   * Begin a new transaction context for event buffering.
+   * Events emitted via `emitBuffered` with this transaction ID
+   * will be held until `commit` or `rollback` is called.
+   */ beginTransaction(transactionID) {
+        if (this.#transactions.has(transactionID)) {
+            throw new Error(`Transaction already exists: ${transactionID}`);
+        }
+        this.#transactions.set(transactionID, []);
+    }
+    /**
+   * Emit an event inside a transaction. The event is buffered
+   * and will only be delivered to listeners upon commit.
+   */ emitBuffered(transactionID, name, data) {
+        const buffer = this.#transactions.get(transactionID);
+        if (buffer == null) {
+            throw new Error(`Transaction not found: ${transactionID}`);
+        }
+        buffer.push({
+            name,
+            data
+        });
+    }
+    /**
+   * Commit a transaction: release all buffered events to listeners
+   * in the order they were emitted.
+   *
+   * Listener errors do not prevent remaining buffered events from firing.
+   * Since `@sozai/event` uses `Promise.allSettled` internally, all listeners
+   * for a given event run even if some throw. Errors from individual event
+   * emissions are caught so the full buffer is always drained.
+   */ async commit(transactionID) {
+        const buffer = this.#transactions.get(transactionID);
+        if (buffer == null) {
+            throw new Error(`Transaction not found: ${transactionID}`);
+        }
+        this.#transactions.delete(transactionID);
+        for (const event of buffer){
+            try {
+                await this.#emitter.emit(event.name, event.data);
+            } catch (err) {
+                // Listener errors do not prevent remaining buffered events from firing.
+                this.#logger?.warn('event listener error during commit for {event}: {error}', {
+                    event: event.name,
+                    error: String(err)
+                });
+            }
+        }
+    }
+    /**
+   * Rollback a transaction: discard all buffered events.
+   */ rollback(transactionID) {
+        if (!this.#transactions.has(transactionID)) {
+            throw new Error(`Transaction not found: ${transactionID}`);
+        }
+        this.#transactions.delete(transactionID);
+    }
+}

package/lib/executor.d.ts

@@ -8,6 +8,13 @@ import type { GetAPI } from './registry.js';
  */
 export type EngineGraphParams = ExecuteGraphParams & {
     viewerDID?: string;
+    /**
+     * Document owner for a delegated write: the server signs the mutation with its
+     * own identity but the resulting document is owned by `owner` (the viewer),
+     * authorized by a held viewer→server delegation capability. Omitted means the
+     * owner is the signer. Used by `mutateGraph` only.
+     */
+    owner?: string;
     /**
      * Delegation tokens authorizing writes to documents the caller does not own.
      * Carried on each outgoing mutation's `cap` field (part of the signed payload)

package/lib/executor.js

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

package/lib/index.d.ts

@@ -1,9 +1,12 @@
 export type { AccessChecker, AccessControlDB, AccessLevel, AccessPermissions, AccessRule, DefaultAccessLevel, } from './access-control.js';
 export { createAccessChecker, parseDocumentAccessPermissions, resolveAccessRule, validateDIDs, validateID, validateIDs, } from './access-control.js';
 export { catalogMatchesDoc } from './catalog-match.js';
-export type { AccessGate, ApplyVerifiedMutationParams, ApplyVerifiedMutationResult, ApplyVerifiedMutationsParams, ApplyVerifiedMutationsResult, ContextFactory, EngineParams, ExecuteParams, ExecutionContext, } from './engine.js';
+export type { Cipher } from './cipher.js';
+export { createDefaultCipher, deriveAtRestKey } from './cipher.js';
+export type { AccessGate, AccessGateFactory, AccessGateStores, ApplyVerifiedMutationParams, ApplyVerifiedMutationResult, ApplyVerifiedMutationsParams, ApplyVerifiedMutationsResult, ContextFactory, DocumentWrite, EngineParams, ExecuteParams, ExecutionContext, MutateDocumentsParams, } from './engine.js';
 export { KubunEngine } from './engine.js';
 export type { EngineEvents } from './engine-events.js';
+export { isTransactionFatal, TransactionFatalError } from './errors.js';
 export { EngineEventBus } from './events.js';
 export type { Engine, EngineGraphParams, GraphQLOperationParams, GraphQLSource, GraphQLSourceParams, GraphQLSourceProvider, GraphsProvider, } from './executor.js';
 export type { CheckMembershipParams, CheckMembershipResult } from './membership-check.js';

package/lib/index.js

@@ -1 +1,10 @@
-export{createAccessChecker,parseDocumentAccessPermissions,resolveAccessRule,validateDIDs,validateID,validateIDs}from"./access-control.js";export{catalogMatchesDoc}from"./catalog-match.js";export{KubunEngine}from"./engine.js";export{EngineEventBus}from"./events.js";export{checkMembership}from"./membership-check.js";export{computeMutationHash}from"./mutation-hash.js";export{runPolicies}from"./policies.js";export{createRegistry}from"./registry.js";
+export { createAccessChecker, parseDocumentAccessPermissions, resolveAccessRule, validateDIDs, validateID, validateIDs } from './access-control.js';
+export { catalogMatchesDoc } from './catalog-match.js';
+export { createDefaultCipher, deriveAtRestKey } from './cipher.js';
+export { KubunEngine } from './engine.js';
+export { isTransactionFatal, TransactionFatalError } from './errors.js';
+export { EngineEventBus } from './events.js';
+export { checkMembership } from './membership-check.js';
+export { computeMutationHash } from './mutation-hash.js';
+export { runPolicies } from './policies.js';
+export { createRegistry } from './registry.js';

package/lib/membership-check.js

@@ -1 +1,99 @@
-import{catalogMatchesDoc as e}from"./catalog-match.js";export async function checkMembership(t){let{p2pStore:r,graphStore:l,selfDID:o,iss:a,mutationHLC:i,doc:f,arrivalGroupID:n}=t,u=async e=>{let t=await r.getMemberRemoval(e,a);if(null!=t&&null!=t.removed_at_hlc)return t.removed_at_hlc<=i?t.removed_at_hlc:void 0};if(null!=n){let e=await u(n);return null!=e?{ok:!1,removedGroupID:n,removedAtHLC:e}:{ok:!0}}let c=await r.getCirclesForMember(o);if(0===c.length)return{ok:!0};let d=new Set;for(let e of c)for(let t of e.catalog_ids??[])d.add(t);let m=new Map;d.size>0&&(m=await l.getCatalogs(Array.from(d)));let g=new Set;for(let t of c)for(let l of t.catalog_ids??[]){let o=m.get(l);if(null!=o&&await e(o.filter_criteria,f,r)){g.add(t.group_id);break}}if(0===g.size)return{ok:!0};for(let e of g){let t=await u(e);if(null!=t)return{ok:!1,removedGroupID:e,removedAtHLC:t}}return{ok:!0}}
+import { normalizeDID } from '@kokuin/token';
+import { catalogMatchesDoc } from './catalog-match.js';
+/**
+ * Decide whether a mutation's issuer is still permitted to write to the doc's
+ * MLS group(s) at the mutation's HLC.
+ *
+ * A group rejects the issuer iff a membership row exists with a removal HLC
+ * that is non-null AND causally at or before the mutation's HLC: the issuer was
+ * removed before (or exactly at) the moment the mutation claims. A missing row,
+ * an active member (`removed_at_hlc === null`), or a removal recorded strictly
+ * after the mutation (a pre-removal mutation) all accept.
+ *
+ * The serialized HLC form is lexicographically ordered, so a string `<=`
+ * compare matches HLC ordering — the same convention the soft-delete LWW uses.
+ *
+ * On the receive path (`arrivalGroupID` set) only that one group is checked.
+ * On the RPC path the candidate groups are the groups behind every circle the
+ * applying peer belongs to whose catalog covers the document; an empty walk
+ * means the doc lies outside this peer's enforceable perimeter and is accepted.
+ */ export async function checkMembership(params) {
+    const { p2pStore, graphStore, selfDID, mutationHLC, doc, arrivalGroupID } = params;
+    // did:peer:4 issuers can arrive in long form; the roster stores the short
+    // form, so normalize before any roster comparison.
+    const iss = normalizeDID(params.iss);
+    // Returns the removal HLC that denies the issuer in this group, or undefined
+    // when the group does not reject (no row, active member, or a removal recorded
+    // strictly after the mutation).
+    const rejectionHLC = async (groupID)=>{
+        const removal = await p2pStore.getMemberRemoval(groupID, iss);
+        if (removal == null || removal.removed_at_hlc == null) {
+            return undefined;
+        }
+        return removal.removed_at_hlc <= mutationHLC ? removal.removed_at_hlc : undefined;
+    };
+    // Receive branch: the envelope already pins the group — check only it.
+    if (arrivalGroupID != null) {
+        const removedAtHLC = await rejectionHLC(arrivalGroupID);
+        if (removedAtHLC != null) {
+            return {
+                ok: false,
+                removedGroupID: arrivalGroupID,
+                removedAtHLC
+            };
+        }
+        return {
+            ok: true
+        };
+    }
+    // RPC branch: resolve candidate groups via the circle walk.
+    const circles = await p2pStore.getCirclesForMember(selfDID);
+    if (circles.length === 0) {
+        return {
+            ok: true
+        };
+    }
+    // Batch-fetch every catalog referenced across the peer's circles in one query.
+    const catalogIDSet = new Set();
+    for (const circle of circles){
+        for (const catalogID of circle.catalog_ids ?? []){
+            catalogIDSet.add(catalogID);
+        }
+    }
+    let catalogsByID = new Map();
+    if (catalogIDSet.size > 0) {
+        catalogsByID = await graphStore.getCatalogs(Array.from(catalogIDSet));
+    }
+    // A circle's group is a candidate iff at least one of its catalogs covers
+    // the document.
+    const candidateGroupIDs = new Set();
+    for (const circle of circles){
+        for (const catalogID of circle.catalog_ids ?? []){
+            const catalog = catalogsByID.get(catalogID);
+            if (catalog == null) continue;
+            if (await catalogMatchesDoc(catalog.filter_criteria, doc, p2pStore)) {
+                candidateGroupIDs.add(circle.group_id);
+                break;
+            }
+        }
+    }
+    // Empty walk: doc is outside this peer's enforceable perimeter — accept.
+    if (candidateGroupIDs.size === 0) {
+        return {
+            ok: true
+        };
+    }
+    for (const groupID of candidateGroupIDs){
+        const removedAtHLC = await rejectionHLC(groupID);
+        if (removedAtHLC != null) {
+            return {
+                ok: false,
+                removedGroupID: groupID,
+                removedAtHLC
+            };
+        }
+    }
+    return {
+        ok: true
+    };
+}

package/lib/mutation-hash.js

@@ -1 +1,6 @@
-import{blake3 as e}from"@noble/hashes/blake3.js";import{bytesToHex as o}from"@noble/hashes/utils.js";let t=new TextEncoder;export function computeMutationHash(n){return o(e(t.encode(n)))}
+import { blake3 } from '@noble/hashes/blake3.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+const encoder = new TextEncoder();
+export function computeMutationHash(jwt) {
+    return bytesToHex(blake3(encoder.encode(jwt)));
+}

package/lib/plugin.d.ts

@@ -1,11 +1,12 @@
-import type { Runtime } from '@enkaku/runtime';
-import type { Identity } from '@enkaku/token';
+import type { Identity } from '@kokuin/token';
 import type { KubunDB } from '@kubun/db';
 import type { ExtensionResolvers } from '@kubun/graphql';
 import type { HLC } from '@kubun/hlc';
 import type { Logger } from '@kubun/logger';
+import type { Runtime } from '@sozai/runtime';
 import type { ExecutionResult } from 'graphql';
-import type { ApplyVerifiedMutationParams, ApplyVerifiedMutationResult, ApplyVerifiedMutationsParams, ApplyVerifiedMutationsResult, ContextFactory, ExecuteParams } from './engine.js';
+import type { Cipher } from './cipher.js';
+import type { ApplyVerifiedMutationParams, ApplyVerifiedMutationResult, ApplyVerifiedMutationsParams, ApplyVerifiedMutationsResult, ContextFactory, ExecuteParams, MutateDocumentsParams } from './engine.js';
 import type { EngineEvents } from './engine-events.js';
 import type { EngineEventBus } from './events.js';
 import type { Engine } from './executor.js';
@@ -13,6 +14,25 @@ import type { PolicyGateMap } from './policies.js';
 export type SchemaExtension = {
     sdl: string;
     resolvers: ExtensionResolvers;
+    /**
+     * Names of `Mutation` fields whose resolvers must run OUTSIDE `mutateGraph`'s
+     * write transaction. Side-effecting operations (peer connect/sync, dance
+     * round-trips) perform network I/O and/or open their own per-step
+     * transactions; wrapping them in the outer write transaction would hold the
+     * DB connection across a network round-trip and, on single-connection
+     * SQLite, deadlock a nested apply against the ambient transaction.
+     *
+     * The opt-out affects ONLY the DB transaction. Such resolvers still run
+     * through `mutateGraph`'s owner-signed authorization path and still receive
+     * the signed mutation operations (`executeCreateMutation`, etc.), which
+     * autocommit each write instead of sharing one ambient transaction. Store
+     * reads and writes route through the root provider, so nothing joins a
+     * transaction that is not open.
+     *
+     * A single mutation operation must not mix transactional and
+     * non-transactional root fields — the engine rejects such an operation.
+     */
+    nonTransactionalMutationFields?: Array<string>;
 };
 /**
  * Low-level graph operations available only to plugins.
@@ -24,6 +44,12 @@ export type GraphInternals = {
     subscribe<Data extends Record<string, unknown> = Record<string, unknown>>(params: ExecuteParams): Promise<AsyncGenerator<ExecutionResult<Data>> | ExecutionResult<Data>>;
     applyVerifiedMutation(params: ApplyVerifiedMutationParams): Promise<ApplyVerifiedMutationResult>;
     applyVerifiedMutations(params: ApplyVerifiedMutationsParams): Promise<ApplyVerifiedMutationsResult>;
+    /**
+     * Apply a batch of document writes signed by the engine identity — optionally
+     * on behalf of `owner` — within one signed write transaction. No GraphQL text
+     * is parsed or executed.
+     */
+    mutateDocuments(params: MutateDocumentsParams): Promise<Array<ApplyVerifiedMutationResult>>;
 };
 /**
  * Parameters provided by the engine to plugin factories.
@@ -39,6 +65,8 @@ export type PluginFactoryParams = {
     eventBus: EngineEventBus<EngineEvents>;
     hlc: HLC;
     getLogger: (name: string) => Logger;
+    /** Shared at-rest cipher; undefined when no key is available. */
+    cipher: Cipher | undefined;
 };
 /**
  * Plugin descriptor returned by a plugin factory.

package/lib/plugin.js

@@ -1 +1,7 @@
-export{};
+/**
+ * Plugin descriptor returned by a plugin factory.
+ *
+ * Plugins expose APIs via the `api` field. Other plugins access them
+ * via `engine.getAPI(name)`. Lifecycle coordination uses lazy promises
+ * on plugin APIs (e.g. `httpAPI.listening`) rather than a central registry.
+ */ export { };

package/lib/policies.js

@@ -1 +1,55 @@
-function e(e){return"issues"in e&&null!=e.issues&&e.issues.length>0}export async function runPolicies(n,t,u){let r=n[t];if(null==r)return{value:u};for(let n of r.sync??[]){let t=n(u);if(e(t))return t}for(let n of r.async??[]){let t=await n(u);if(e(t))return t}return{value:u}}
+/**
+ * Policy gate module for the Kubun engine.
+ *
+ * Policies gate engine operations with sync-before-async ordering.
+ * Each gate has optional sync and async check arrays. Sync checks run first
+ * (fast, in-memory). If any sync check fails, async checks are skipped entirely.
+ *
+ * Result types follow the Standard Schema output specification:
+ * - Success: `{ value }` — the context passes through
+ * - Failure: `{ issues }` — an array of issues with at minimum a `message` field
+ */ // ---- Standard Schema-compatible result types (https://standardschema.dev) ----
+/**
+ * A path segment in a policy issue, matching StandardSchemaV1.PathSegment.
+ */ // ---- Execution ----
+function isFailure(result) {
+    return 'issues' in result && result.issues != null && result.issues.length > 0;
+}
+/**
+ * Run all policy checks for a given gate type.
+ *
+ * Execution order:
+ * 1. Run ALL sync checks — fail fast if any return issues
+ * 2. Run ALL async checks — fail fast if any return issues
+ * 3. Return success with the original context
+ *
+ * If the gate type is not present in the map, the operation is allowed by default.
+ */ export async function runPolicies(gates, gateType, context) {
+    const gate = gates[gateType];
+    // No gate defined for this type — allow by default
+    if (gate == null) {
+        return {
+            value: context
+        };
+    }
+    // Phase 1: Run sync checks (fast, in-memory)
+    const syncChecks = gate.sync ?? [];
+    for (const check of syncChecks){
+        const result = check(context);
+        if (isFailure(result)) {
+            return result;
+        }
+    }
+    // Phase 2: Run async checks (potentially slow — DB, network, etc.)
+    const asyncChecks = gate.async ?? [];
+    for (const check of asyncChecks){
+        const result = await check(context);
+        if (isFailure(result)) {
+            return result;
+        }
+    }
+    // All checks passed
+    return {
+        value: context
+    };
+}

package/lib/registry.js

@@ -1 +1,25 @@
-import{defer as e}from"@enkaku/async";export function createRegistry(){let r=e(),t={};return{registerPlugin:function(e,r){t[e]=r},closeGate:function(){r.resolve()},getAPI:function(e){return r.promise.then(()=>{let r=t[e];if(null==r)throw Error(`API not registered: ${e}`);return r})}}}
+import { defer } from '@sozai/async';
+export function createRegistry() {
+    const gate = defer();
+    const pluginAPIs = {};
+    function registerPlugin(name, api) {
+        pluginAPIs[name] = api;
+    }
+    function closeGate() {
+        gate.resolve();
+    }
+    function getAPI(name) {
+        return gate.promise.then(()=>{
+            const api = pluginAPIs[name];
+            if (api == null) {
+                throw new Error(`API not registered: ${name}`);
+            }
+            return api;
+        });
+    }
+    return {
+        registerPlugin,
+        closeGate,
+        getAPI
+    };
+}

package/package.json

@@ -1,52 +1,55 @@
 {
   "name": "@kubun/engine",
-  "version": "0.10.3",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@enkaku/async": "^0.16.0",
-    "@enkaku/capability": "^0.16.0",
-    "@enkaku/event": "^0.16.0",
-    "@enkaku/runtime": "^0.16.0",
-    "@enkaku/schema": "^0.16.0",
-    "@enkaku/token": "^0.16.0",
+    "@kokuin/capability": "^0.2.1",
+    "@kokuin/token": "^0.3.0",
+    "@noble/ciphers": "^2.2.0",
     "@noble/hashes": "^2.2.0",
+    "@sozai/async": "^0.2.1",
+    "@sozai/codec": "^0.4.0",
+    "@sozai/event": "^0.1.3",
+    "@sozai/runtime": "^0.1.0",
+    "@sozai/schema": "^0.1.1",
     "graphql": "^16.14.2",
-    "@kubun/graphql": "^0.10.1",
-    "@kubun/db-adapter": "^0.10.0",
-    "@kubun/logger": "^0.10.0",
-    "@kubun/mutation": "^0.10.0",
-    "@kubun/protocol": "^0.10.0",
-    "@kubun/hlc": "^0.10.0",
-    "@kubun/store-graph": "^0.10.1",
-    "@kubun/store-p2p": "^0.10.0",
-    "@kubun/db": "^0.10.0"
+    "@kubun/db": "^0.12.0",
+    "@kubun/hlc": "^0.12.0",
+    "@kubun/db-adapter": "^0.12.0",
+    "@kubun/logger": "^0.12.0",
+    "@kubun/graphql": "^0.12.0",
+    "@kubun/store-delegation": "^0.12.0",
+    "@kubun/mutation": "^0.12.0",
+    "@kubun/protocol": "^0.12.0",
+    "@kubun/store-graph": "^0.12.0",
+    "@kubun/store-p2p": "^0.12.0"
   },
   "devDependencies": {
-    "@testcontainers/postgresql": "^12.0.1",
-    "@kubun/db-postgres": "^0.10.0",
-    "@kubun/test-utils": "^0.10.0",
-    "@kubun/id": "^0.10.0"
+    "@testcontainers/postgresql": "^12.1.0",
+    "@kubun/id": "^0.12.0",
+    "@kubun/db-postgres": "^0.12.0",
+    "@kubun/test-utils": "^0.12.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }