alemonjs 2.1.91 → 2.1.93

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIdED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/bin/publish.js

@@ -2,7 +2,8 @@
 import fs from 'fs';
 import { join } from 'path';
 import os from 'os';
-import { execSync, spawnSync } from 'child_process';
+import { execSync } from 'child_process';
+import spawn from 'cross-spawn';
 
 const RELEASE_TYPES = new Set(['patch', 'minor', 'major', 'prepatch', 'preminor', 'premajor', 'prerelease']);
 const PRERELEASE_IDS = new Set(['alpha', 'beta', 'rc', 'next']);
@@ -24,7 +25,7 @@ function readPackageJson() {
 }
 
 function runCommand(command, args, options = {}) {
-  const result = spawnSync(command, args, {
+  const result = spawn.sync(command, args, {
     cwd: process.cwd(),
     stdio: 'inherit',
     shell: false,
@@ -49,7 +50,7 @@ function getCommandOutput(command) {
 }
 
 function hasCommand(command) {
-  const result = spawnSync(command, ['--version'], {
+  const result = spawn.sync(command, ['--version'], {
     cwd: process.cwd(),
     stdio: 'ignore'
   });
@@ -293,7 +294,7 @@ function getLatestReleaseVersion() {
 }
 
 function remoteBranchExists(branch) {
-  const result = spawnSync('git', ['ls-remote', '--exit-code', '--heads', 'origin', branch], {
+  const result = spawn.sync('git', ['ls-remote', '--exit-code', '--heads', 'origin', branch], {
     cwd: process.cwd(),
     stdio: 'ignore'
   });
@@ -302,7 +303,7 @@ function remoteBranchExists(branch) {
 }
 
 function localBranchExists(branch) {
-  const result = spawnSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+  const result = spawn.sync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
     cwd: process.cwd(),
     stdio: 'ignore'
   });
@@ -330,7 +331,7 @@ function cleanupWorktree(worktreeDir) {
     return;
   }
 
-  spawnSync('git', ['worktree', 'remove', '--force', worktreeDir], {
+  spawn.sync('git', ['worktree', 'remove', '--force', worktreeDir], {
     cwd: process.cwd(),
     stdio: 'ignore'
   });
@@ -428,7 +429,7 @@ export async function publish(release, options = {}) {
     copyDirContents(publishDir, worktreeDir);
 
     runCommand('git', ['-C', worktreeDir, 'add', '-A']);
-    const hasChanges = spawnSync('git', ['-C', worktreeDir, 'diff', '--cached', '--quiet']).status !== 0;
+    const hasChanges = spawn.sync('git', ['-C', worktreeDir, 'diff', '--cached', '--quiet']).status !== 0;
     if (!hasChanges) {
       console.log('release 分支无文件变化，跳过提交');
     } else {

package/lib/application/context.d.ts

@@ -0,0 +1,40 @@
+import type { EventKeys, Events } from '../types/index.js';
+type ContextState = Record<string, unknown>;
+export type ContextAction<T = unknown> = {
+    readonly payload: T;
+    readonly signal: AbortSignal;
+    pass: () => void;
+    close: () => void;
+};
+export type ContextHandler<S extends ContextState, T = unknown> = (event: Events[EventKeys], state: S, action: ContextAction<T>) => void | Promise<void>;
+type ContextConfig<S extends ContextState, R extends Record<string, ContextHandler<S, any>>> = {
+    name: string;
+    events: readonly EventKeys[];
+    scope: readonly string[];
+    conflict?: 'replace' | 'reject';
+    onError?: 'close' | 'keep';
+    expiresIn?: number | string;
+    initialState: S | ((payload: unknown) => S);
+    handlers: R;
+};
+export type Context = {
+    name: string;
+    [handler: string]: unknown;
+};
+export type ContextConfiguration = {
+    contexts: Record<string, Context>;
+};
+export type ContextPhase = 'middleware' | 'response';
+export declare const configureContext: (config: ContextConfiguration) => ContextConfiguration;
+export declare const createContext: <S extends ContextState, R extends Record<string, ContextHandler<S, any>>>(config: ContextConfig<S, R>) => {
+    name: string;
+    cancel: () => boolean;
+} & { [K in keyof R]: (payload?: unknown) => void; };
+export declare const validateContextRegistration: (register?: {
+    middlewareContent?: ContextConfiguration;
+    responseContent?: ContextConfiguration;
+}) => void;
+export declare const expendContext: <T extends EventKeys>(event: Events[T], select: T, next: () => void, phase: ContextPhase) => Promise<boolean>;
+export declare const clearContexts: () => void;
+export declare const clearContextsByApp: (appName: string) => void;
+export {};

package/lib/application/context.js

@@ -0,0 +1,340 @@
+import { showErrorModule } from '../common/utils.js';
+import { withEventContext, finishCurrentTrace, getCurrentEvent, getCurrentAppName } from './runtime/hook-event-context.js';
+import { dispatchEventError } from './runtime/event-error.js';
+import { getChildrenApp } from './runtime/store.js';
+import { scheduleTimeout, scheduleCancel } from './runtime/schedule-store.js';
+import { clearActiveContexts, clearActiveContextsByApp, getActiveContextKeys, activeContexts, removeActiveContext, putActiveContext } from './runtime/context-registry.js';
+
+const contextQueues = new Map();
+let contextSequence = 0;
+const contextDefinitionSymbol = Symbol('alemonjs.contextDefinition');
+const contextDefinitionSymbolForContent = Symbol('alemonjs.contextDefinitionForContent');
+const parseExpiresIn = (value) => {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const match = /^(\d+)\s*(ms|s|m|h|d)?$/i.exec(value.trim());
+    if (!match) {
+        throw new Error(`Invalid context expiresIn: ${value}`);
+    }
+    const amount = Number(match[1]);
+    const unit = match[2]?.toLowerCase() ?? 'ms';
+    const factor = unit === 'd' ? 86_400_000 : unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : unit === 's' ? 1_000 : 1;
+    return amount * factor;
+};
+const cloneState = (state) => {
+    if (!state || typeof state !== 'object' || Array.isArray(state)) {
+        throw new Error('Context initialState must be an object');
+    }
+    try {
+        return globalThis.structuredClone(state);
+    }
+    catch {
+        throw new Error('Context initialState must be structured-cloneable');
+    }
+};
+const clonePayload = (payload) => {
+    try {
+        return globalThis.structuredClone(payload);
+    }
+    catch {
+        throw new Error('Context payload must be structured-cloneable');
+    }
+};
+const getScopeKey = (appName, definition, event) => {
+    const values = definition.scope.map(key => {
+        const value = event[key];
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+            throw new Error(`Invalid context scope value: ${key} must be a string, number or boolean`);
+        }
+        return [key, String(value)];
+    });
+    return JSON.stringify([appName, definition.name, values]);
+};
+const isExpired = (context, now = Date.now()) => context.expiresAt !== undefined && context.expiresAt <= now;
+const configureContext = (config) => {
+    const contexts = Object.values(config.contexts ?? {});
+    const names = new Set();
+    if (contexts.length === 0) {
+        throw new Error('configureContext requires at least one context');
+    }
+    for (const context of contexts) {
+        const definition = context[contextDefinitionSymbolForContent];
+        if (!definition) {
+            throw new Error('configureContext only accepts contexts created by createContext');
+        }
+        if (names.has(definition.name)) {
+            throw new Error(`Duplicate context name: ${definition.name}`);
+        }
+        names.add(definition.name);
+    }
+    return Object.freeze({
+        ...config,
+        contexts: Object.freeze({ ...config.contexts })
+    });
+};
+const createContext = (config) => {
+    if (!config.name) {
+        throw new Error('Context name is required');
+    }
+    if (config.events.length === 0) {
+        throw new Error(`Context events are required: ${config.name}`);
+    }
+    if (config.scope.length === 0) {
+        throw new Error(`Context scope is required: ${config.name}`);
+    }
+    if (Object.keys(config.handlers).length === 0) {
+        throw new Error(`Context handlers are required: ${config.name}`);
+    }
+    if (Object.prototype.hasOwnProperty.call(config.handlers, 'cancel')) {
+        throw new Error(`Context handler name is reserved: ${config.name}/cancel`);
+    }
+    const initialState = typeof config.initialState === 'function' ? config.initialState : cloneState(config.initialState);
+    const definition = {
+        name: config.name,
+        events: Object.freeze([...config.events]),
+        scope: Object.freeze([...config.scope]),
+        conflict: config.conflict ?? 'replace',
+        onError: config.onError ?? 'close',
+        expiresIn: parseExpiresIn(config.expiresIn),
+        initialState: payload => {
+            const state = typeof initialState === 'function' ? initialState(payload) : initialState;
+            return cloneState(state);
+        },
+        handlers: Object.freeze({ ...config.handlers })
+    };
+    const actions = Object.fromEntries(Object.keys(config.handlers).map(handler => [
+        handler,
+        (payload) => {
+            const action = { type: `${config.name}/${handler}`, payload };
+            Object.defineProperty(action, contextDefinitionSymbol, {
+                value: { definition, handler }
+            });
+            dispatchContext(action);
+        }
+    ]));
+    const context = {
+        name: config.name,
+        ...actions,
+        cancel: () => cancelContext(definition)
+    };
+    Object.defineProperty(context, contextDefinitionSymbolForContent, {
+        value: definition
+    });
+    return Object.freeze(context);
+};
+const getRegisteredContexts = (appName, phase) => {
+    const register = getChildrenApp(appName)?.register;
+    const content = phase === 'middleware' ? register?.middlewareContent : register?.responseContent;
+    return content ? Object.values(content.contexts) : [];
+};
+const getContextPhases = (appName, definition) => {
+    return ['middleware', 'response'].filter(phase => {
+        return getRegisteredContexts(appName, phase).some(context => context[contextDefinitionSymbolForContent] === definition);
+    });
+};
+const isRegistered = (appName, definition, phase) => {
+    const phases = getContextPhases(appName, definition);
+    return phase ? phases.includes(phase) : phases.length > 0;
+};
+const validateContextRegistration = (register) => {
+    const owners = new Map();
+    for (const phase of ['middleware', 'response']) {
+        const content = phase === 'middleware' ? register?.middlewareContent : register?.responseContent;
+        for (const context of (content ? Object.values(content.contexts) : [])) {
+            const definition = context[contextDefinitionSymbolForContent];
+            if (!definition) {
+                throw new Error('Context registration only accepts contexts created by createContext');
+            }
+            if (owners.has(definition)) {
+                throw new Error(`Context cannot be registered in multiple phases: ${definition.name}`);
+            }
+            owners.set(definition, phase);
+        }
+    }
+};
+const cancelContext = (definition) => {
+    const event = getCurrentEvent();
+    if (!event || typeof event !== 'object') {
+        throw new Error('Context actions must be called inside an event handler');
+    }
+    const appName = getCurrentAppName() ?? 'main';
+    const key = getScopeKey(appName, definition, event);
+    return removeActiveContext(key);
+};
+const dispatchContext = (action, event) => {
+    const internalAction = action;
+    const metadata = internalAction[contextDefinitionSymbol];
+    const definition = metadata?.definition;
+    if (!definition) {
+        throw new Error(`Invalid context action: ${action.type}`);
+    }
+    const handler = metadata.handler;
+    const currentEvent = getCurrentEvent();
+    if (!currentEvent || typeof currentEvent !== 'object') {
+        throw new Error('Context actions must be dispatched with an event or inside an event handler');
+    }
+    const appName = getCurrentAppName() ?? 'main';
+    const phases = getContextPhases(appName, definition);
+    if (phases.length === 0) {
+        throw new Error(`Context action is not registered for app: ${action.type}`);
+    }
+    if (phases.length > 1) {
+        throw new Error(`Context is registered in multiple phases: ${action.type}`);
+    }
+    const key = getScopeKey(appName, definition, currentEvent);
+    const previous = activeContexts.get(key);
+    if (previous && definition.conflict === 'reject') {
+        throw new Error(`Context is already active: ${action.type}`);
+    }
+    const now = Date.now();
+    const id = `${now.toString(36)}-${Math.random().toString(36).slice(2)}`;
+    const payload = clonePayload(action.payload);
+    const expiresAt = definition.expiresIn ? now + definition.expiresIn : undefined;
+    const controller = new AbortController();
+    let expirationTimerId;
+    const context = {
+        key,
+        id,
+        appName,
+        phase: phases[0],
+        events: definition.events,
+        definition,
+        handler,
+        payload,
+        state: definition.initialState(payload),
+        expiresAt,
+        createdAt: now,
+        order: ++contextSequence,
+        controller,
+        onRemove: () => {
+            controller.abort();
+            if (expirationTimerId) {
+                scheduleCancel(expirationTimerId);
+            }
+        }
+    };
+    if (definition.expiresIn) {
+        expirationTimerId = scheduleTimeout(() => {
+            removeActiveContext(key, id);
+        }, definition.expiresIn, appName);
+    }
+    putActiveContext(context);
+};
+const expendContext = async (event, select, next, phase) => {
+    const now = Date.now();
+    let current;
+    for (const key of getActiveContextKeys(select)) {
+        const context = activeContexts.get(key);
+        if (!context) {
+            continue;
+        }
+        if (context.phase !== phase) {
+            continue;
+        }
+        if (isExpired(context, now)) {
+            removeActiveContext(key, context.id);
+            continue;
+        }
+        if (!isRegistered(context.appName, context.definition, context.phase)) {
+            removeActiveContext(key, context.id);
+            continue;
+        }
+        let scopeKey;
+        try {
+            scopeKey = getScopeKey(context.appName, context.definition, event);
+        }
+        catch {
+            continue;
+        }
+        if (scopeKey === key && (!current || context.order > current.order)) {
+            current = context;
+        }
+    }
+    if (!current) {
+        next();
+        return false;
+    }
+    const key = current.key;
+    const previous = contextQueues.get(key) ?? Promise.resolve();
+    const run = previous
+        .catch(() => undefined)
+        .then(async () => {
+        const active = activeContexts.get(key);
+        if (!active) {
+            next();
+            return;
+        }
+        const handler = active.definition.handlers[active.handler];
+        if (!handler) {
+            removeActiveContext(active.key, active.id);
+            next();
+            return;
+        }
+        let shouldPass = false;
+        let shouldClose = false;
+        const control = {
+            payload: active.payload,
+            signal: active.controller.signal,
+            pass: () => {
+                shouldPass = true;
+            },
+            close: () => {
+                shouldClose = true;
+            }
+        };
+        try {
+            await withEventContext(event, () => control.pass(), () => handler(event, active.state, control), {
+                appName: active.appName,
+                phase: active.phase === 'middleware' ? 'middleware-content' : 'response-content'
+            });
+        }
+        catch (error) {
+            showErrorModule(error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Context handler failed'));
+            const shouldContinue = await dispatchEventError({
+                event,
+                error,
+                appName: active.appName,
+                phase: active.phase === 'middleware' ? 'middleware-content' : 'response-content'
+            });
+            if (active.definition.onError === 'close') {
+                removeActiveContext(active.key, active.id);
+            }
+            if (shouldContinue) {
+                next();
+                return;
+            }
+            finishCurrentTrace('error');
+            return;
+        }
+        if (shouldClose) {
+            removeActiveContext(active.key, active.id);
+        }
+        if (shouldPass) {
+            next();
+        }
+        else {
+            finishCurrentTrace('consumed');
+        }
+    })
+        .finally(() => {
+        if (contextQueues.get(key) === run) {
+            contextQueues.delete(key);
+        }
+    });
+    contextQueues.set(key, run);
+    await run;
+    return true;
+};
+const clearContexts = () => {
+    clearActiveContexts();
+    contextQueues.clear();
+};
+const clearContextsByApp = (appName) => {
+    clearActiveContextsByApp(appName);
+};
+
+export { clearContexts, clearContextsByApp, configureContext, createContext, expendContext, validateContextRegistration };

package/lib/application/index.d.ts

@@ -5,6 +5,8 @@ export { defineMiddleware } from './define-middleware.js';
 export { defineRouter, lazy, runHandler } from './define-router.js';
 export * from './expose.js';
 export * from './hooks/index.js';
+export { createContext, configureContext } from './context.js';
+export type { Context, ContextAction, ContextConfiguration, ContextHandler, ContextPhase } from './context.js';
 export * from './schedule.js';
 export * from './format/message-api.js';
 export * from './format/message-format.js';

package/lib/application/index.js

@@ -22,6 +22,7 @@ export { useRoute } from './hooks/route.js';
 export { useUser } from './hooks/user.js';
 export { useObserver, useSubscribe } from './hooks/subscribe.js';
 export { createEvent, useEvent } from './hooks/event.js';
+export { configureContext, createContext } from './context.js';
 export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './schedule.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './format/message-api.js';
 export { Format, FormatButtonGroup, FormatMarkDown, FormatSelect } from './format/message-format.js';

package/lib/application/runtime/client-runtime.js

@@ -25,6 +25,7 @@ import { createServer } from './http-server.js';
 import { disposeAllRuntimeApps } from './store.js';
 import { scheduleCancelByApp, unregisterAppDir } from './schedule-store.js';
 import { dispatchDisposeAllApps } from './lifecycle-callbacks.js';
+import { clearActiveContexts } from './context-registry.js';
 
 global.__client_loaded = true;
 let runtimeDisposed = false;
@@ -35,6 +36,7 @@ const disposeClientRuntime = async () => {
     }
     runtimeDisposed = true;
     await dispatchDisposeAllApps();
+    clearActiveContexts();
     const apps = disposeAllRuntimeApps();
     apps.forEach(app => {
         scheduleCancelByApp(app.name);

package/lib/application/runtime/context-registry.d.ts

@@ -0,0 +1,14 @@
+import type { EventKeys } from '../../types/index.js';
+export type ContextRegistryEntry = {
+    key: string;
+    id: string;
+    appName: string;
+    events: readonly EventKeys[];
+    onRemove?: () => void;
+};
+export declare const activeContexts: Map<string, ContextRegistryEntry>;
+export declare const putActiveContext: (context: ContextRegistryEntry) => void;
+export declare const removeActiveContext: (key: string, id?: string) => boolean;
+export declare const getActiveContextKeys: (event: EventKeys) => Set<string>;
+export declare const clearActiveContextsByApp: (appName: string) => void;
+export declare const clearActiveContexts: () => void;

package/lib/application/runtime/context-registry.js

@@ -0,0 +1,49 @@
+const activeContexts = new Map();
+const activeContextKeysByEvent = new Map();
+const putActiveContext = (context) => {
+    const previous = activeContexts.get(context.key);
+    if (previous) {
+        removeActiveContext(previous.key, previous.id);
+    }
+    activeContexts.set(context.key, context);
+    for (const event of context.events) {
+        const keys = activeContextKeysByEvent.get(event) ?? new Set();
+        keys.add(context.key);
+        activeContextKeysByEvent.set(event, keys);
+    }
+};
+const removeActiveContext = (key, id) => {
+    const context = activeContexts.get(key);
+    if (!context || (id && context.id !== id)) {
+        return false;
+    }
+    activeContexts.delete(key);
+    for (const event of context.events) {
+        const keys = activeContextKeysByEvent.get(event);
+        keys?.delete(key);
+        if (keys?.size === 0) {
+            activeContextKeysByEvent.delete(event);
+        }
+    }
+    try {
+        context.onRemove?.();
+    }
+    catch {
+    }
+    return true;
+};
+const getActiveContextKeys = (event) => activeContextKeysByEvent.get(event) ?? new Set();
+const clearActiveContextsByApp = (appName) => {
+    for (const context of activeContexts.values()) {
+        if (context.appName === appName) {
+            removeActiveContext(context.key, context.id);
+        }
+    }
+};
+const clearActiveContexts = () => {
+    for (const context of [...activeContexts.values()]) {
+        removeActiveContext(context.key, context.id);
+    }
+};
+
+export { activeContexts, clearActiveContexts, clearActiveContextsByApp, getActiveContextKeys, putActiveContext, removeActiveContext };

package/lib/application/runtime/event-processor-cycle.js

@@ -2,6 +2,7 @@ import { expendEvent } from './event-processor-event.js';
 import { expendMiddleware } from './event-processor-middleware.js';
 import { expendSubscribeCreate, expendSubscribeMount, expendSubscribeUnmount } from './event-processor-subscribe.js';
 import { finishCurrentTrace } from './hook-event-context.js';
+import { expendContext } from '../context.js';
 
 const expendCycle = (valueEvent, select, _config) => {
     const nextEnd = () => {
@@ -21,19 +22,33 @@ const expendCycle = (valueEvent, select, _config) => {
         }
         void expendEvent(valueEvent, select, nextUnMount);
     };
-    const nextMount = (cn, ...cns) => {
+    const nextResponseContent = (cn, ...cns) => {
         if (cn) {
             nextEvent(...cns);
             return;
         }
-        void expendSubscribeMount(valueEvent, select, nextEvent);
+        void expendContext(valueEvent, select, nextEvent, 'response');
     };
-    const nextCreate = (cn, ...cns) => {
+    const nextMount = (cn, ...cns) => {
+        if (cn) {
+            nextResponseContent(...cns);
+            return;
+        }
+        void expendSubscribeMount(valueEvent, select, nextResponseContent);
+    };
+    const nextMiddlewareContent = (cn, ...cns) => {
         if (cn) {
             nextMount(...cns);
             return;
         }
-        void expendMiddleware(valueEvent, select, nextMount);
+        void expendContext(valueEvent, select, nextMount, 'middleware');
+    };
+    const nextCreate = (cn, ...cns) => {
+        if (cn) {
+            nextMiddlewareContent(...cns);
+            return;
+        }
+        void expendMiddleware(valueEvent, select, nextMiddlewareContent);
     };
     void expendSubscribeCreate(valueEvent, select, nextCreate);
 };

package/lib/application/runtime/load-modules/loadChild.js

@@ -5,6 +5,7 @@ import { registerRuntimeApp, updateRuntimeAppStatus, ChildrenApp, clearRuntimeAp
 import { registerExpose } from '../../expose.js';
 import { ResultCode, fileSuffixMiddleware } from '../../../common/variable.js';
 import { registerAppDir, scheduleCancelByApp, unregisterAppDir } from '../schedule-store.js';
+import { validateContextRegistration } from '../../context.js';
 import module$1 from 'module';
 import { dispatchRuntimeStatusChange, dispatchAppDispose, dispatchAppReady } from '../lifecycle-callbacks.js';
 
@@ -168,10 +169,11 @@ const loadChildren = async (mainPath, appName) => {
         }
         const registerMounted = async () => {
             const res = await app?.register();
-            const hasEventCapability = Boolean(res && (res?.response || res?.middleware || res?.responseRouter || res?.middlewareRouter));
+            validateContextRegistration(res);
+            const hasEventCapability = Boolean(res && (res?.response || res?.middleware || res?.responseRouter || res?.middlewareRouter || res?.middlewareContent || res?.responseContent));
             const hasExposeCapability = Boolean(res?.expose);
             const hasKoaRouterCapability = Boolean(res?.koaRouter);
-            if (res && (res?.response || res?.middleware || res?.responseRouter || res?.middlewareRouter)) {
+            if (res && (res?.response || res?.middleware || res?.responseRouter || res?.middlewareRouter || res?.middlewareContent || res?.responseContent)) {
                 App.register(res);
             }
             setRuntimeAppKoaRouters(appName, res?.koaRouter);

package/lib/application/runtime/store.js

@@ -1,6 +1,7 @@
 import { SinglyLinkedList } from '../../common/SinglyLinkedList.js';
 import { disposeExpose } from '../expose.js';
 import { dispatchRuntimeStatusChange } from './lifecycle-callbacks.js';
+import { clearActiveContextsByApp } from './context-registry.js';
 export { Logger, logger } from '../../common/logger.js';
 
 class Core {
@@ -548,6 +549,7 @@ class ChildrenApp {
     }
     un() {
         disposeExpose(this.#name);
+        clearActiveContextsByApp(this.#name);
         Reflect.deleteProperty(alemonjsCore.storeChildrenApp, this.#name);
         bumpStoreVersion();
     }

package/lib/core/cbp/processor/config.d.ts

@@ -1,4 +1,3 @@
-import { WebSocket } from 'ws';
 export declare const childrenClient: Map<string, WebSocket>;
 export declare const platformClient: Map<string, WebSocket>;
 export declare const fullClient: Map<string, WebSocket>;

package/lib/index.js

@@ -28,6 +28,7 @@ export { cbpClient } from './application/runtime/cbp/connects/client.js';
 export { cbpPlatform } from './platform/cbp-platform.js';
 export { checkFallbackHint } from './application/router/fallback.js';
 export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './application/schedule.js';
+export { configureContext, createContext } from './application/context.js';
 export { createActionRequestEnvelope, createActionResponseEnvelope, createApiRequestEnvelope, createApiResponseEnvelope, createEventEnvelope, getNormalizedDeviceId, getNormalizedEventRouteId, isCBPEnvelope, isNormalizedActionRequest, isNormalizedApiRequest, normalizeInboundMessage, toLegacyActionData, toLegacyApiData } from './common/cbp/normalize.js';
 export { createDirectClient, createDirectServer, generateSocketPath } from './common/direct-channel.js';
 export { createEvent, useEvent } from './application/hooks/event.js';

package/lib/types/cycle/index.d.ts

@@ -9,7 +9,7 @@ type StroreParam = {
     };
     middleware: StoreMiddlewareItem[];
 };
-export type EventErrorPhase = 'middleware' | 'response' | 'subscribe' | 'route';
+export type EventErrorPhase = 'middleware' | 'response' | 'subscribe' | 'route' | 'context' | 'middleware-content' | 'response-content';
 export type EventTraceReason = 'filtered' | 'completed' | 'consumed' | 'error';
 export type RuntimeLifecycleStatus = 'discovered' | 'loading' | 'ready' | 'failed' | 'disposed';
 export type EventStartContext<T extends EventKeys = EventKeys> = {

package/lib/types/event/index.d.ts

@@ -4,6 +4,7 @@ import { EventKeys, Events } from './map';
 import { DataEnums } from '../message';
 import { Expose } from '../../application/expose';
 import type KoaRouter from 'koa-router';
+import type { ContextConfiguration } from '../../application/context';
 export type Current<T extends EventKeys> = (event: Events[T], next: Next) => Promise<boolean | void | undefined> | boolean | void | undefined;
 export type OnResponseValue<C, T extends EventKeys> = {
     current: C;
@@ -60,6 +61,8 @@ export type childrenCallbackRes = {
     middlewareRouter?: ReturnType<DefineRouterFunc>;
     koaRouter?: KoaRouter | KoaRouter[];
     expose?: Expose;
+    responseContent?: ContextConfiguration;
+    middlewareContent?: ContextConfiguration;
 } | undefined;
 export type childrenCallback = ChildrenCycle & {
     register?: () => (childrenCallbackRes | undefined) | Promise<childrenCallbackRes | undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.91",
+  "version": "2.1.93",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -49,32 +49,27 @@
   "dependencies": {
     "@koa/cors": "^5.0.0",
     "axios": "^1.14.0",
-    "chalk": "^5.6.2",
     "commander": "^13.1.0",
     "cron": "^4.4.0",
+    "cross-spawn": "^7.0.6",
     "file-type": "21.0.0",
     "flatted": "^3.3.3",
+    "https-proxy-agent": "^9.0.0",
     "koa": "^3.0.1",
     "koa-router": "^14.0.0",
-    "koa-static": "^5.0.0",
+    "lodash": "^4.18.1",
     "log4js": "^6.9.1",
     "mime-types": "^3.0.1",
     "public-ip": "^7.0.1",
     "qrcode": "^1.5.4",
-    "uuid": "11.1.0",
     "ws": "^8.18.0",
-    "https-proxy-agent": "^9.0.0",
     "yaml": "^2.5.1"
   },
   "devDependencies": {
     "@types/koa": "^2.15.0",
-    "@types/koa-bodyparser": "^4.3.12",
-    "@types/koa-mount": "^4.0.5",
     "@types/koa-router": "^7.4.8",
-    "@types/koa-static": "^4.0.4",
     "@types/koa__cors": "^5.0.0",
-    "@types/mime-types": "^3.0.1",
-    "@types/uuid": "^10.0.0"
+    "@types/mime-types": "^3.0.1"
   },
   "bin": {
     "alemonjs": "./bin/alemonjs.js",
@@ -92,5 +87,5 @@
     "type": "git",
     "url": "https://github.com/lemonade-lab/alemonjs.git"
   },
-  "gitHead": "c6aa5616afe091a37610dad22fbb2d2618d943b8"
-}
+  "gitHead": "f3222b96dcdca984ec726cdd26d759952ca9c705"
+}