@kubun/plugin-rpc 0.10.0 → 0.11.0

package/lib/handlers.d.ts

@@ -1,9 +1,9 @@
-import type { GetRandomValues } from '@enkaku/runtime';
 import type { ProcedureHandlers } from '@enkaku/server';
-import type { SigningIdentity } from '@enkaku/token';
+import type { SigningIdentity } from '@kokuin/token';
 import type { Engine, GraphInternals } from '@kubun/engine';
 import type { HLC } from '@kubun/hlc';
 import type { GraphProtocol } from '@kubun/protocol';
+import type { GetRandomValues } from '@sozai/runtime';
 import type { TransactionManager } from './transaction-manager.js';
 export type CreateHandlersParams = {
     allowDelegatedMutations: boolean;

package/lib/handlers.js

@@ -1 +1,328 @@
-import{consume as a}from"@enkaku/generator";import{stringifyToken as t}from"@enkaku/token";import{DocumentID as e}from"@kubun/id";import{convertPatchInput as r,createMutationOperations as n,WriteAccessDeniedError as i}from"@kubun/mutation";import{GraphQLError as o}from"graphql";function s(a){let t={data:a.data};return null!=a.errors&&(t.errors=a.errors.map(a=>a.toJSON())),null!=a.extensions&&(t.extensions=a.extensions),t}function u(a,t){let e=a.message?.payload,r=e?.sub??e?.iss??t;return{id:a.param.id,text:a.param.text,variables:a.param.variables??{},viewerDID:r}}export function createGraphHandlers(c){let{allowDelegatedMutations:l,engine:p,getRandomValues:d,graph:m,defaultDID:g,hlc:h,signingIdentity:y,transactionManager:w}=c;return{"graph/deploy":async a=>await p.deployGraph({clusters:a.param.clusters,id:a.param.id,name:a.param.name,plugins:a.param.plugins}),"graph/list":async()=>await p.listGraphs(),"graph/load":async a=>await p.loadGraph({id:a.param.id}),"graph/mutate":async a=>{let{viewerDID:c}=u(a,g);if(null!=a.param.mutations){let t,e=a.param.mutations,r=Object.keys(e),n=r.map(a=>e[a]);try{t=await m.applyVerifiedMutations({tokens:n})}catch(a){if(a instanceof i)return s({data:null,errors:[new o(a.message,{extensions:{code:a.code,docID:a.docID}})]});throw a}let{results:u}=t,l={};for(let a=0;a<r.length;a++){let t=u[a].document;if(null==t)throw Error("Unexpected dropped mutation in pre-signed apply (no gate configured)");l[r[a]]=t}return s(await m.execute({graphID:a.param.id,text:a.param.text,variables:a.param.variables??{},viewerDID:c,contextExtensions:{executeCreateMutation:async a=>l[a.info.path.key],executeSetMutation:async a=>l[a.info.path.key],executeUpdateMutation:async a=>l[a.info.path.key],executeRemoveMutation:async()=>{}}}))}if(!l)throw Error("Delegated mutations not enabled. Set allowDelegatedMutations: true or provide pre-signed mutations.");if(null==y)throw Error("Delegated mutations require a SigningIdentity on the engine");let f=a.param.transactionID??null;if(null==f)return s(await p.mutateGraph({id:a.param.id,text:a.param.text,variables:a.param.variables??{},viewerDID:c}));let D=async a=>{let r=t(await y.signToken(a)),n=w.getTransaction(f);if(null==n)throw Error(`Transaction not found or expired: ${f}`);let i=e.fromString(a.sub),o="change"===a.typ,s={id:a.sub,model:i.model.toString(),owner:a.aud??a.iss,data:o?null:a.data,createdAt:new Date,updatedAt:o?new Date:null};return n.mutations.push({mutation:a,jwt:r,authorDID:a.iss,documentID:s.id,result:s}),s},x=n({issuer:y.id,hlc:h,getRandomValues:d,processSetMutation:async a=>await D(a),processChangeMutation:async a=>await D(a)});return s(await m.execute({graphID:a.param.id,text:a.param.text,variables:a.param.variables??{},viewerDID:c,contextExtensions:{executeCreateMutation:async a=>await x.createDocument({modelID:a.modelID,data:a.data}),executeSetMutation:async a=>await x.setDocument({modelID:a.modelID,unique:a.unique,data:a.data}),executeUpdateMutation:async a=>await x.updateDocument({docID:a.input.id,patch:r(a.input.patch)}),executeRemoveMutation:async a=>{await x.removeDocument({docID:a.id})}}}))},"graph/query":async a=>s(await p.queryGraph(u(a,g))),"graph/subscribe":async t=>{let e=await p.subscribeToGraph(u(t,g));if(t.signal.aborted)return null;if("errors"in e)return s(e);let r=t.writable.getWriter();try{await a(e,async a=>{await r.write(s(a))},t.signal)}catch(a){if(!t.signal.aborted)throw a}finally{try{await r.close()}catch{}}return null},"graph/beginTransaction":async a=>{let t=a.message?.payload,e=t?.iss??g;return await p.loadGraph({id:a.param.id}),{transactionID:w.beginTransaction(e,a.param.id).id}},"graph/commitTransaction":async a=>{let t=w.getTransaction(a.param.transactionID);if(null==t)throw Error(`Transaction not found or expired: ${a.param.transactionID}`);if(t.mutations.length>0){let e=t.mutations.map(a=>a.jwt);try{await m.applyVerifiedMutations({tokens:e})}catch(t){if(t instanceof i)return w.rollbackTransaction(a.param.transactionID),{success:!1,error:{code:t.code,message:t.message,docID:t.docID}};throw t}}return w.markCommitted(a.param.transactionID),{success:!0}},"graph/rollbackTransaction":async a=>(w.rollbackTransaction(a.param.transactionID),{success:!0})}}
+import { stringifyToken } from '@kokuin/token';
+import { DocumentID } from '@kubun/id';
+import { convertPatchInput, createMutationOperations, WriteAccessDeniedError } from '@kubun/mutation';
+import { consume } from '@sozai/generator';
+import { GraphQLError } from 'graphql';
+function toGraphResult(result) {
+    const graphResult = {
+        data: result.data
+    };
+    if (result.errors != null) {
+        graphResult.errors = result.errors.map((err)=>{
+            const json = err.toJSON();
+            return json;
+        });
+    }
+    if (result.extensions != null) {
+        graphResult.extensions = result.extensions;
+    }
+    return graphResult;
+}
+/**
+ * Resolve the viewerDID for a graph operation from the signed message payload.
+ *
+ * The verified `iss` is the only trustworthy viewer: it is the DID that signed
+ * the request. A `sub` that differs from `iss` is a forged-subject attempt
+ * (running the graph as someone else), so it is rejected outright. The
+ * `defaultDID` fallback applies ONLY when no payload is present, which is the
+ * explicit `accessRules: false` local mode where authentication is disabled.
+ */ function resolveViewerDID(payload, defaultDID) {
+    if (payload == null) return defaultDID;
+    const iss = payload.iss;
+    const sub = payload.sub;
+    if (sub != null && sub !== iss) {
+        throw new Error('Access denied: signed payload subject does not match issuer');
+    }
+    return iss ?? defaultDID;
+}
+/**
+ * Extract EngineGraphParams from a handler context, resolving the viewerDID
+ * from the verified issuer of the signed message payload (see resolveViewerDID).
+ */ function extractGraphParams(ctx, defaultDID) {
+    const payload = ctx.message?.payload;
+    return {
+        id: ctx.param.id,
+        text: ctx.param.text,
+        variables: ctx.param.variables ?? {},
+        viewerDID: resolveViewerDID(payload, defaultDID)
+    };
+}
+export function createGraphHandlers(params) {
+    const { allowDelegatedMutations, engine, getRandomValues, graph, defaultDID, hlc, signingIdentity, transactionManager } = params;
+    return {
+        'graph/deploy': async (ctx)=>{
+            return await engine.deployGraph({
+                clusters: ctx.param.clusters,
+                id: ctx.param.id,
+                name: ctx.param.name,
+                plugins: ctx.param.plugins
+            });
+        },
+        'graph/list': async ()=>{
+            return await engine.listGraphs();
+        },
+        'graph/load': async (ctx)=>{
+            return await engine.loadGraph({
+                id: ctx.param.id
+            });
+        },
+        'graph/mutate': async (ctx)=>{
+            const { viewerDID } = extractGraphParams(ctx, defaultDID);
+            if (ctx.param.mutations != null) {
+                // Pre-signed mode: client submitted JWT tokens keyed by GraphQL field alias
+                const mutations = ctx.param.mutations;
+                const keys = Object.keys(mutations);
+                const tokens = keys.map((k)=>mutations[k]);
+                // Apply all mutations atomically via engine primitive. A
+                // capability-check failure throws `WriteAccessDeniedError` from the
+                // apply path; translate it into a GraphQL-shaped result so the wire
+                // carries the `KB07` extensions code instead of the generic enkaku
+                // "Handler execution failed" wrapper that would otherwise hide the
+                // reason.
+                let applied;
+                try {
+                    applied = await graph.applyVerifiedMutations({
+                        tokens
+                    });
+                } catch (cause) {
+                    if (cause instanceof WriteAccessDeniedError) {
+                        return toGraphResult({
+                            data: null,
+                            errors: [
+                                new GraphQLError(cause.message, {
+                                    extensions: {
+                                        code: cause.code,
+                                        docID: cause.docID
+                                    }
+                                })
+                            ]
+                        });
+                    }
+                    throw cause;
+                }
+                const { results } = applied;
+                // Build mutatedDocuments map keyed by GraphQL field path. Pre-signed
+                // mode does not configure an accessGate, so every result here carries
+                // a non-null `document`.
+                const mutatedDocuments = {};
+                for(let i = 0; i < keys.length; i++){
+                    const doc = results[i].document;
+                    if (doc == null) {
+                        throw new Error('Unexpected dropped mutation in pre-signed apply (no gate configured)');
+                    }
+                    mutatedDocuments[keys[i]] = doc;
+                }
+                // Execute GraphQL with overridden mutation executors that return pre-applied results.
+                // contextExtensions overrides the engine's default executors via shallow merge.
+                const result = await graph.execute({
+                    graphID: ctx.param.id,
+                    text: ctx.param.text,
+                    variables: ctx.param.variables ?? {},
+                    viewerDID,
+                    contextExtensions: {
+                        executeCreateMutation: async (params)=>{
+                            return mutatedDocuments[params.info.path.key];
+                        },
+                        executeSetMutation: async (params)=>{
+                            return mutatedDocuments[params.info.path.key];
+                        },
+                        executeUpdateMutation: async (params)=>{
+                            return mutatedDocuments[params.info.path.key];
+                        },
+                        executeRemoveMutation: async ()=>{
+                        // Remove mutations don't return a document — already applied
+                        }
+                    }
+                });
+                return toGraphResult(result);
+            }
+            // Delegated mode: server signs mutations on behalf of the client.
+            // Must be explicitly enabled via allowDelegatedMutations option.
+            if (!allowDelegatedMutations) {
+                throw new Error('Delegated mutations not enabled. Set allowDelegatedMutations: true or provide pre-signed mutations.');
+            }
+            if (signingIdentity == null) {
+                throw new Error('Delegated mutations require a SigningIdentity on the engine');
+            }
+            const transactionID = ctx.param.transactionID ?? null;
+            // Non-transaction delegated: engine.mutateGraph() handles signing internally
+            if (transactionID == null) {
+                const result = await engine.mutateGraph({
+                    id: ctx.param.id,
+                    text: ctx.param.text,
+                    variables: ctx.param.variables ?? {},
+                    viewerDID,
+                    owner: viewerDID
+                });
+                return toGraphResult(result);
+            }
+            // Transaction mode: buffer signed mutations without applying them.
+            // Requires custom signing context since mutateGraph() applies immediately.
+            const signAndBuffer = async (mutation)=>{
+                const signed = await signingIdentity.signToken(mutation);
+                const jwt = stringifyToken(signed);
+                const txCtx = transactionManager.getTransaction(transactionID);
+                if (txCtx == null) {
+                    throw new Error(`Transaction not found or expired: ${transactionID}`);
+                }
+                const docID = DocumentID.fromString(mutation.sub);
+                const isChange = mutation.typ === 'change';
+                const result = {
+                    id: mutation.sub,
+                    model: docID.model.toString(),
+                    owner: mutation.aud ?? mutation.iss,
+                    data: isChange ? null : mutation.data,
+                    createdAt: new Date(),
+                    updatedAt: isChange ? new Date() : null
+                };
+                txCtx.mutations.push({
+                    mutation,
+                    jwt,
+                    authorDID: mutation.iss,
+                    documentID: result.id,
+                    result
+                });
+                return result;
+            };
+            const ops = createMutationOperations({
+                issuer: signingIdentity.id,
+                hlc,
+                getRandomValues,
+                owner: viewerDID,
+                async processSetMutation (mutation) {
+                    return await signAndBuffer(mutation);
+                },
+                async processChangeMutation (mutation) {
+                    return await signAndBuffer(mutation);
+                }
+            });
+            const result = await graph.execute({
+                graphID: ctx.param.id,
+                text: ctx.param.text,
+                variables: ctx.param.variables ?? {},
+                viewerDID,
+                contextExtensions: {
+                    executeCreateMutation: async (params)=>{
+                        return await ops.createDocument({
+                            modelID: params.modelID,
+                            data: params.data
+                        });
+                    },
+                    executeSetMutation: async (params)=>{
+                        return await ops.setDocument({
+                            modelID: params.modelID,
+                            unique: params.unique,
+                            data: params.data
+                        });
+                    },
+                    executeUpdateMutation: async (params)=>{
+                        return await ops.updateDocument({
+                            docID: params.input.id,
+                            patch: convertPatchInput(params.input.patch)
+                        });
+                    },
+                    executeRemoveMutation: async (params)=>{
+                        await ops.removeDocument({
+                            docID: params.id
+                        });
+                    }
+                }
+            });
+            return toGraphResult(result);
+        },
+        'graph/query': async (ctx)=>{
+            const result = await engine.queryGraph(extractGraphParams(ctx, defaultDID));
+            return toGraphResult(result);
+        },
+        'graph/subscribe': async (ctx)=>{
+            const subscription = await engine.subscribeToGraph(extractGraphParams(ctx, defaultDID));
+            if (ctx.signal.aborted) {
+                return null;
+            }
+            // If subscribe returned errors instead of an async generator
+            if ('errors' in subscription) {
+                return toGraphResult(subscription);
+            }
+            const writer = ctx.writable.getWriter();
+            try {
+                await consume(subscription, async (value)=>{
+                    await writer.write(toGraphResult(value));
+                }, ctx.signal);
+            } catch (reason) {
+                // When aborted (client disconnect, server dispose), consume() rejects
+                // with the abort reason. This is expected.
+                if (!ctx.signal.aborted) {
+                    throw reason;
+                }
+            } finally{
+                // Belt-and-braces: explicitly close the source generator so its
+                // document:saved listener is torn down. consume() already calls
+                // return() on abort and normal completion; this is an idempotent
+                // safeguard against a future consume() that does not.
+                try {
+                    await subscription.return?.(undefined);
+                } catch  {
+                // Generator may already be closed during abort teardown
+                }
+                try {
+                    await writer.close();
+                } catch  {
+                // Writer may already be closed during abort teardown
+                }
+            }
+            return null;
+        },
+        'graph/beginTransaction': async (ctx)=>{
+            const payload = ctx.message?.payload;
+            const callerDID = resolveViewerDID(payload, defaultDID);
+            // Validate that the graph exists before starting a transaction
+            await engine.loadGraph({
+                id: ctx.param.id
+            });
+            const txCtx = transactionManager.beginTransaction(callerDID, ctx.param.id);
+            return {
+                transactionID: txCtx.id
+            };
+        },
+        'graph/commitTransaction': async (ctx)=>{
+            const txCtx = transactionManager.getTransaction(ctx.param.transactionID);
+            if (txCtx == null) {
+                throw new Error(`Transaction not found or expired: ${ctx.param.transactionID}`);
+            }
+            if (txCtx.mutations.length > 0) {
+                const tokens = txCtx.mutations.map((m)=>m.jwt);
+                try {
+                    await graph.applyVerifiedMutations({
+                        tokens
+                    });
+                } catch (cause) {
+                    if (cause instanceof WriteAccessDeniedError) {
+                        // Revocation between begin and commit — surface the reason on the
+                        // wire via the typed `error` field so callers can distinguish
+                        // access-denied from generic commit failures.
+                        transactionManager.rollbackTransaction(ctx.param.transactionID);
+                        return {
+                            success: false,
+                            error: {
+                                code: cause.code,
+                                message: cause.message,
+                                docID: cause.docID
+                            }
+                        };
+                    }
+                    throw cause;
+                }
+            }
+            transactionManager.markCommitted(ctx.param.transactionID);
+            return {
+                success: true
+            };
+        },
+        'graph/rollbackTransaction': async (ctx)=>{
+            transactionManager.rollbackTransaction(ctx.param.transactionID);
+            return {
+                success: true
+            };
+        }
+    };
+}

package/lib/index.js

@@ -1 +1,67 @@
-import{serve as e}from"@enkaku/server";import{isSigningIdentity as t}from"@enkaku/token";import{createGraphHandlers as n}from"./handlers.js";import{TransactionManager as i}from"./transaction-manager.js";export function createRPCPlugin(r){return a=>{let o=[],s=t(a.identity)?a.identity:null,g=new i({getRandomID:a.runtime.getRandomID,...r?.transactionConfig}),l=n({allowDelegatedMutations:r?.allowDelegatedMutations??!1,defaultDID:a.identity.id,engine:a.engine,getRandomValues:a.runtime.getRandomValues,graph:a.graph,signingIdentity:s,hlc:a.hlc,transactionManager:g});return{name:"rpc",api:{serve:(t,n)=>{let i=r?.accessRules,s={getRandomID:a.runtime.getRandomID,handlers:l,logger:a.getLogger("rpc-server"),signal:n,transport:t},g=e(!1===i?s:{...s,identity:a.identity,accessRules:i??{}});return o.push(g),g}},dispose:async()=>{for(let e of(g.dispose(),o))await e.dispose()}}}}
+import { serve } from '@enkaku/server';
+import { isSigningIdentity } from '@kokuin/token';
+import { createGraphHandlers } from './handlers.js';
+import { TransactionManager } from './transaction-manager.js';
+// ---- Plugin factory ----
+/**
+ * Creates the RPC plugin.
+ *
+ * The RPC plugin exposes the engine over transport. It optionally depends
+ * on the HTTP plugin for registering a /graphql route. Even without HTTP,
+ * the RPC plugin provides status tracking and a GraphQL query for server status.
+ *
+ * Creates Enkaku protocol handlers backed by the engine's Core interface
+ * (queryGraph/mutateGraph/subscribeToGraph via GraphInternals). Clients connect via `serve()` on any transport.
+ */ export function createRPCPlugin(options) {
+    return (params)=>{
+        const servers = [];
+        const signer = isSigningIdentity(params.identity) ? params.identity : null;
+        const transactionManager = new TransactionManager({
+            getRandomID: params.runtime.getRandomID,
+            ...options?.transactionConfig
+        });
+        const handlers = createGraphHandlers({
+            allowDelegatedMutations: options?.allowDelegatedMutations ?? false,
+            defaultDID: params.identity.id,
+            engine: params.engine,
+            getRandomValues: params.runtime.getRandomValues,
+            graph: params.graph,
+            signingIdentity: signer,
+            hlc: params.hlc,
+            transactionManager
+        });
+        const api = {
+            serve: (transport, signal)=>{
+                const accessRules = options?.accessRules;
+                const baseParams = {
+                    getRandomID: params.runtime.getRandomID,
+                    handlers,
+                    logger: params.getLogger('rpc-server'),
+                    signal,
+                    transport
+                };
+                const serveParams = accessRules === false ? {
+                    ...baseParams,
+                    requireAuth: false
+                } : {
+                    ...baseParams,
+                    identity: params.identity,
+                    accessRules: accessRules ?? {}
+                };
+                const server = serve(serveParams);
+                servers.push(server);
+                return server;
+            }
+        };
+        return {
+            name: 'rpc',
+            api,
+            dispose: async ()=>{
+                transactionManager.dispose();
+                for (const server of servers){
+                    await server.dispose();
+                }
+            }
+        };
+    };
+}

package/lib/transaction-manager.js

@@ -1 +1,105 @@
-export class TransactionManager{#t;#e;#a;#i;#s=new Map;#n=null;constructor(t){this.#t=t.getRandomID,this.#e=t.globalLimit??20,this.#a=t.perDIDLimit??3,this.#i=t.timeoutMS??3e4,this.#o()}beginTransaction(t,e){if(this.#s.size>=this.#e)throw Error(`Global transaction limit reached (${this.#e}). Cannot create new transaction.`);let a=0;for(let e of this.#s.values())e.callerDID===t&&a++;if(a>=this.#a)throw Error(`Per-DID transaction limit reached (${this.#a}) for ${t}. Cannot create new transaction.`);let i={id:this.#t(),callerDID:t,graphID:e,mutations:[],createdAt:Date.now(),status:"open"};return this.#s.set(i.id,i),i}getTransaction(t){let e=this.#s.get(t);return null==e?null:Date.now()-e.createdAt>this.#i?(e.status="rolledBack",this.#s.delete(t),null):e}rollbackTransaction(t){let e=this.#s.get(t);if(null==e)throw Error(`Transaction not found: ${t}`);if("committed"===e.status)throw Error(`Cannot rollback committed transaction: ${t}`);e.status="rolledBack",this.#s.delete(t)}markCommitted(t){let e=this.#s.get(t);null!=e&&(e.status="committed",this.#s.delete(t))}dispose(){for(let[t,e]of this.#s)("open"===e.status||"committing"===e.status)&&(e.status="rolledBack");this.#s.clear(),null!=this.#n&&(clearInterval(this.#n),this.#n=null)}#o(){this.#n=setInterval(()=>{let t=Date.now();for(let[e,a]of this.#s)t-a.createdAt>this.#i&&(a.status="rolledBack",this.#s.delete(e))},Math.min(this.#i,1e4));let t=this.#n;"object"==typeof t&&"function"==typeof t.unref&&t.unref()}}
+const DEFAULT_PER_DID_LIMIT = 3;
+const DEFAULT_GLOBAL_LIMIT = 20;
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class TransactionManager {
+    #getRandomID;
+    #globalLimit;
+    #perDIDLimit;
+    #timeoutMS;
+    #transactions = new Map();
+    #sweepInterval = null;
+    constructor(options){
+        this.#getRandomID = options.getRandomID;
+        this.#globalLimit = options.globalLimit ?? DEFAULT_GLOBAL_LIMIT;
+        this.#perDIDLimit = options.perDIDLimit ?? DEFAULT_PER_DID_LIMIT;
+        this.#timeoutMS = options.timeoutMS ?? DEFAULT_TIMEOUT_MS;
+        this.#startTimeoutSweep();
+    }
+    beginTransaction(callerDID, graphID) {
+        if (this.#transactions.size >= this.#globalLimit) {
+            throw new Error(`Global transaction limit reached (${this.#globalLimit}). Cannot create new transaction.`);
+        }
+        let didCount = 0;
+        for (const ctx of this.#transactions.values()){
+            if (ctx.callerDID === callerDID) {
+                didCount++;
+            }
+        }
+        if (didCount >= this.#perDIDLimit) {
+            throw new Error(`Per-DID transaction limit reached (${this.#perDIDLimit}) for ${callerDID}. Cannot create new transaction.`);
+        }
+        const ctx = {
+            id: this.#getRandomID(),
+            callerDID,
+            graphID,
+            mutations: [],
+            createdAt: Date.now(),
+            status: 'open'
+        };
+        this.#transactions.set(ctx.id, ctx);
+        return ctx;
+    }
+    getTransaction(transactionID) {
+        const ctx = this.#transactions.get(transactionID);
+        if (ctx == null) {
+            return null;
+        }
+        // Lazy timeout check
+        if (Date.now() - ctx.createdAt > this.#timeoutMS) {
+            ctx.status = 'rolledBack';
+            this.#transactions.delete(transactionID);
+            return null;
+        }
+        return ctx;
+    }
+    rollbackTransaction(transactionID) {
+        const ctx = this.#transactions.get(transactionID);
+        if (ctx == null) {
+            throw new Error(`Transaction not found: ${transactionID}`);
+        }
+        if (ctx.status === 'committed') {
+            throw new Error(`Cannot rollback committed transaction: ${transactionID}`);
+        }
+        ctx.status = 'rolledBack';
+        this.#transactions.delete(transactionID);
+    }
+    markCommitted(transactionID) {
+        const ctx = this.#transactions.get(transactionID);
+        if (ctx == null) {
+            return;
+        }
+        ctx.status = 'committed';
+        this.#transactions.delete(transactionID);
+    }
+    dispose() {
+        // Rollback all active transactions
+        for (const [_id, ctx] of this.#transactions){
+            if (ctx.status === 'open' || ctx.status === 'committing') {
+                ctx.status = 'rolledBack';
+            }
+        }
+        this.#transactions.clear();
+        if (this.#sweepInterval != null) {
+            clearInterval(this.#sweepInterval);
+            this.#sweepInterval = null;
+        }
+    }
+    #startTimeoutSweep() {
+        this.#sweepInterval = setInterval(()=>{
+            const now = Date.now();
+            for (const [id, ctx] of this.#transactions){
+                if (now - ctx.createdAt > this.#timeoutMS) {
+                    ctx.status = 'rolledBack';
+                    this.#transactions.delete(id);
+                }
+            }
+        }, Math.min(this.#timeoutMS, 10_000));
+        // Allow the process to exit even if the interval is running.
+        // In Node.js, setInterval returns an object with unref(); in browsers it returns a number.
+        const interval = this.#sweepInterval;
+        if (typeof interval === 'object' && typeof interval.unref === 'function') {
+            ;
+            interval.unref();
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-rpc",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "type": "module",
   "main": "lib/index.js",
@@ -14,30 +14,31 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/generator": "^0.16.0",
-    "@enkaku/runtime": "^0.16.0",
-    "@enkaku/server": "^0.16.0",
-    "@enkaku/token": "^0.16.0",
-    "graphql": "^16.13.2",
-    "@kubun/db": "^0.10.0",
-    "@kubun/hlc": "^0.10.0",
-    "@kubun/graphql": "^0.10.0",
-    "@kubun/mutation": "^0.10.0",
-    "@kubun/protocol": "^0.10.0",
-    "@kubun/engine": "^0.10.0"
+    "@sozai/generator": "^0.1.0",
+    "@sozai/runtime": "^0.1.0",
+    "@enkaku/server": "^0.18.1",
+    "@kokuin/token": "^0.1.1",
+    "graphql": "^16.14.2",
+    "@kubun/db": "^0.11.0",
+    "@kubun/graphql": "^0.11.0",
+    "@kubun/engine": "^0.11.0",
+    "@kubun/mutation": "^0.11.0",
+    "@kubun/hlc": "^0.11.0",
+    "@kubun/protocol": "^0.11.0"
   },
   "devDependencies": {
-    "@enkaku/capability": "^0.16.0",
-    "@enkaku/transport": "^0.16.0",
-    "@kubun/client": "^0.10.0",
-    "@kubun/id": "^0.10.0",
-    "@kubun/store-graph": "^0.10.0",
-    "@kubun/store-p2p": "^0.10.0",
-    "@kubun/test-utils": "^0.10.0"
+    "@kokuin/capability": "^0.1.0",
+    "@enkaku/transport": "^0.18.1",
+    "@kubun/client": "^0.11.0",
+    "@kubun/store-graph": "^0.11.0",
+    "@kubun/store-delegation": "^0.11.0",
+    "@kubun/id": "^0.11.0",
+    "@kubun/store-p2p": "^0.11.0",
+    "@kubun/test-utils": "^0.11.0"
   },
   "scripts": {
     "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": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "test:types": "tsc --noEmit -p tsconfig.test.json",