@astrale-os/kernel-server 0.5.0-beta.63 → 0.5.0-beta.64

package/dist/errors/admission.d.ts

@@ -0,0 +1,7 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+/** Advisory delay before a request the Server did not admit is sent again. */
+export declare const ADMISSION_RETRY_AFTER_MS = 1000;
+/** Public refusal of an operation the Server did not admit; nothing ran. */
+export declare function admissionRefusal(accepting: boolean): errors.ErrorPayload;
+/** HTTP presentation of a public error's retry delay, when it has one. */
+export declare function retryAfterHeaders(error: errors.ErrorPayload): Readonly<Record<string, string>>;

package/dist/errors/admission.js

@@ -0,0 +1,22 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+/** Advisory delay before a request the Server did not admit is sent again. */
+export const ADMISSION_RETRY_AFTER_MS = 1_000;
+/** Public refusal of an operation the Server did not admit; nothing ran. */
+export function admissionRefusal(accepting) {
+    return accepting
+        ? {
+            code: errors.CODES.BACKEND_UNAVAILABLE,
+            message: 'Server is at capacity; retry later.',
+            data: errors.retryReason(errors.RETRY_REASONS.CAPACITY_EXHAUSTED, ADMISSION_RETRY_AFTER_MS),
+        }
+        : {
+            code: errors.CODES.BACKEND_UNAVAILABLE,
+            message: 'Server is draining; retry later.',
+            data: errors.retryReason(errors.RETRY_REASONS.SERVER_DRAINING, ADMISSION_RETRY_AFTER_MS),
+        };
+}
+/** HTTP presentation of a public error's retry delay, when it has one. */
+export function retryAfterHeaders(error) {
+    const retryAfterMs = errors.retryAfterOf(error);
+    return retryAfterMs === undefined ? {} : { 'retry-after': errors.retryAfterField(retryAfterMs) };
+}

package/dist/errors/index.d.ts

@@ -1,3 +1,4 @@
+export { ADMISSION_RETRY_AFTER_MS, admissionRefusal, retryAfterHeaders } from './admission.js';
 export { DeliveryUnavailableError, IssuerKeysUnavailableError } from './availability.js';
 export { classifyError } from './classify.js';
 export { RequestBodyInvalidError, RequestBodyTooLargeError } from './request-body.js';

package/dist/errors/index.js

@@ -1,3 +1,4 @@
+export { ADMISSION_RETRY_AFTER_MS, admissionRefusal, retryAfterHeaders } from './admission.js';
 export { DeliveryUnavailableError, IssuerKeysUnavailableError } from './availability.js';
 export { classifyError } from './classify.js';
 export { RequestBodyInvalidError, RequestBodyTooLargeError } from './request-body.js';

package/dist/issuer/exchange.js

@@ -2,6 +2,7 @@ import { inspect as inspectCredential } from '@astrale-os/kernel-core/auth/crede
 import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as exchangeProtocol from '@astrale-os/kernel-protocol/issuer/exchange';
 import { paths as issuerPaths } from '@astrale-os/kernel-protocol/issuer/paths';
