@exellix/graph-engine 6.0.0

package/dist/src/types/refs.js

@@ -0,0 +1,12 @@
+/** Schema version for structured record gates on `conditions.dataFilters` (and optional `graphEntry.dataFilters`). */
+export const EXELLIX_STRUCTURED_DATA_FILTERS_V1 = 'exellix.dataFilters.v1';
+/** Merged graph document model is exposed under this key in merged execution `variables`. */
+export const EXELLIX_GRAPH_MODEL_VARIABLE_KEY = '__graphModel';
+/** Returns `graph.metadata` when present (plain object); otherwise `{}`. */
+export function mergeGraphDocumentModel(graph) {
+    const meta = graph.metadata;
+    if (meta != null && typeof meta === 'object' && !Array.isArray(meta)) {
+        return { ...meta };
+    }
+    return {};
+}

package/dist/src/types/results.d.ts

@@ -0,0 +1,103 @@
+import type { RunLogEntry } from './runLog.js';
+/** Classification for engine-managed `runTask` retries. */
+export type StepFailureClassification = 'timeout' | 'token-limit' | 'other';
+/** One row per `runTask` attempt (including the first) when step retry is active. */
+export interface StepAttemptRecord {
+    index: number;
+    ok: boolean;
+    startedAt: number;
+    endedAt: number;
+    durationMs: number;
+    classification?: StepFailureClassification;
+    errorCode?: string;
+    errorMessage?: string;
+    maxTokensRequested?: number;
+}
+/**
+ * Per-node execution trace stored in execution._trace.nodes[nodeId]
+ */
+export interface NodeTraceEntry {
+    startedAt: number;
+    endedAt: number;
+    skillKey: string;
+    ok: boolean;
+    durationMs: number;
+    activityId?: string;
+    summary?: Record<string, any>;
+    error?: {
+        message: string;
+        code?: string;
+        stack?: string;
+    };
+    /** Present when the MAIN `runTask` used engine step retries (success or terminal failure). */
+    attempts?: StepAttemptRecord[];
+}
+export type DebugTaskRecord = {
+    taskType: 'ai-task' | 'pre-execution' | 'post-execution';
+    details: string;
+    metadata: Record<string, unknown>;
+    modelUsed?: string | null;
+};
+export type DebugNodeTraceEntry = {
+    nodeId: string;
+    /** Node timing + status + any executor summary fields. */
+    metadata: Record<string, unknown>;
+    snapshots: {
+        inputs?: Record<string, unknown>;
+        memory?: {
+            jobMemory?: unknown;
+            taskMemory?: unknown;
+            execution?: unknown;
+        };
+    };
+    /** Best-effort node response snapshot (task output / error). */
+    response?: unknown;
+    tasks: DebugTaskRecord[];
+};
+/** One aggregated item in `ExecuteGraphResult.stepsResponses`. */
+export type ExecuteGraphStepResponse = Record<string, unknown>;
+/**
+ * Execution results
+ */
+export interface NodeExecutionResult {
+    nodeId: string;
+    skillKey: string;
+    success: boolean;
+    output?: any;
+    error?: {
+        code: string;
+        message: string;
+        diagnostics?: any;
+    };
+    metadata?: Record<string, any>;
+    execution?: any;
+    /**
+     * True when the PRE synthesized-context step ran against an empty synthesizedContext slot
+     * (i.e. synthesizedContext was absent from executionMemory before the task, either naturally
+     * or because `clearSynthesizedContextPerNode` stripped it). False when PRE was present but
+     * synthesizedContext was already in memory and not cleared. Undefined when there is no PRE step.
+     */
+    preRanFresh?: boolean;
+    /**
+     * Synthesis observability fields extracted from the ai-tasks runTask response metadata.
+     * Includes synthesisEnabled, mainContextSource, synthesizedContextPresent, detectedTemplateCores, etc.
+     */
+    aiTasksObservability?: Record<string, unknown>;
+    /** Lines from `runTask` metadata (`runLog`); merged into graph `runLog` by the runtime. */
+    taskRunLog?: RunLogEntry[];
+    logxerCorrelationId?: string;
+    /**
+     * Optional debug payload captured by the executor when `debugMode` is enabled.
+     * This is intended for `executeGraph` to assemble a stable trace DTO.
+     */
+    debug?: {
+        inputs?: Record<string, unknown>;
+        memoryStart?: {
+            jobMemory?: unknown;
+            taskMemory?: unknown;
+            execution?: unknown;
+        };
+        response?: unknown;
+        tasks?: DebugTaskRecord[];
+    };
+}

