@kubun/service-graph-api 0.14.0

package/LICENSE.md

@@ -0,0 +1,57 @@
+# The Prosperity Public License 3.0.0
+
+Contributor: Paul Le Cam
+
+Source Code: https://github.com/PaulLeCam/kubun
+
+## Purpose
+
+This license allows you to use and share this software for noncommercial purposes for free and to try this software for commercial purposes for thirty days.
+
+## Agreement
+
+In order to receive this license, you have to agree to its rules.  Those rules are both obligations under that agreement and conditions to your license.  Don't do anything with this software that triggers a rule you can't or won't follow.
+
+## Notices
+
+Make sure everyone who gets a copy of any part of this software from you, with or without changes, also gets the text of this license and the contributor and source code lines above.
+
+## Commercial Trial
+
+Limit your use of this software for commercial purposes to a thirty-day trial period.  If you use this software for work, your company gets one trial period for all personnel, not one trial per person.
+
+## Contributions Back
+
+Developing feedback, changes, or additions that you contribute back to the contributor on the terms of a standardized public software license such as [the Blue Oak Model License 1.0.0](https://blueoakcouncil.org/license/1.0.0), [the Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html), [the MIT license](https://spdx.org/licenses/MIT.html), or [the two-clause BSD license](https://spdx.org/licenses/BSD-2-Clause.html) doesn't count as use for a commercial purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, doesn't count as use for a commercial purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution doesn't count as use for a commercial purpose regardless of the source of funding or obligations resulting from the funding.
+
+## Defense
+
+Don't make any legal claim against anyone accusing this software, with or without changes, alone or with other technology, of infringing any patent.
+
+## Copyright
+
+The contributor licenses you to do everything with this software that would otherwise infringe their copyright in it.
+
+## Patent
+
+The contributor licenses you to do everything with this software that would otherwise infringe any patents they can license or become able to license.
+
+## Reliability
+
+The contributor can't revoke this license.
+
+## Excuse
+
+You're excused for unknowingly breaking [Notices](#notices) if you take all practical steps to comply within thirty days of learning you broke the rule.
+
+## No Liability
+
+***As far as the law allows, this software comes as is, without any warranty or condition, and the contributor won't be liable to anyone for any damages related to this software or this license, under any kind of legal claim.***

package/lib/handlers.d.ts

@@ -0,0 +1,18 @@
+import type { ProcedureHandlers } from '@enkaku/server';
+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;
+    defaultDID: string;
+    engine: Engine;
+    getRandomValues: GetRandomValues;
+    graph: GraphInternals;
+    hlc: HLC;
+    signingIdentity: SigningIdentity | null;
+    transactionManager: TransactionManager;
+};
+export declare function createGraphHandlers(params: CreateHandlersParams): ProcedureHandlers<GraphProtocol>;

package/lib/handlers.js

@@ -0,0 +1,329 @@
+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,
+                search: ctx.param.search
+            });
+        },
+        '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.d.ts

@@ -0,0 +1,26 @@
+import type { KubunPlugin, PluginFactoryParams } from '@kubun/engine';
+import type { AccessRules } from '@kubun/plugin-service-api';
+import type { TransactionManagerOptions } from './transaction-manager.js';
+export type { GraphProtocol } from '@kubun/protocol';
+export type { CreateHandlersParams } from './handlers.js';
+export { createGraphHandlers } from './handlers.js';
+export type { TransactionManagerOptions } from './transaction-manager.js';
+export { TransactionManager } from './transaction-manager.js';
+export type GraphServicePluginOptions = {
+    /** Allow the engine to sign mutations on behalf of clients (delegated mode). Default: false. */
+    allowDelegatedMutations?: boolean;
+    /** Configuration for the transaction manager. */
+    transactionConfig?: TransactionManagerOptions;
+    /** Default access rules for the registered provider. Default: `{}` (server-only). */
+    accessRules?: AccessRules;
+};
+/**
+ * Creates the graph service plugin.
+ *
+ * Registers the `graph/*` handlers as a `service` provider named `graph`, so the
+ * service host serves them over a transport. Graph auth is unchanged: each handler
+ * resolves its viewer from the verified signed-message `iss` itself and never
+ * consults the host authorizer, so the provider's default access rules are empty
+ * (server-only) unless a host grants procedures per serve.
+ */
+export declare function createGraphServicePlugin(options?: GraphServicePluginOptions): (params: PluginFactoryParams) => KubunPlugin;

package/lib/index.js