+import { admissionRefusal, retryAfterHeaders } from '../errors/index.js';
 const PROVIDER_CODES = new Set([
     errors.CODES.AUTH_INVALID,
     errors.CODES.AUTH_EXPIRED,
@@ -24,7 +25,10 @@ export function mount(app, issuer, provider, cors, active, timeoutMs) {
     }
     app.all(path, async (context) => {
         const request = context.req.raw;
-        const respond = (payload, extra) => json(payload, errors.httpStatusOf(payload.error), request, cors, extra);
+        const respond = (payload, extra) => json(payload, errors.httpStatusOf(payload.error), request, cors, {
+            ...retryAfterHeaders(payload.error),
+            ...extra,
+        });
         let admitted;
         try {
             admitted = exchangeProtocol.acceptHttpRequest({
@@ -40,12 +44,9 @@ export function mount(app, issuer, provider, cors, active, timeoutMs) {
             }
             throw cause;
         }
-        if (!active.isAccepting) {
-            return respond(error('BACKEND_UNAVAILABLE', 'Token exchange is unavailable.'));
-        }
         const operation = active.begin(timeoutMs, request.signal);
         if (operation === undefined) {
-            return respond(error('LIMIT_EXCEEDED', 'Token-exchange limit exceeded.'));
+            return respond(exchangeProtocol.acceptErrorResponse({ error: admissionRefusal(active.isAccepting) }));
         }
         try {
             try {
@@ -134,12 +135,13 @@ function error(code, message) {
     });
 }
 function json(value, status, request, cors, extra) {
+    const additional = new Headers(extra);
     const headers = new Headers(exchangeProtocol.responseHeaders());
-    for (const [name, value] of Object.entries(cors.response(request)))
+    const exposed = additional.has('retry-after') ? ['retry-after'] : [];
+    for (const [name, value] of Object.entries(cors.response(request, exposed))) {
         headers.set(name, value);
-    if (extra !== undefined) {
-        for (const [name, value] of new Headers(extra))
-            headers.set(name, value);
     }
+    for (const [name, value] of additional)
+        headers.set(name, value);
     return new Response(JSON.stringify(value), { status, headers });
 }

package/dist/issuer/routes.js

@@ -2,7 +2,7 @@ import { configuration } from '@astrale-os/kernel-protocol/issuer/configuration'
 import { hosted } from '@astrale-os/kernel-protocol/issuer/hosted';
 import { keySet } from '@astrale-os/kernel-protocol/issuer/key-set';
 import { paths as issuerPaths } from '@astrale-os/kernel-protocol/issuer/paths';
-import { IssuerKeysUnavailableError } from '../errors/index.js';
+import { admissionRefusal, IssuerKeysUnavailableError, retryAfterHeaders } from '../errors/index.js';
 import { mount } from './exchange.js';
 export function issuerRouteReservations(input, tokenExchange = false) {
     const paths = issuerPaths(input.issuer);
@@ -32,6 +32,19 @@ export function mountIssuer(app, input, cors, active, timeoutMs, tokenExchange)
         ...cors.response(request),
         'cache-control': 'no-cache',
     });
+    // A lifecycle refusal names saturation or drain and presents its retry delay.
+    const refusal = (request) => {
+        const refused = admissionRefusal(active.isAccepting);
+        const retry = retryAfterHeaders(refused);
+        return {
+            body: { error: refused.message },
+            headers: {
+                ...cors.response(request, Object.keys(retry)),
+                'cache-control': 'no-cache',
+                ...retry,
+            },
+        };
+    };
     const algorithm = input.signingAlgorithm ?? 'ES256';
     const discovery = configuration(issuer, [algorithm], {
         tokenExchange: tokenExchange !== undefined,
@@ -44,7 +57,8 @@ export function mountIssuer(app, input, cors, active, timeoutMs, tokenExchange)
     app.get(paths.keys, async (context) => {
         const operation = active.begin(timeoutMs, context.req.raw.signal);
         if (operation === undefined) {
-            return context.json({ error: 'Issuer is unavailable while draining.' }, 503, headers(context.req.raw));
+            const refused = refusal(context.req.raw);
+            return context.json(refused.body, 503, refused.headers);
         }
         try {
             const keys = await input.loadPublicKeys(operation.signal);
@@ -76,7 +90,8 @@ export function mountIssuer(app, input, cors, active, timeoutMs, tokenExchange)
                 return context.json({ error: 'Issuer not found.' }, 404, headers(context.req.raw));
             const operation = active.begin(timeoutMs, context.req.raw.signal);
             if (operation === undefined) {
-                return context.json({ error: 'Issuer is unavailable while draining.' }, 503, headers(context.req.raw));
+                const refused = refusal(context.req.raw);
+                return context.json(refused.body, 503, refused.headers);
             }
             try {
                 const keys = await hostedKeys(loadIssuerPublicKeys, hostedIssuer, operation.signal, algorithm);
@@ -100,7 +115,8 @@ export function mountIssuer(app, input, cors, active, timeoutMs, tokenExchange)
                 return context.json({ error: 'Issuer not found.' }, 404, headers(context.req.raw));
             const operation = active.begin(timeoutMs, context.req.raw.signal);
             if (operation === undefined) {
-                return context.json({ error: 'Issuer is unavailable while draining.' }, 503, headers(context.req.raw));
+                const refused = refusal(context.req.raw);
+                return context.json(refused.body, 503, refused.headers);
             }
             try {
                 const keys = await hostedKeys(loadIssuerPublicKeys, hostedIssuer, operation.signal, algorithm);

package/dist/publication/delivery/handler.d.ts

@@ -6,4 +6,4 @@ export interface Limits {
     readonly invocationTimeoutMs: number;
 }
 /** Serve one delivery request against the exact Publication snapshot that selected its URL. */
-export declare function handleDelivery(request: Request, snapshot: PreparedPublicationSnapshot, provider: Provider | undefined, active: ActiveOperations, limits: Limits, cors: Readonly<Record<string, string>>): Promise<Response>;
+export declare function handleDelivery(request: Request, snapshot: PreparedPublicationSnapshot, provider: Provider | undefined, active: ActiveOperations, limits: Limits, corsFor: (exposedHeaders?: readonly string[]) => Readonly<Record<string, string>>): Promise<Response>;

package/dist/publication/delivery/handler.js

@@ -1,11 +1,12 @@
 import * as codecs from '@astrale-os/kernel-protocol/codecs';
 import * as protocolPublication from '@astrale-os/kernel-protocol/publication';
-import { DeliveryUnavailableError } from '../../errors/index.js';
+import { admissionRefusal, DeliveryUnavailableError, retryAfterHeaders, } from '../../errors/index.js';
 import { RequestBodyInvalidError, RequestBodyTooLargeError } from '../../errors/index.js';
 import { readBoundedBody } from '../../transport/index.js';
 const delivery = protocolPublication.delivery;
 /** Serve one delivery request against the exact Publication snapshot that selected its URL. */
-export async function handleDelivery(request, snapshot, provider, active, limits, cors) {
+export async function handleDelivery(request, snapshot, provider, active, limits, corsFor) {
+    const cors = corsFor();
     if (request.method !== 'POST') {
         return response({ error: 'Delivery requires POST.' }, 405, cors);
     }
@@ -17,8 +18,11 @@ export async function handleDelivery(request, snapshot, provider, active, limits
         return response({ error: 'Delivery is unavailable.' }, 404, cors);
     }
     const operation = active.begin(limits.invocationTimeoutMs, request.signal);
-    if (operation === undefined)
-        return response({ error: 'Server is draining.' }, 503, cors);
+    if (operation === undefined) {
+        const refusal = admissionRefusal(active.isAccepting);
+        const retry = retryAfterHeaders(refusal);
+        return response({ error: refusal.message }, 503, { ...corsFor(Object.keys(retry)), ...retry });
+    }
     try {
         const authorization = request.headers.get('authorization');
         const token = bearer(authorization);

package/dist/routes/routes.js

@@ -5,7 +5,7 @@ import { bundleUrl } from '@astrale-os/kernel-protocol/publication';
 import { mediaType as publicationMediaType, PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
 import { reference as publicationReference } from '@astrale-os/kernel-protocol/publication/reference';
 import * as routes from '@astrale-os/kernel-protocol/routes';
-import { classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../errors/index.js';
+import { admissionRefusal, classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, retryAfterHeaders, } from '../errors/index.js';
 import { invocationContext } from '../invocation/index.js';
 import { handleDelivery } from '../publication/delivery/index.js';
 import { readPreparedPublicationSnapshot, } from '../publication/index.js';
@@ -25,8 +25,9 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
     }
     app.get(publicationPath, (context) => {
         const responseCors = cors.response(context.req.raw, ['etag']);
-        if (!active.isAccepting)
-            return response({ error: 'Publication is unavailable while draining.' }, 503, responseCors);
+        if (!active.isAccepting) {
+            return drained('Publication is unavailable while draining.', (exposed) => cors.response(context.req.raw, exposed));
+        }
         const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer, externalOrigin);
         if (snapshot === undefined)
             return response({ error: 'Publication is not ready.' }, 503, responseCors);
@@ -60,12 +61,13 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
             return publicationPreflight(cors, request, snapshot, externalOrigin);
         }
         const responseCors = cors.response(request);
+        const corsFor = (exposed) => cors.response(request, exposed);
         const descriptor = snapshot.publication.schema.bundle;
         const addressed = bundleUrl(snapshot.publication.identity.issuer, descriptor.ref);
         const immutable = descriptor.href === addressed;
         if (sameRoute(request.url, snapshot.publication.schema.bundle.href, externalOrigin)) {
             if (!active.isAccepting)
-                return response({ error: 'Publication artifact is unavailable while draining.' }, 503, responseCors);
+                return drained('Publication artifact is unavailable while draining.', corsFor);
             if (request.method !== 'GET')
                 return response({ error: 'Bundle retrieval requires GET.' }, 405, responseCors);
             const body = snapshot.bundle;
@@ -100,7 +102,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
         }
         const deliveryUrl = snapshot.publication.delivery?.href;
         if (deliveryUrl !== undefined && sameRoute(request.url, deliveryUrl, externalOrigin)) {
-            return handleDelivery(request, snapshot, deliveryProvider, active, limits, cors.response(request));
+            return handleDelivery(request, snapshot, deliveryProvider, active, limits, corsFor);
         }
         let routing;
         try {
@@ -120,7 +122,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
         }
         catch (cause) {
             if (cause instanceof routes.RouteError) {
-                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Native route routing is invalid.' }, 400, responseCors);
+                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Native route routing is invalid.' }, 400, corsFor);
             }
             throw cause;
         }
@@ -130,10 +132,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
         const assigned = nextInvocation();
         const operation = active.begin(limits.invocationTimeoutMs, request.signal);
         if (operation === undefined)
-            return nativeError({
-                code: errors.CODES.BACKEND_UNAVAILABLE,
-                message: 'Server is draining.',
-            }, 503, responseCors);
+            return nativeError(admissionRefusal(active.isAccepting), 503, corsFor);
         let handedOff = false;
         try {
             const body = await readBoundedBody(request, limits.maximumRequestBytes, operation.signal);
@@ -178,7 +177,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
             }
             if (result.kind === 'stream') {
                 handedOff = true;
-                return await streamResponse(result.stream, operation, responseCors);
+                return await streamResponse(result.stream, operation, corsFor);
             }
             if (result.kind === 'miss') {
                 return new Response(null, {
@@ -192,29 +191,29 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
             return nativeError({
                 code: errors.CODES.UNSUPPORTED,
                 message: 'Native routes do not forward Runtime redirects.',
-            }, 502, responseCors);
+            }, 502, corsFor);
         }
         catch (cause) {
             if (cause instanceof RequestBodyTooLargeError) {
-                return nativeError({ code: errors.CODES.LIMIT_EXCEEDED, message: 'Request body is too large.' }, 413, responseCors);
+                return nativeError({ code: errors.CODES.LIMIT_EXCEEDED, message: 'Request body is too large.' }, 413, corsFor);
             }
             if (cause instanceof RequestBodyInvalidError) {
-                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Request body is invalid.' }, 400, responseCors);
+                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Request body is invalid.' }, 400, corsFor);
             }
             if (cause instanceof routes.RouteError) {
-                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Native route request is invalid.' }, 400, responseCors);
+                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Native route request is invalid.' }, 400, corsFor);
             }
             if (operation.timedOut) {
                 return nativeError({
                     code: errors.CODES.DEADLINE_EXCEEDED,
                     message: 'Invocation deadline exceeded.',
-                }, 504, responseCors);
+                }, 504, corsFor);
             }
             if (operation.signal.aborted) {
-                return nativeError({ code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }, 408, responseCors);
+                return nativeError({ code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }, 408, corsFor);
             }
             const payload = classifyError(cause);
-            return nativeError(payload, errors.httpStatusOf(payload), responseCors);
+            return nativeError(payload, errors.httpStatusOf(payload), corsFor);
         }
         finally {
             if (!handedOff)
@@ -404,7 +403,7 @@ async function streamResponse(stream, operation, cors) {
     if (operation.signal.aborted) {
         void cancelSetup('native stream setup cancelled');
         const payload = preStreamError(operation.signal.reason, operation);
-        return response({ error: payload }, errors.httpStatusOf(payload), cors);
+        return response({ error: payload }, errors.httpStatusOf(payload), cors());
     }
     const encoder = new TextEncoder();
     let pending = first;
@@ -482,7 +481,7 @@ async function streamResponse(stream, operation, cors) {
     operation.onCancel((reason) => stop(reason, interruptedStreamError(operation.timedOut)));
     return new Response(body, {
         headers: {
-            ...cors,
+            ...cors(),
             'content-type': routes.STREAM_MEDIA_TYPE,
             'cache-control': 'no-cache',
         },
@@ -529,9 +528,16 @@ function response(body, status, cors) {
         headers: { ...cors, 'content-type': 'application/json' },
     });
 }
+/** A Publication artifact refused while draining presents the lifecycle retry delay. */
+function drained(message, cors) {
+    const retry = retryAfterHeaders(admissionRefusal(false));
+    return response({ error: message }, 503, { ...cors(Object.keys(retry)), ...retry });
+}
+/** Every native error, including a capacity refusal raised by dispatch, presents its retry delay. */
 function nativeError(error, status, cors) {
     const admitted = routes.decodeErrorResponse({ error });
-    return response(admitted, status, cors);
+    const retry = retryAfterHeaders(error);
+    return response(admitted, status, { ...cors(Object.keys(retry)), ...retry });
 }
 function encodedBody(input) {
     return typeof input === 'string' ? input : toBody(input);

package/dist/transport/http/handler.js

@@ -1,7 +1,7 @@
 import * as codecs from '@astrale-os/kernel-protocol/codecs';
 import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
-import { classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../../errors/index.js';
+import { admissionRefusal, classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../../errors/index.js';
 import { invocationContext, publicationRouteDecision, } from '../../invocation/index.js';
 import { readBoundedBody } from '../body.js';
 import { loadCodecs } from '../codecs.js';
@@ -47,10 +47,10 @@ export function createHttpHandler(config) {
             if (binaryRequest && request.body !== null && !request.body.locked) {
                 void request.body.cancel('binary request rejected').catch(() => undefined);
             }
-            return renderError(null, {
-                code: errors.CODES.BACKEND_UNAVAILABLE,
-                message: 'server is unavailable.',
-            }, codecs.json, { status: 503, negotiated: false });
+            return renderError(null, admissionRefusal(config.active.isAccepting), codecs.json, {
+                status: 503,
+                negotiated: false,
+            });
         }
         let handedOff = false;
         let binary;

package/dist/transport/http/render.js

@@ -1,7 +1,7 @@
 import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { HTTP_ROUTE_MISS, HTTP_ROUTE_STALE } from '@astrale-os/kernel-protocol/routes/routing';
-import { classifyError } from '../../errors/index.js';
+import { classifyError, retryAfterHeaders } from '../../errors/index.js';
 import { ResponseBodyTooLargeError } from '../../errors/index.js';
 import { interruptedStreamError } from '../stream-error.js';
 export function renderHttpResult(result, context) {
@@ -57,8 +57,9 @@ export function renderRedirect(requestId, invocation, redirect) {
 }
 export function renderHttpError(requestId, invocation, error, codec, cors, options = {}) {
     const status = options.status ?? errors.httpStatusOf(error);
-    const extra = status === 401 ? { 'www-authenticate': 'Bearer realm="astrale-invocation"' } : {};
-    return errorEnvelopeResponse(codec, { error, requestId, invocation }, { ...cors(), ...extra }, status, options.negotiated ?? true, options.maximumResponseBytes);
+    const retry = retryAfterHeaders(error);
+    const extra = status === 401 ? { 'www-authenticate': 'Bearer realm="astrale-invocation"' } : retry;
+    return errorEnvelopeResponse(codec, { error, requestId, invocation }, { ...cors(Object.keys(retry)), ...extra }, status, options.negotiated ?? true, options.maximumResponseBytes);
 }
 export function renderHttpStale(requestId, invocation, current, codec, cors, maximumResponseBytes) {
     return envelopeResponse(codec, protocol.stale(requestId, invocation, current), cors(), 200, true, maximumResponseBytes);

package/dist/transport/websocket/session.js

@@ -1,6 +1,6 @@
 import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
-import { classifyError } from '../../errors/index.js';
+import { admissionRefusal, classifyError } from '../../errors/index.js';
 import { ResponseBodyTooLargeError } from '../../errors/index.js';
 import { invocationContext, publicationRouteDecision, } from '../../invocation/index.js';
 import { byteLength } from '../body.js';
@@ -129,10 +129,7 @@ export function createWebSocketSession(config) {
             }
             const operation = config.active.begin(config.invocationTimeoutMs);
             if (operation === undefined) {
-                await sendError(socket, admittedCodec, envelope.requestId, assigned, {
-                    code: errors.CODES.BACKEND_UNAVAILABLE,
-                    message: 'server is unavailable.',
-                }, sendOutput);
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, admissionRefusal(config.active.isAccepting), sendOutput);
                 return;
             }
             operations.set(key, operation);

package/dist/transport/websocket/upgrade.js

@@ -1,12 +1,15 @@
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { admissionRefusal, retryAfterHeaders } from '../../errors/index.js';
 import { loadCodecs } from '../codecs.js';
 import { createWebSocketSession } from './session.js';
 export async function handleWebSocketUpgrade(config) {
     if (!config.cors.allowsBrowserOrigin(config.request))
         return failure(403);
     const operation = config.active.begin(config.invocationTimeoutMs, config.request.signal);
-    if (operation === undefined)
-        return failure(503, config.cors.response(config.request));
+    if (operation === undefined) {
+        const retry = retryAfterHeaders(admissionRefusal(config.active.isAccepting));
+        return failure(503, { ...config.cors.response(config.request, Object.keys(retry)), ...retry });
+    }
     try {
         const supported = await loadCodecs();
         const selection = protocol.websocket.selectSubprotocol(config.request.headers.get('sec-websocket-protocol'), supported);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-server",
-  "version": "0.5.0-beta.63",
+  "version": "0.5.0-beta.64",
   "description": "Portable HTTP and WebSocket boundary for Astrale invocation, publication, installation, and issuer protocols",
   "license": "Apache-2.0",
   "repository": {
@@ -33,9 +33,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "0.9.0-beta.55",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.40",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.61",
+    "@astrale-os/kernel-core": "0.9.0-beta.56",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.41",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.62",
     "hono": "^4.6.20",
     "msgpackr": "^2.0.5"
   },