package/dist/src/types/results.js

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

package/dist/src/types/runLog.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Structured run log for execution consoles (playground, Activix, HTTP APIs).
+ * @see `.docs/exellix-graph-format.md` — Layer 08 / run log contract.
+ */
+/**
+ * NOTE: `@exellix/ai-tasks` 5.5+ no longer exports `RunLogCorrelationIds`.
+ * We preserve the field for downstream consumers but keep it structurally typed.
+ */
+export type RunLogCorrelationIds = Record<string, unknown>;
+/** Severity for filtering and display. */
+export type RunLogLevel = 'debug' | 'info' | 'warn' | 'error';
+/** Origin of the log line within a graph run (`pipeline` matches @exellix/ai-tasks RunLogScope). */
+export type RunLogScope = 'graph' | 'node' | 'task' | 'narrix' | 'logxer' | 'pipeline';
+/**
+ * One append-only row for UIs. Prefer `message` + small `data`; large blobs should be truncated by policy.
+ */
+export interface RunLogEntry {
+    /** Epoch ms (monotonic within a process; compare per-run only). */
+    ts: number;
+    level: RunLogLevel;
+    scope: RunLogScope;
+    /** Set when scope is node/task/narrix/logxer tied to a DAG node. */
+    nodeId?: string;
+    /** Carried when lines originate from @exellix/ai-tasks `RunLogEntry`. */
+    skillKey?: string;
+    taskId?: string;
+    correlationIds?: RunLogCorrelationIds;
+    message: string;
+    /** Optional structured payload; may be truncated (see buildRunLog / runtime options). */
+    data?: unknown;
+}
+/** How aggressively to populate `runLog` on {@link ExecuteGraphResult}. */
+export type RunLogMode = 'off' | 'summary' | 'full';
+/**
+ * Canonical key on `runTask` response metadata for buffered run-log lines.
+ * 5.x: only this key is read; the legacy `exellixRunLog` alias is no longer accepted.
+ */
+export declare const AI_TASKS_RUN_LOG_METADATA_KEY: "runLog";
+/**
+ * Canonical Logxer / viewer correlation id on `runTask` response metadata
+ * (`RunTaskDiagnostics.logxerRunId`). 5.x: only this key is read; the legacy
+ * `logxerCorrelationId` alias is no longer accepted.
+ */
+export declare const AI_TASKS_LOGXER_RUN_ID_METADATA_KEY: "logxerRunId";
+/** Defaults when caller omits run-log limits (signal-heavy responses). */
+export declare const DEFAULT_MAX_RUN_LOG_ENTRIES = 500;
+export declare const DEFAULT_MAX_RUN_LOG_DATA_JSON_CHARS = 4096;
+export interface RunLogBuildOptions {
+    mode: RunLogMode;
+    maxEntries: number;
+    maxDataJsonChars: number;
+    jobId: string;
+    /** Same UUID as graph-engine `runTask.taskId` for this run. */
+    taskId: string;
+    graphId: string;
+    /** Wall time when `executeGraph` began (first graph-level log line). Defaults to min node `startedAt` or `Date.now()`. */
+    graphRunStartedAt?: number;
+    /** Graph outcome for terminal graph-level lines. */
+    graphStatus: 'completed' | 'failed';
+    /** Final execution object (must include `_trace` when built by runtime). */
+    execution: Record<string, unknown>;
+    /** Lines from per-node `runTask` metadata (e.g. Logxer buffer); merged after synthetic trace lines. */
+    taskAppendedEntries?: RunLogEntry[];
+    /** Last wins if multiple nodes report one. */
+    logxerCorrelationId?: string;
+}
+export interface RunLogBuildResult {
+    runLog?: RunLogEntry[];
+    runLogTruncated?: boolean;
+    runLogOmittedCount?: number;
+    logxerCorrelationId?: string;
+}