@@ -0,0 +1,51 @@
+// The graph service: the `graph/*` Enkaku procedures registered as a `service`
+// provider so the service host can serve them over a transport, plus the handler
+// and transaction-manager building blocks the RPC plugin still composes directly.
+// The wire contract itself lives in `@kubun/protocol` and is re-exported here.
+import { isSigningIdentity } from '@kokuin/token';
+import { createGraphHandlers } from './handlers.js';
+import { TransactionManager } from './transaction-manager.js';
+export { createGraphHandlers } from './handlers.js';
+export { TransactionManager } from './transaction-manager.js';
+// The service name the provider registers under and the host toggles via `services`.
+const GRAPH_SERVICE_NAME = 'graph';
+/**
+ * Creates the graph service plugin.
+ *
+ * Registers the `graph/*` handlers as a `service` provider named `graph`, so the
+ * service host serves them over a transport. Graph auth is unchanged: each handler
+ * resolves its viewer from the verified signed-message `iss` itself and never
+ * consults the host authorizer, so the provider's default access rules are empty
+ * (server-only) unless a host grants procedures per serve.
+ */ export function createGraphServicePlugin(options) {
+    return (params)=>{
+        const signer = isSigningIdentity(params.identity) ? params.identity : null;
+        const transactionManager = new TransactionManager({
+            runtime: params.runtime,
+            ...options?.transactionConfig
+        });
+        const handlers = createGraphHandlers({
+            allowDelegatedMutations: options?.allowDelegatedMutations ?? false,
+            defaultDID: params.identity.id,
+            engine: params.engine,
+            getRandomValues: params.runtime.getRandomValues,
+            graph: params.graph,
+            hlc: params.hlc,
+            signingIdentity: signer,
+            transactionManager
+        });
+        params.registerProvider('service', {
+            name: GRAPH_SERVICE_NAME,
+            // The typed `ProcedureHandlers<GraphProtocol>` narrows to the host's
+            // structural `Handlers` at this one seam, mirroring the host's serve cast.
+            handlers: handlers,
+            accessRules: options?.accessRules ?? {}
+        });
+        return {
+            name: 'graph-service',
+            dispose: async ()=>{
+                transactionManager.dispose();
+            }
+        };
+    };
+}

package/lib/transaction-manager.d.ts

@@ -0,0 +1,34 @@
+import type { DocumentMutation, DocumentNode } from '@kubun/protocol';
+import type { Runtime } from '@sozai/runtime';
+export type BufferedMutation = {
+    mutation: DocumentMutation;
+    jwt: string;
+    authorDID: string;
+    documentID: string;
+    result: DocumentNode;
+};
+export type TransactionStatus = 'open' | 'committing' | 'committed' | 'rolledBack';
+export type TransactionContext = {
+    id: string;
+    callerDID: string;
+    graphID: string;
+    mutations: Array<BufferedMutation>;
+    createdAt: number;
+    status: TransactionStatus;
+};
+export type TransactionManagerOptions = {
+    /** Host runtime, used to mint each transaction's id. */
+    runtime: Runtime;
+    perDIDLimit?: number;
+    globalLimit?: number;
+    timeoutMS?: number;
+};
+export declare class TransactionManager {
+    #private;
+    constructor(options: TransactionManagerOptions);
+    beginTransaction(callerDID: string, graphID: string): TransactionContext;
+    getTransaction(transactionID: string): TransactionContext | null;
+    rollbackTransaction(transactionID: string): void;
+    markCommitted(transactionID: string): void;
+    dispose(): void;
+}

package/lib/transaction-manager.js

@@ -0,0 +1,105 @@
+const DEFAULT_PER_DID_LIMIT = 3;
+const DEFAULT_GLOBAL_LIMIT = 20;
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class TransactionManager {
+    #runtime;
+    #globalLimit;
+    #perDIDLimit;
+    #timeoutMS;
+    #transactions = new Map();
+    #sweepInterval = null;
+    constructor(options){
+        this.#runtime = options.runtime;
+        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.#runtime.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

@@ -0,0 +1,57 @@
+{
+  "name": "@kubun/service-graph-api",
+  "version": "0.14.0",
+  "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/*",
+    "LICENSE.md"
+  ],
+  "dependencies": {
+    "@enkaku/server": "^0.21.2",
+    "@kokuin/token": "^0.5.0",
+    "@kubun/engine": "^0.14.0",
+    "@kubun/hlc": "^0.14.0",
+    "@kubun/id": "^0.14.0",
+    "@kubun/mutation": "^0.14.0",
+    "@kubun/plugin-service-api": "^0.14.0",
+    "@kubun/protocol": "^0.14.0",
+    "@sozai/generator": "^0.2.0",
+    "@sozai/runtime": "^0.1.0",
+    "graphql": "^16.14.2"
+  },
+  "devDependencies": {
+    "@enkaku/client": "^0.21.0",
+    "@enkaku/transport": "^0.21.0",
+    "@kokuin/capability": "^0.3.0",
+    "@kokuin/controller": "^0.1.0",
+    "@kubun/client": "^0.14.0",
+    "@kubun/db": "^0.14.0",
+    "@kubun/plugin-service-server": "^0.14.0",
+    "@kubun/store-controller": "^0.14.0",
+    "@kubun/store-delegation": "^0.14.0",
+    "@kubun/store-graph": "^0.14.0",
+    "@kubun/store-p2p": "^0.14.0",
+    "@kubun/test-utils": "^0.13.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "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 ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
+    "test": "pnpm run test:types && pnpm run test:unit",
+    "test:types": "tsc --noEmit -p tsconfig.test.json",
+    "test:unit": "vitest run"
+  }
+}