package/dist/src/types/runLog.js

@@ -0,0 +1,18 @@
+/**
+ * Structured run log for execution consoles (playground, Activix, HTTP APIs).
+ * @see `.docs/exellix-graph-format.md` — Layer 08 / run log contract.
+ */
+/**
+ * Canonical key on `runTask` response metadata for buffered run-log lines.
+ * 5.x: only this key is read; the legacy `exellixRunLog` alias is no longer accepted.
+ */
+export const AI_TASKS_RUN_LOG_METADATA_KEY = 'runLog';
+/**
+ * Canonical Logxer / viewer correlation id on `runTask` response metadata
+ * (`RunTaskDiagnostics.logxerRunId`). 5.x: only this key is read; the legacy
+ * `logxerCorrelationId` alias is no longer accepted.
+ */
+export const AI_TASKS_LOGXER_RUN_ID_METADATA_KEY = 'logxerRunId';
+/** Defaults when caller omits run-log limits (signal-heavy responses). */
+export const DEFAULT_MAX_RUN_LOG_ENTRIES = 500;
+export const DEFAULT_MAX_RUN_LOG_DATA_JSON_CHARS = 4096;

package/dist/src/types/taskNodeConfiguration.d.ts

@@ -0,0 +1,95 @@
+import type { InputStrategyKey, LlmCallConfig, NarrixModeKey, NarrixRunInput, RunTaskRequest } from '@exellix/ai-tasks';
+import type { ExecutionStrategyInvocation, TaskStrategyItemData } from './aiTasksDerivedTypes.js';
+import type { AiTaskProfileMetadata } from './aiTaskProfile.js';
+import type { ModelConfigSelection } from './refs.js';
+import type { NarrixPreProcessorConfig } from './narrix.js';
+/** Same shape as scoped-data-reader pack slots (declared here to avoid importing runtime from types). */
+export type TaskNodeScopedDataReaderPackSlot = {
+    slot: string;
+    entityIdPath: string;
+    memorixItemDescriptorId?: string;
+    itemDescriptorId?: string;
+};
+/**
+ * Execution-facing configuration for a task node. Must not be mixed into {@link TaskNodePureMetadata};
+ * the canonical graph validator allowlists `metadata` separately.
+ *
+ * Consolidates every key the engine reads for `runTask`, pipelines, Narrix resolution, retries, identity,
+ * and in-process local skills.
+ */
+export type TaskNodeTaskConfiguration = {
+    /**
+     * ai-tasks compile-at-invoke strategies (e.g. `pre: "synthesis"`). Forwarded on
+     * `RunTaskRequest.taskConfiguration` when not lifted to the request root.
+     */
+    aiTaskStrategies?: Record<string, unknown>;
+    aiTaskProfile?: AiTaskProfileMetadata;
+    narrix?: NarrixPreProcessorConfig;
+    /** Materialized question / template input when orchestration persists PRE artifacts (execution-adjacent). */
+    synthesizedInput?: Record<string, unknown> | string;
+    narrixMode?: NarrixModeKey | (string & {});
+    inputStrategyKey?: InputStrategyKey | (string & {});
+    executionStrategies?: ExecutionStrategyInvocation[];
+    executionStrategyCatalogItems?: TaskStrategyItemData[];
+    narrixInput?: NarrixRunInput | {
+        $path: string;
+    };
+    aiTasksOutputValidation?: {
+        schema: Record<string, unknown>;
+        mode?: 'fail' | 'warn';
+        validateWhenMissing?: boolean;
+    };
+    taskTypeId?: string;
+    modelConfig?: ModelConfigSelection;
+    llmCall?: LlmCallConfig;
+    stepRetryPolicy?: unknown;
+    concurrency?: number;
+    taskKind?: RunTaskRequest['taskKind'];
+    autoValidateDecisionOutput?: boolean;
+    identity?: Record<string, unknown>;
+    runTaskIdentity?: Record<string, unknown>;
+    memoryKey?: string;
+    narrixScope?: RunTaskRequest['narrixScope'];
+    aiScoping?: RunTaskRequest['aiScoping'];
+    aiScopingOptions?: RunTaskRequest['aiScopingOptions'];
+    timeoutMs?: number;
+    templateRenderOptions?: RunTaskRequest['templateRenderOptions'];
+    smartInputRenderOptions?: RunTaskRequest['smartInputRenderOptions'];
+    templateTokens?: RunTaskRequest['templateTokens'];
+    aiEngineId?: RunTaskRequest['aiEngineId'];
+    sessionId?: string;
+    agentType?: RunTaskRequest['agentType'];
+    gatewayDiagnostics?: RunTaskRequest['gatewayDiagnostics'];
+    context?: RunTaskRequest['context'];
+    knowledge?: RunTaskRequest['knowledge'];
+    /** deterministic-rule — rule table evaluated by `deterministic-rule` local skill */
+    rules?: Array<Record<string, unknown>>;
+    firstMatchWins?: boolean;
+    defaultOutput?: Record<string, unknown>;
+    sensitivityAnalysis?: Record<string, unknown>;
+    /** scoped-data-reader */
+    entityIdPath?: string;
+    pack?: TaskNodeScopedDataReaderPackSlot[];
+    memorixItemDescriptorId?: string;
+    itemDescriptorId?: string;
+    /** scoped-answer-writer */
+    memorixWriteDescriptors?: Partial<Record<string, string>>;
+    memorixContentTypes?: string[];
+    /** @deprecated Use {@link memorixWriteDescriptors}. */
+    memorixWriteDescriptorId?: string;
+    writeDescriptorId?: string;
+    entityTypePath?: string;
+    staticEntityType?: string;
+    payloadPath?: string;
+    questionTitle?: string;
+    phase?: 'A' | 'B';
+    seedThingIdPath?: string;
+    artifactThingType?: string;
+    xmemoryNamespace?: string;
+    /** scoped-answer-assembler */
+    mergeInferencePaths?: string[];
+    mergeDecisionPaths?: string[];
+};
+export declare function getTaskConfiguration(node: {
+    taskConfiguration?: TaskNodeTaskConfiguration;
+}): TaskNodeTaskConfiguration | undefined;

package/dist/src/types/taskNodeConfiguration.js

@@ -0,0 +1,3 @@
+export function getTaskConfiguration(node) {
+    return node.taskConfiguration;
+}

package/dist/src/util/packageVersion.d.ts

@@ -0,0 +1,2 @@
+/** Read `version` from a package.json path; returns undefined if missing or unreadable. */
+export declare function readPackageVersion(packageJsonPath: string): Promise<string | undefined>;

package/dist/src/util/packageVersion.js

@@ -0,0 +1,12 @@
+import { readFile } from 'node:fs/promises';
+/** Read `version` from a package.json path; returns undefined if missing or unreadable. */
+export async function readPackageVersion(packageJsonPath) {
+    try {
+        const raw = await readFile(packageJsonPath, 'utf-8');
+        const j = JSON.parse(raw);
+        return typeof j.version === 'string' ? j.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/testkit/RealTasksClient.d.ts

@@ -0,0 +1,16 @@
+import type { TasksClientLike, RunTaskRequest, RunTaskResponse as ExellixGraphRunTaskResponse } from '../src/runtime/ExellixGraphRuntime.js';
+/**
+ * Real tasks client that wraps @exellix/ai-tasks.
+ * Converts between exellix-graph's RunTaskRequest format and ai-tasks' expected format.
+ * Implements `TasksClientLike` (the canonical 5.x runtime client surface).
+ */
+export declare class RealTasksClient implements TasksClientLike {
+    close(): Promise<void>;
+    /**
+     * Awaits `@exellix/ai-tasks` packaged client content-registry readiness (`testContentRegistryConnection`).
+     * On timeout, errors are swallowed so callers match prior non-fatal behavior; the first `runTask`
+     * may still fail with a concrete resolution error if the registry was not ready.
+     */
+    warmup(timeoutMs?: number): Promise<void>;
+    runTask(req: RunTaskRequest): Promise<ExellixGraphRunTaskResponse>;
+}

package/dist/testkit/RealTasksClient.js

@@ -0,0 +1,143 @@
+import { createCataloxFromEnv, createDefaultWorexClientTasks, initFirebaseAdminFromEnv, } from '@exellix/ai-tasks';
+let packagedClientPromise = null;
+function getPackagedClientPromise() {
+    packagedClientPromise ??= createDefaultWorexClientTasks({
+        packageName: 'XEONOX_SKILLS',
+        enableActivityTracking: true,
+        catalox: (() => {
+            initFirebaseAdminFromEnv();
+            return createCataloxFromEnv();
+        })(),
+    });
+    return packagedClientPromise;
+}
+async function closePackagedClient() {
+    const p = packagedClientPromise;
+    packagedClientPromise = null;
+    if (!p)
+        return;
+    try {
+        const sdk = await p;
+        await sdk.close();
+    }
+    catch {
+        /* creation or close failed */
+    }
+}
+/**
+ * Real tasks client that wraps @exellix/ai-tasks.
+ * Converts between exellix-graph's RunTaskRequest format and ai-tasks' expected format.
+ * Implements `TasksClientLike` (the canonical 5.x runtime client surface).
+ */
+export class RealTasksClient {
+    async close() {
+        await closePackagedClient();
+    }
+    /**
+     * Awaits `@exellix/ai-tasks` packaged client content-registry readiness (`testContentRegistryConnection`).
+     * On timeout, errors are swallowed so callers match prior non-fatal behavior; the first `runTask`
+     * may still fail with a concrete resolution error if the registry was not ready.
+     */
+    async warmup(timeoutMs = 5_000) {
+        const sdk = await getPackagedClientPromise();
+        try {
+            await sdk.warmup({ timeoutMs });
+        }
+        catch {
+            /* non-fatal */
+        }
+    }
+    async runTask(req) {
+        try {
+            // Convert exellix-graph format to ai-tasks format
+            // Contract: skillKey is the content-registry instruction key; we do not send
+            // pre-parsed instructions — downstream must fetch template by key and parse it.
+            const skillKey = req.skillKey;
+            // Forward canonical graph-engine / ai-tasks v7 requests as-is (ai-tasks merges jobContext, variables, input).
+            const aiTasksRequest = {
+                ...req,
+                skillKey,
+                jobId: req.jobId,
+                taskId: req.taskId,
+                agentId: req.agentId,
+                input: req.input != null ? req.input : {},
+            };
+            // Forward explicit graph/runtime modelConfig only; graph-engine does not inject model defaults.
+            const reqModelConfig = req.modelConfig;
+            if (reqModelConfig) {
+                aiTasksRequest.modelConfig = reqModelConfig;
+            }
+            if (req.executionPipeline != null) {
+                aiTasksRequest.executionPipeline = req.executionPipeline;
+            }
+            if (req.includeContextInPrompt !== undefined) {
+                aiTasksRequest.includeContextInPrompt = req.includeContextInPrompt;
+            }
+            if (req.outputValidation != null) {
+                aiTasksRequest.outputValidation = req.outputValidation;
+            }
+            if (req.diagnostics != null) {
+                aiTasksRequest.diagnostics = req.diagnostics;
+            }
+            if (process.env.DEBUG_AI_PROVIDER === 'true') {
+                const mc = aiTasksRequest.modelConfig;
+                const effective = mc
+                    ? { xynthesisModel: mc.xynthesisModel, skillModel: mc.skillModel }
+                    : aiTasksRequest.config
+                        ? {
+                            provider: aiTasksRequest.config.provider,
+                            model: aiTasksRequest.config.model,
+                        }
+                        : { provider: '(none)', model: '(none)' };
+                console.log('[AI_PROVIDER] RealTasksClient → ai-tasks:', effective);
+            }
+            const sdk = await getPackagedClientPromise();
+            const response = await sdk.runTask(aiTasksRequest);
+            // Convert ai-tasks response to the unified format consumed by the canonical 5.x runtime.
+            // RunSkillResponse has: skillKey, rawText, flexMd, parsed, metadata
+            const result = {
+                ...response,
+                success: true,
+                ok: true,
+                output: response.parsed,
+                parsed: response.parsed,
+                rawContent: response.rawText,
+            };
+            if (response.executionMemory !== undefined) {
+                result.executionMemory = response.executionMemory;
+            }
+            if (response.jobMemory !== undefined) {
+                result.jobMemory = response.jobMemory;
+            }
+            if (response.taskMemory !== undefined) {
+                result.taskMemory = response.taskMemory;
+            }
+            if (response.execution !== undefined) {
+                result.execution = response.execution;
+            }
+            // Prefer canonical executionMemory when execution is omitted.
+            if (result.execution === undefined && result.executionMemory !== undefined) {
+                result.execution = result.executionMemory;
+            }
+            // ai-tasks attaches synthesis observability on top-level metadata (see task-sdk attachExecutionStateAndObservability).
+            const sdkMeta = response.metadata ?? response.meta;
+            if (sdkMeta != null && typeof sdkMeta === 'object' && !Array.isArray(sdkMeta)) {
+                result.metadata = { ...result.metadata, ...sdkMeta };
+                result.meta = result.metadata;
+            }
+            return result;
+        }
+        catch (error) {
+            const errorResponse = {
+                success: false,
+                ok: false,
+                error: {
+                    code: error.code || 'TASK_RUN_FAILED',
+                    message: error.message || 'Task execution failed',
+                    diagnostics: { error, stack: error.stack, name: error.name, ...error },
+                },
+            };
+            return errorResponse;
+        }
+    }
+}

package/dist/testkit/depGraphEngineFactory.d.ts

@@ -0,0 +1,6 @@
+import type { GraphEngine, GraphEngineFactory } from '../src/runtime/GraphEngine.js';
+export declare class DepGraphEngineFactory implements GraphEngineFactory {
+    create(input: {
+        graph: any;
+    }): GraphEngine;
+}

package/dist/testkit/depGraphEngineFactory.js

@@ -0,0 +1,54 @@
+class DepEngine {
+    done = new Set();
+    outputs = {};
+    errors = {};
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    /**
+     * Update the active graph definition while keeping execution state (done/outputs/errors).
+     * This allows callers to pass derived graphs (e.g. conditional edges filtered per round).
+     */
+    setGraph(graph) {
+        this.graph = graph;
+    }
+    depsOf(nodeId) {
+        // edge: { from, to } means "to depends on from"
+        return (this.graph.edges ?? [])
+            .filter((e) => e.to === nodeId)
+            .map((e) => e.from);
+    }
+    plan() {
+        const nodes = this.graph.nodes ?? [];
+        const runnable = nodes.filter((n) => {
+            if (this.done.has(n.id))
+                return false;
+            const deps = this.depsOf(n.id);
+            return deps.every((d) => this.done.has(d));
+        });
+        if (runnable.length)
+            return { status: 'continue', nextNodes: runnable };
+        const allDone = nodes.every((n) => this.done.has(n.id));
+        return allDone ? { status: 'completed', nextNodes: [] } : { status: 'blocked', nextNodes: [] };
+    }
+    commit(input) {
+        this.done.add(input.nodeId);
+        if (input.error)
+            this.errors[input.nodeId] = input.error;
+        if (input.output)
+            this.outputs[input.nodeId] = input.output;
+    }
+    snapshot() {
+        return {
+            done: Array.from(this.done),
+            outputs: this.outputs,
+            errors: this.errors,
+        };
+    }
+}
+export class DepGraphEngineFactory {
+    create(input) {
+        return new DepEngine(input.graph);
+    }
+}

package/dist/testkit/exellixRuntimeObjects.d.ts

@@ -0,0 +1,7 @@
+import { type BuildExellixGraphRuntimeObjectsInput, type RuntimeObjects } from '../src/runtime/runtimeObjects.js';
+/**
+ * Best-effort read of `@exellix/ai-tasks` `runtimeObjects` export (when the SDK exposes it).
+ */
+export declare function tryLoadExellixAiTasksRuntimeSubtree(): Promise<BuildExellixGraphRuntimeObjectsInput['aiTasksRuntimeObjects'] | undefined>;
+/** Composed exellix-graph + optional ai-tasks subtree (no graph-level Activix/Logxer unless you extend `input`). */
+export declare function loadExellixGraphRuntimeObjects(input?: Omit<BuildExellixGraphRuntimeObjectsInput, 'aiTasksRuntimeObjects'>): Promise<RuntimeObjects>;

package/dist/testkit/exellixRuntimeObjects.js

@@ -0,0 +1,25 @@
+import { buildExellixGraphRuntimeObjects, } from '../src/runtime/runtimeObjects.js';
+/**
+ * Best-effort read of `@exellix/ai-tasks` `runtimeObjects` export (when the SDK exposes it).
+ */
+export async function tryLoadExellixAiTasksRuntimeSubtree() {
+    try {
+        const mod = (await import('@exellix/ai-tasks'));
+        const ro = mod.runtimeObjects;
+        if (ro == null || typeof ro !== 'object')
+            return undefined;
+        return {
+            activixClient: ro.activixClient,
+            logxerClient: ro.logxerClient,
+            packagesRuntimeObjects: ro.packagesRuntimeObjects,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Composed exellix-graph + optional ai-tasks subtree (no graph-level Activix/Logxer unless you extend `input`). */
+export async function loadExellixGraphRuntimeObjects(input = {}) {
+    const aiTasksRuntimeObjects = await tryLoadExellixAiTasksRuntimeSubtree();
+    return buildExellixGraphRuntimeObjects({ ...input, aiTasksRuntimeObjects });
+}

package/dist/testkit/inMemoryGraphLoader.d.ts

@@ -0,0 +1,6 @@
+import type { GraphLoader } from '../src/runtime/ExellixGraphRuntime.js';
+export declare class InMemoryGraphLoader implements GraphLoader {
+    private graphsById;
+    constructor(graphsById: Record<string, any>);
+    loadGraph(graphId: string): Promise<any>;
+}

package/dist/testkit/inMemoryGraphLoader.js

@@ -0,0 +1,12 @@
+export class InMemoryGraphLoader {
+    graphsById;
+    constructor(graphsById) {
+        this.graphsById = graphsById;
+    }
+    async loadGraph(graphId) {
+        const g = this.graphsById[graphId];
+        if (!g)
+            throw new Error(`GRAPH_NOT_FOUND: ${graphId}`);
+        return g;
+    }
+}

package/dist/testkit/index.d.ts

@@ -0,0 +1,4 @@
+export { InMemoryGraphLoader } from './inMemoryGraphLoader.js';
+export { DepGraphEngineFactory } from './depGraphEngineFactory.js';
+export { RealTasksClient } from './RealTasksClient.js';
+export { tryLoadExellixAiTasksRuntimeSubtree, loadExellixGraphRuntimeObjects, } from './exellixRuntimeObjects.js';

package/dist/testkit/index.js

@@ -0,0 +1,4 @@
+export { InMemoryGraphLoader } from './inMemoryGraphLoader.js';
+export { DepGraphEngineFactory } from './depGraphEngineFactory.js';
+export { RealTasksClient } from './RealTasksClient.js';
+export { tryLoadExellixAiTasksRuntimeSubtree, loadExellixGraphRuntimeObjects, } from './exellixRuntimeObjects.js';