@bluelibs/runner-dev 6.2.0 → 6.4.0

package/dist/generated/resolvers-types.d.ts

@@ -173,12 +173,6 @@ export type Diagnostic = {
     nodeKind: Maybe<Scalars['String']['output']>;
     severity: Scalars['String']['output'];
 };
-/** The structure of a durable workflow, extracted without executing it */
-export type DurableFlowShape = {
-    __typename?: 'DurableFlowShape';
-    /** Ordered list of flow nodes describing the workflow structure */
-    nodes: Array<FlowNode>;
-};
 export type EmissionEntry = {
     __typename?: 'EmissionEntry';
     /** Correlation id for tracing */
@@ -280,7 +274,7 @@ export type Event = BaseElement & {
     emittedBy: Array<Scalars['String']['output']>;
     /** Nodes that emit this event (resolved). Can be Task, Hook or Resource. */
     emittedByResolved: Array<BaseElement>;
-    /** Event lane summary derived from globals.tags.eventLane when present. */
+    /** Event lane summary derived from Event Lane applyTo() assignments when present. */
     eventLane: Maybe<EventLaneSummary>;
     /** Contents of the file at filePath (if accessible). Optionally slice by 1-based inclusive line numbers via startLine/endLine. Caution: avoid querying this in bulk; prefer fetching one file at a time. */
     fileContents: Maybe<Scalars['String']['output']>;
@@ -327,7 +321,7 @@ export type EventFileContentsArgs = {
 export type EventFilterInput = {
     /** When true, only events without hooks are returned. */
     hasNoHooks: InputMaybe<Scalars['Boolean']['input']>;
-    /** When true, hides internal/system events (runner-dev/globals). */
+    /** When true, hides system namespace events (`system` / `system.*`). */
     hideSystem: InputMaybe<Scalars['Boolean']['input']>;
     /** Return only events whose id contains this substring. */
     idIncludes: InputMaybe<Scalars['String']['input']>;
@@ -343,64 +337,6 @@ export type EventLoopStats = {
     /** Average event loop delay (ms) measured via monitorEventLoopDelay */
     lag: Scalars['Float']['output'];
 };
-/** A durable workflow event emission node */
-export type FlowEmitNode = {
-    __typename?: 'FlowEmitNode';
-    /** The event ID being emitted */
-    eventId: Scalars['String']['output'];
-    kind: Scalars['String']['output'];
-    /** Optional explicit step ID */
-    stepId: Maybe<Scalars['String']['output']>;
-};
-/** A node in a durable workflow flow description */
-export type FlowNode = FlowEmitNode | FlowNoteNode | FlowSignalNode | FlowSleepNode | FlowStepNode | FlowSwitchNode;
-/** A durable workflow documentation note */
-export type FlowNoteNode = {
-    __typename?: 'FlowNoteNode';
-    kind: Scalars['String']['output'];
-    /** The note message */
-    message: Scalars['String']['output'];
-};
-/** A durable workflow signal wait node */
-export type FlowSignalNode = {
-    __typename?: 'FlowSignalNode';
-    kind: Scalars['String']['output'];
-    /** The event ID this step waits for */
-    signalId: Scalars['String']['output'];
-    /** Optional explicit step ID */
-    stepId: Maybe<Scalars['String']['output']>;
-    /** Optional timeout in milliseconds */
-    timeoutMs: Maybe<Scalars['Int']['output']>;
-};
-/** A durable workflow sleep/delay node */
-export type FlowSleepNode = {
-    __typename?: 'FlowSleepNode';
-    /** Sleep duration in milliseconds */
-    durationMs: Scalars['Int']['output'];
-    kind: Scalars['String']['output'];
-    /** Optional explicit step ID */
-    stepId: Maybe<Scalars['String']['output']>;
-};
-/** A durable workflow step node */
-export type FlowStepNode = {
-    __typename?: 'FlowStepNode';
-    /** Whether this step has a rollback/compensation handler */
-    hasCompensation: Scalars['Boolean']['output'];
-    kind: Scalars['String']['output'];
-    /** The step identifier */
-    stepId: Scalars['String']['output'];
-};
-/** A durable workflow branching/switch node */
-export type FlowSwitchNode = {
-    __typename?: 'FlowSwitchNode';
-    /** IDs of the available branches */
-    branchIds: Array<Scalars['String']['output']>;
-    /** Whether a default branch is defined */
-    hasDefault: Scalars['Boolean']['output'];
-    kind: Scalars['String']['output'];
-    /** The switch step identifier */
-    stepId: Scalars['String']['output'];
-};
 export type GcStats = {
     __typename?: 'GcStats';
     /** Number of GC cycles since process start */
@@ -675,15 +611,17 @@ export type MiddlewareInterceptorOwnersSnapshot = {
 };
 export type MiddlewareResourceUsage = {
     __typename?: 'MiddlewareResourceUsage';
-    config: Maybe<Scalars['ID']['output']>;
+    config: Maybe<Scalars['String']['output']>;
     id: Scalars['ID']['output'];
     node: Resource;
 };
 export type MiddlewareTaskUsage = {
     __typename?: 'MiddlewareTaskUsage';
-    config: Maybe<Scalars['ID']['output']>;
+    config: Maybe<Scalars['String']['output']>;
     id: Scalars['ID']['output'];
-    node: Task;
+    node: BaseElement;
+    origin: Maybe<Scalars['String']['output']>;
+    subtreeOwnerId: Maybe<Scalars['ID']['output']>;
 };
 /** Kinds of executable nodes */
 export type NodeKindEnum = 'HOOK' | 'TASK';
@@ -839,8 +777,12 @@ export type Resource = BaseElement & {
     filePath: Maybe<Scalars['String']['output']>;
     /** True when this resource defines a cooldown() lifecycle hook. */
     hasCooldown: Scalars['Boolean']['output'];
+    /** True when this resource defines a dispose() lifecycle hook. */
+    hasDispose: Scalars['Boolean']['output'];
     /** True when this resource defines a health() probe for runtime health reports. */
     hasHealthCheck: Scalars['Boolean']['output'];
+    /** True when this resource defines an init() lifecycle hook. */
+    hasInit: Scalars['Boolean']['output'];
     /** True when this resource defines a ready() lifecycle hook. */
     hasReady: Scalars['Boolean']['output'];
     /** Unique identifier for the element */
@@ -858,7 +800,7 @@ export type Resource = BaseElement & {
     /** Middlewares applied to this resource (resolved) */
     middlewareResolved: Array<ResourceMiddleware>;
     /** Middlewares applied to this resource with per-usage config */
-    middlewareResolvedDetailed: Array<TaskMiddlewareUsage>;
+    middlewareResolvedDetailed: Array<ResourceMiddlewareUsage>;
     /** Ids of items this resource overrides */
     overrides: Array<Scalars['String']['output']>;
     /** The registerable items this resource overrides (resolved) */
@@ -968,20 +910,49 @@ export type ResourceMiddlewareFileContentsArgs = {
     endLine: InputMaybe<Scalars['Int']['input']>;
     startLine: InputMaybe<Scalars['Int']['input']>;
 };
-export type ResourceSubtreeBranch = {
-    __typename?: 'ResourceSubtreeBranch';
-    middleware: Array<Scalars['String']['output']>;
-    validatorCount: Scalars['Int']['output'];
+export type ResourceMiddlewareUsage = {
+    __typename?: 'ResourceMiddlewareUsage';
+    config: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    node: ResourceMiddleware;
+};
+export type ResourceSubtreeIdentityRequirement = {
+    __typename?: 'ResourceSubtreeIdentityRequirement';
+    roles: Array<Scalars['String']['output']>;
+    tenant: Scalars['Boolean']['output'];
+    user: Scalars['Boolean']['output'];
+};
+export type ResourceSubtreeIdentityScope = {
+    __typename?: 'ResourceSubtreeIdentityScope';
+    required: Scalars['Boolean']['output'];
+    tenant: Scalars['Boolean']['output'];
+    user: Scalars['Boolean']['output'];
+};
+export type ResourceSubtreeMiddlewareScope = {
+    __typename?: 'ResourceSubtreeMiddlewareScope';
+    identityScope: Maybe<ResourceSubtreeIdentityScope>;
 };
 export type ResourceSubtreePolicy = {
     __typename?: 'ResourceSubtreePolicy';
     events: Maybe<ResourceSubtreeValidationBranch>;
     hooks: Maybe<ResourceSubtreeValidationBranch>;
+    middleware: Maybe<ResourceSubtreeMiddlewareScope>;
     resourceMiddleware: Maybe<ResourceSubtreeValidationBranch>;
-    resources: Maybe<ResourceSubtreeBranch>;
+    resources: Maybe<ResourceSubtreeResourceBranch>;
     tags: Maybe<ResourceSubtreeValidationBranch>;
     taskMiddleware: Maybe<ResourceSubtreeValidationBranch>;
-    tasks: Maybe<ResourceSubtreeBranch>;
+    tasks: Maybe<ResourceSubtreeTaskBranch>;
+};
+export type ResourceSubtreeResourceBranch = {
+    __typename?: 'ResourceSubtreeResourceBranch';
+    middleware: Array<Scalars['String']['output']>;
+    validatorCount: Scalars['Int']['output'];
+};
+export type ResourceSubtreeTaskBranch = {
+    __typename?: 'ResourceSubtreeTaskBranch';
+    identity: Array<ResourceSubtreeIdentityRequirement>;
+    middleware: Array<Scalars['String']['output']>;
+    validatorCount: Scalars['Int']['output'];
 };
 export type ResourceSubtreeValidationBranch = {
     __typename?: 'ResourceSubtreeValidationBranch';
@@ -1158,6 +1129,8 @@ export type Task = BaseElement & {
     depenendsOnResolved: Array<BaseElement>;
     /** The durable resource runtime used by this workflow (if resolvable) */
     durableResource: Maybe<Resource>;
+    /** The explicit durable workflow key when set via tags.durableWorkflow.with({ key }). Null when the workflow uses its canonical task id as the durable identity. */
+    durableWorkflowKey: Maybe<Scalars['String']['output']>;
     /** Event ids this task may emit (from dependencies) */
     emits: Array<Scalars['String']['output']>;
     /** Events emitted by this task (resolved) */
@@ -1166,8 +1139,6 @@ export type Task = BaseElement & {
     fileContents: Maybe<Scalars['String']['output']>;
     /** Path to task file */
     filePath: Maybe<Scalars['String']['output']>;
-    /** The workflow structure (steps, sleeps, signals, etc.) for durable tasks */
-    flowShape: Maybe<DurableFlowShape>;
     /** Whether this task has runtime interceptors registered via taskDependency.intercept(...). */
     hasInterceptors: Scalars['Boolean']['output'];
     /** Unique identifier for the element */
@@ -1288,6 +1259,8 @@ export type TaskMiddlewareUsage = {
     config: Maybe<Scalars['String']['output']>;
     id: Scalars['ID']['output'];
     node: TaskMiddleware;
+    origin: Maybe<Scalars['String']['output']>;
+    subtreeOwnerId: Maybe<Scalars['ID']['output']>;
 };
 export type WithIndex<TObject> = TObject & Record<string, any>;
 export type ResolversObject<TObject> = WithIndex<TObject>;
@@ -1317,10 +1290,6 @@ export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParen
 export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
 export type NextResolverFn<T> = () => Promise<T>;
 export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
-/** Mapping of union types */
-export type ResolversUnionTypes<_RefType extends Record<string, unknown>> = ResolversObject<{
-    FlowNode: (FlowEmitNode) | (FlowNoteNode) | (FlowSignalNode) | (FlowSleepNode) | (FlowStepNode) | (FlowSwitchNode);
-}>;
 /** Mapping of interface types */
 export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> = ResolversObject<{
     BaseElement: (Omit<All, 'tags'> & {
@@ -1359,7 +1328,7 @@ export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> =
         dependsOnResolved: Array<_RefType['Resource']>;
         emits: Array<_RefType['Event']>;
         middlewareResolved: Array<_RefType['ResourceMiddleware']>;
-        middlewareResolvedDetailed: Array<_RefType['TaskMiddlewareUsage']>;
+        middlewareResolvedDetailed: Array<_RefType['ResourceMiddlewareUsage']>;
         overridesResolved: Array<_RefType['BaseElement']>;
         registeredByResolved: Maybe<_RefType['Resource']>;
         registersResolved: Array<_RefType['BaseElement']>;
@@ -1382,12 +1351,11 @@ export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> =
         tags: Maybe<Array<_RefType['Tag']>>;
         taskMiddlewares: Array<_RefType['TaskMiddleware']>;
         tasks: Array<_RefType['Task']>;
-    }) | (Omit<Task, 'dependsOnResolved' | 'depenendsOnResolved' | 'durableResource' | 'emitsResolved' | 'flowShape' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
+    }) | (Omit<Task, 'dependsOnResolved' | 'depenendsOnResolved' | 'durableResource' | 'emitsResolved' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
         dependsOnResolved: _RefType['TaskDependsOn'];
         depenendsOnResolved: Array<_RefType['BaseElement']>;
         durableResource: Maybe<_RefType['Resource']>;
         emitsResolved: Array<_RefType['Event']>;
-        flowShape: Maybe<_RefType['DurableFlowShape']>;
         middlewareResolved: Array<_RefType['TaskMiddleware']>;
         middlewareResolvedDetailed: Array<_RefType['TaskMiddlewareUsage']>;
         registeredByResolved: Maybe<_RefType['Resource']>;
@@ -1418,9 +1386,6 @@ export type ResolversTypes = ResolversObject<{
     CoverageInfo: ResolverTypeWrapper<CoverageInfo>;
     CpuStats: ResolverTypeWrapper<CpuStats>;
     Diagnostic: ResolverTypeWrapper<Diagnostic>;
-    DurableFlowShape: ResolverTypeWrapper<Omit<DurableFlowShape, 'nodes'> & {
-        nodes: Array<ResolversTypes['FlowNode']>;
-    }>;
     EmissionEntry: ResolverTypeWrapper<Omit<EmissionEntry, 'emitterResolved' | 'eventResolved'> & {
         emitterResolved: Maybe<ResolversTypes['BaseElement']>;
         eventResolved: Maybe<ResolversTypes['Event']>;
@@ -1444,13 +1409,6 @@ export type ResolversTypes = ResolversObject<{
     EventLaneSummary: ResolverTypeWrapper<EventLaneSummary>;
     EventLoopStats: ResolverTypeWrapper<EventLoopStats>;
     Float: ResolverTypeWrapper<Scalars['Float']['output']>;
-    FlowEmitNode: ResolverTypeWrapper<FlowEmitNode>;
-    FlowNode: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['FlowNode']>;
-    FlowNoteNode: ResolverTypeWrapper<FlowNoteNode>;
-    FlowSignalNode: ResolverTypeWrapper<FlowSignalNode>;
-    FlowSleepNode: ResolverTypeWrapper<FlowSleepNode>;
-    FlowStepNode: ResolverTypeWrapper<FlowStepNode>;
-    FlowSwitchNode: ResolverTypeWrapper<FlowSwitchNode>;
     GcStats: ResolverTypeWrapper<GcStats>;
     Hook: ResolverTypeWrapper<Omit<Hook, 'depenendsOnResolved' | 'emitsResolved' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
         depenendsOnResolved: Array<ResolversTypes['BaseElement']>;
@@ -1496,7 +1454,7 @@ export type ResolversTypes = ResolversObject<{
         node: ResolversTypes['Resource'];
     }>;
     MiddlewareTaskUsage: ResolverTypeWrapper<Omit<MiddlewareTaskUsage, 'node'> & {
-        node: ResolversTypes['Task'];
+        node: ResolversTypes['BaseElement'];
     }>;
     NodeKindEnum: NodeKindEnum;
     Query: ResolverTypeWrapper<{}>;
@@ -1504,7 +1462,7 @@ export type ResolversTypes = ResolversObject<{
         dependsOnResolved: Array<ResolversTypes['Resource']>;
         emits: Array<ResolversTypes['Event']>;
         middlewareResolved: Array<ResolversTypes['ResourceMiddleware']>;
-        middlewareResolvedDetailed: Array<ResolversTypes['TaskMiddlewareUsage']>;
+        middlewareResolvedDetailed: Array<ResolversTypes['ResourceMiddlewareUsage']>;
         overridesResolved: Array<ResolversTypes['BaseElement']>;
         registeredByResolved: Maybe<ResolversTypes['Resource']>;
         registersResolved: Array<ResolversTypes['BaseElement']>;
@@ -1524,8 +1482,15 @@ export type ResolversTypes = ResolversObject<{
         usedBy: Array<ResolversTypes['Resource']>;
         usedByDetailed: Array<ResolversTypes['MiddlewareResourceUsage']>;
     }>;
-    ResourceSubtreeBranch: ResolverTypeWrapper<ResourceSubtreeBranch>;
+    ResourceMiddlewareUsage: ResolverTypeWrapper<Omit<ResourceMiddlewareUsage, 'node'> & {
+        node: ResolversTypes['ResourceMiddleware'];
+    }>;
+    ResourceSubtreeIdentityRequirement: ResolverTypeWrapper<ResourceSubtreeIdentityRequirement>;
+    ResourceSubtreeIdentityScope: ResolverTypeWrapper<ResourceSubtreeIdentityScope>;
+    ResourceSubtreeMiddlewareScope: ResolverTypeWrapper<ResourceSubtreeMiddlewareScope>;
     ResourceSubtreePolicy: ResolverTypeWrapper<ResourceSubtreePolicy>;
+    ResourceSubtreeResourceBranch: ResolverTypeWrapper<ResourceSubtreeResourceBranch>;
+    ResourceSubtreeTaskBranch: ResolverTypeWrapper<ResourceSubtreeTaskBranch>;
     ResourceSubtreeValidationBranch: ResolverTypeWrapper<ResourceSubtreeValidationBranch>;
     RpcLaneSummary: ResolverTypeWrapper<RpcLaneSummary>;
     RunDisposeOptions: ResolverTypeWrapper<RunDisposeOptions>;
@@ -1552,12 +1517,11 @@ export type ResolversTypes = ResolversObject<{
     }>;
     TagTarget: null;
     TagUsage: ResolverTypeWrapper<TagUsage>;
-    Task: ResolverTypeWrapper<Omit<Task, 'dependsOnResolved' | 'depenendsOnResolved' | 'durableResource' | 'emitsResolved' | 'flowShape' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
+    Task: ResolverTypeWrapper<Omit<Task, 'dependsOnResolved' | 'depenendsOnResolved' | 'durableResource' | 'emitsResolved' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
         dependsOnResolved: ResolversTypes['TaskDependsOn'];
         depenendsOnResolved: Array<ResolversTypes['BaseElement']>;
         durableResource: Maybe<ResolversTypes['Resource']>;
         emitsResolved: Array<ResolversTypes['Event']>;
-        flowShape: Maybe<ResolversTypes['DurableFlowShape']>;
         middlewareResolved: Array<ResolversTypes['TaskMiddleware']>;
         middlewareResolvedDetailed: Array<ResolversTypes['TaskMiddlewareUsage']>;
         registeredByResolved: Maybe<ResolversTypes['Resource']>;
@@ -1599,9 +1563,6 @@ export type ResolversParentTypes = ResolversObject<{
     CoverageInfo: CoverageInfo;
     CpuStats: CpuStats;
     Diagnostic: Diagnostic;
-    DurableFlowShape: Omit<DurableFlowShape, 'nodes'> & {
-        nodes: Array<ResolversParentTypes['FlowNode']>;
-    };
     EmissionEntry: Omit<EmissionEntry, 'emitterResolved' | 'eventResolved'> & {
         emitterResolved: Maybe<ResolversParentTypes['BaseElement']>;
         eventResolved: Maybe<ResolversParentTypes['Event']>;
@@ -1625,13 +1586,6 @@ export type ResolversParentTypes = ResolversObject<{
     EventLaneSummary: EventLaneSummary;
     EventLoopStats: EventLoopStats;
     Float: Scalars['Float']['output'];
-    FlowEmitNode: FlowEmitNode;
-    FlowNode: ResolversUnionTypes<ResolversParentTypes>['FlowNode'];
-    FlowNoteNode: FlowNoteNode;
-    FlowSignalNode: FlowSignalNode;
-    FlowSleepNode: FlowSleepNode;
-    FlowStepNode: FlowStepNode;
-    FlowSwitchNode: FlowSwitchNode;
     GcStats: GcStats;
     Hook: Omit<Hook, 'depenendsOnResolved' | 'emitsResolved' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
         depenendsOnResolved: Array<ResolversParentTypes['BaseElement']>;
@@ -1674,14 +1628,14 @@ export type ResolversParentTypes = ResolversObject<{
         node: ResolversParentTypes['Resource'];
     };
     MiddlewareTaskUsage: Omit<MiddlewareTaskUsage, 'node'> & {
-        node: ResolversParentTypes['Task'];
+        node: ResolversParentTypes['BaseElement'];
     };
     Query: {};
     Resource: Omit<Resource, 'dependsOnResolved' | 'emits' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'overridesResolved' | 'registeredByResolved' | 'registersResolved' | 'tags' | 'usedBy'> & {
         dependsOnResolved: Array<ResolversParentTypes['Resource']>;
         emits: Array<ResolversParentTypes['Event']>;
         middlewareResolved: Array<ResolversParentTypes['ResourceMiddleware']>;
-        middlewareResolvedDetailed: Array<ResolversParentTypes['TaskMiddlewareUsage']>;
+        middlewareResolvedDetailed: Array<ResolversParentTypes['ResourceMiddlewareUsage']>;
         overridesResolved: Array<ResolversParentTypes['BaseElement']>;
         registeredByResolved: Maybe<ResolversParentTypes['Resource']>;
         registersResolved: Array<ResolversParentTypes['BaseElement']>;
@@ -1700,8 +1654,15 @@ export type ResolversParentTypes = ResolversObject<{
         usedBy: Array<ResolversParentTypes['Resource']>;
         usedByDetailed: Array<ResolversParentTypes['MiddlewareResourceUsage']>;
     };
-    ResourceSubtreeBranch: ResourceSubtreeBranch;
+    ResourceMiddlewareUsage: Omit<ResourceMiddlewareUsage, 'node'> & {
+        node: ResolversParentTypes['ResourceMiddleware'];
+    };
+    ResourceSubtreeIdentityRequirement: ResourceSubtreeIdentityRequirement;
+    ResourceSubtreeIdentityScope: ResourceSubtreeIdentityScope;
+    ResourceSubtreeMiddlewareScope: ResourceSubtreeMiddlewareScope;
     ResourceSubtreePolicy: ResourceSubtreePolicy;
+    ResourceSubtreeResourceBranch: ResourceSubtreeResourceBranch;
+    ResourceSubtreeTaskBranch: ResourceSubtreeTaskBranch;
     ResourceSubtreeValidationBranch: ResourceSubtreeValidationBranch;
     RpcLaneSummary: RpcLaneSummary;
     RunDisposeOptions: RunDisposeOptions;
@@ -1726,12 +1687,11 @@ export type ResolversParentTypes = ResolversObject<{
         tasks: Array<ResolversParentTypes['Task']>;
     };
     TagUsage: TagUsage;
-    Task: Omit<Task, 'dependsOnResolved' | 'depenendsOnResolved' | 'durableResource' | 'emitsResolved' | 'flowShape' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
+    Task: Omit<Task, 'dependsOnResolved' | 'depenendsOnResolved' | 'durableResource' | 'emitsResolved' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
         dependsOnResolved: ResolversParentTypes['TaskDependsOn'];
         depenendsOnResolved: Array<ResolversParentTypes['BaseElement']>;
         durableResource: Maybe<ResolversParentTypes['Resource']>;
         emitsResolved: Array<ResolversParentTypes['Event']>;
-        flowShape: Maybe<ResolversParentTypes['DurableFlowShape']>;
         middlewareResolved: Array<ResolversParentTypes['TaskMiddleware']>;
         middlewareResolvedDetailed: Array<ResolversParentTypes['TaskMiddlewareUsage']>;
         registeredByResolved: Maybe<ResolversParentTypes['Resource']>;
@@ -1822,10 +1782,6 @@ export type DiagnosticResolvers<ContextType = CustomGraphQLContext, ParentType e
     severity: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
-export type DurableFlowShapeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['DurableFlowShape'] = ResolversParentTypes['DurableFlowShape']> = ResolversObject<{
-    nodes: Resolver<Array<ResolversTypes['FlowNode']>, ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
 export type EmissionEntryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['EmissionEntry'] = ResolversParentTypes['EmissionEntry']> = ResolversObject<{
     correlationId: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     emitterId: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1899,46 +1855,6 @@ export type EventLoopStatsResolvers<ContextType = CustomGraphQLContext, ParentTy
     lag: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
-export type FlowEmitNodeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['FlowEmitNode'] = ResolversParentTypes['FlowEmitNode']> = ResolversObject<{
-    eventId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    kind: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    stepId: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
-export type FlowNodeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['FlowNode'] = ResolversParentTypes['FlowNode']> = ResolversObject<{
-    __resolveType: TypeResolveFn<'FlowEmitNode' | 'FlowNoteNode' | 'FlowSignalNode' | 'FlowSleepNode' | 'FlowStepNode' | 'FlowSwitchNode', ParentType, ContextType>;
-}>;
-export type FlowNoteNodeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['FlowNoteNode'] = ResolversParentTypes['FlowNoteNode']> = ResolversObject<{
-    kind: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    message: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
-export type FlowSignalNodeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['FlowSignalNode'] = ResolversParentTypes['FlowSignalNode']> = ResolversObject<{
-    kind: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    signalId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    stepId: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    timeoutMs: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
-export type FlowSleepNodeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['FlowSleepNode'] = ResolversParentTypes['FlowSleepNode']> = ResolversObject<{
-    durationMs: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
-    kind: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    stepId: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
-export type FlowStepNodeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['FlowStepNode'] = ResolversParentTypes['FlowStepNode']> = ResolversObject<{
-    hasCompensation: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
-    kind: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    stepId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
-export type FlowSwitchNodeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['FlowSwitchNode'] = ResolversParentTypes['FlowSwitchNode']> = ResolversObject<{
-    branchIds: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
-    hasDefault: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
-    kind: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    stepId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
 export type GcStatsResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['GcStats'] = ResolversParentTypes['GcStats']> = ResolversObject<{
     collections: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
     duration: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
@@ -2085,15 +2001,17 @@ export type MiddlewareInterceptorOwnersSnapshotResolvers<ContextType = CustomGra
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type MiddlewareResourceUsageResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['MiddlewareResourceUsage'] = ResolversParentTypes['MiddlewareResourceUsage']> = ResolversObject<{
-    config: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+    config: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
     node: Resolver<ResolversTypes['Resource'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type MiddlewareTaskUsageResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['MiddlewareTaskUsage'] = ResolversParentTypes['MiddlewareTaskUsage']> = ResolversObject<{
-    config: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+    config: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
-    node: Resolver<ResolversTypes['Task'], ParentType, ContextType>;
+    node: Resolver<ResolversTypes['BaseElement'], ParentType, ContextType>;
+    origin: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    subtreeOwnerId: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type QueryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
@@ -2136,7 +2054,9 @@ export type ResourceResolvers<ContextType = CustomGraphQLContext, ParentType ext
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, ResourceFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     hasCooldown: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    hasDispose: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     hasHealthCheck: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    hasInit: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     hasReady: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
     isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
@@ -2145,7 +2065,7 @@ export type ResourceResolvers<ContextType = CustomGraphQLContext, ParentType ext
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     middleware: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     middlewareResolved: Resolver<Array<ResolversTypes['ResourceMiddleware']>, ParentType, ContextType>;
-    middlewareResolvedDetailed: Resolver<Array<ResolversTypes['TaskMiddlewareUsage']>, ParentType, ContextType>;
+    middlewareResolvedDetailed: Resolver<Array<ResolversTypes['ResourceMiddlewareUsage']>, ParentType, ContextType>;
     overrides: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     overridesResolved: Resolver<Array<ResolversTypes['BaseElement']>, ParentType, ContextType>;
     registeredBy: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -2210,19 +2130,48 @@ export type ResourceMiddlewareResolvers<ContextType = CustomGraphQLContext, Pare
     visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
-export type ResourceSubtreeBranchResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreeBranch'] = ResolversParentTypes['ResourceSubtreeBranch']> = ResolversObject<{
-    middleware: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
-    validatorCount: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+export type ResourceMiddlewareUsageResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceMiddlewareUsage'] = ResolversParentTypes['ResourceMiddlewareUsage']> = ResolversObject<{
+    config: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    node: Resolver<ResolversTypes['ResourceMiddleware'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceSubtreeIdentityRequirementResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreeIdentityRequirement'] = ResolversParentTypes['ResourceSubtreeIdentityRequirement']> = ResolversObject<{
+    roles: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    tenant: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    user: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceSubtreeIdentityScopeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreeIdentityScope'] = ResolversParentTypes['ResourceSubtreeIdentityScope']> = ResolversObject<{
+    required: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    tenant: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    user: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceSubtreeMiddlewareScopeResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreeMiddlewareScope'] = ResolversParentTypes['ResourceSubtreeMiddlewareScope']> = ResolversObject<{
+    identityScope: Resolver<Maybe<ResolversTypes['ResourceSubtreeIdentityScope']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type ResourceSubtreePolicyResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreePolicy'] = ResolversParentTypes['ResourceSubtreePolicy']> = ResolversObject<{
     events: Resolver<Maybe<ResolversTypes['ResourceSubtreeValidationBranch']>, ParentType, ContextType>;
     hooks: Resolver<Maybe<ResolversTypes['ResourceSubtreeValidationBranch']>, ParentType, ContextType>;
+    middleware: Resolver<Maybe<ResolversTypes['ResourceSubtreeMiddlewareScope']>, ParentType, ContextType>;
     resourceMiddleware: Resolver<Maybe<ResolversTypes['ResourceSubtreeValidationBranch']>, ParentType, ContextType>;
-    resources: Resolver<Maybe<ResolversTypes['ResourceSubtreeBranch']>, ParentType, ContextType>;
+    resources: Resolver<Maybe<ResolversTypes['ResourceSubtreeResourceBranch']>, ParentType, ContextType>;
     tags: Resolver<Maybe<ResolversTypes['ResourceSubtreeValidationBranch']>, ParentType, ContextType>;
     taskMiddleware: Resolver<Maybe<ResolversTypes['ResourceSubtreeValidationBranch']>, ParentType, ContextType>;
-    tasks: Resolver<Maybe<ResolversTypes['ResourceSubtreeBranch']>, ParentType, ContextType>;
+    tasks: Resolver<Maybe<ResolversTypes['ResourceSubtreeTaskBranch']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceSubtreeResourceBranchResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreeResourceBranch'] = ResolversParentTypes['ResourceSubtreeResourceBranch']> = ResolversObject<{
+    middleware: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    validatorCount: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceSubtreeTaskBranchResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreeTaskBranch'] = ResolversParentTypes['ResourceSubtreeTaskBranch']> = ResolversObject<{
+    identity: Resolver<Array<ResolversTypes['ResourceSubtreeIdentityRequirement']>, ParentType, ContextType>;
+    middleware: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    validatorCount: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type ResourceSubtreeValidationBranchResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreeValidationBranch'] = ResolversParentTypes['ResourceSubtreeValidationBranch']> = ResolversObject<{
@@ -2335,11 +2284,11 @@ export type TaskResolvers<ContextType = CustomGraphQLContext, ParentType extends
     dependsOnResolved: Resolver<ResolversTypes['TaskDependsOn'], ParentType, ContextType>;
     depenendsOnResolved: Resolver<Array<ResolversTypes['BaseElement']>, ParentType, ContextType>;
     durableResource: Resolver<Maybe<ResolversTypes['Resource']>, ParentType, ContextType>;
+    durableWorkflowKey: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     emits: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     emitsResolved: Resolver<Array<ResolversTypes['Event']>, ParentType, ContextType>;
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, TaskFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    flowShape: Resolver<Maybe<ResolversTypes['DurableFlowShape']>, ParentType, ContextType>;
     hasInterceptors: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
     inputSchema: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -2402,6 +2351,8 @@ export type TaskMiddlewareUsageResolvers<ContextType = CustomGraphQLContext, Par
     config: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
     node: Resolver<ResolversTypes['TaskMiddleware'], ParentType, ContextType>;
+    origin: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    subtreeOwnerId: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type Resolvers<ContextType = CustomGraphQLContext> = ResolversObject<{
@@ -2411,20 +2362,12 @@ export type Resolvers<ContextType = CustomGraphQLContext> = ResolversObject<{
     CoverageInfo: CoverageInfoResolvers<ContextType>;
     CpuStats: CpuStatsResolvers<ContextType>;
     Diagnostic: DiagnosticResolvers<ContextType>;
-    DurableFlowShape: DurableFlowShapeResolvers<ContextType>;
     EmissionEntry: EmissionEntryResolvers<ContextType>;
     Error: ErrorResolvers<ContextType>;
     ErrorEntry: ErrorEntryResolvers<ContextType>;
     Event: EventResolvers<ContextType>;
     EventLaneSummary: EventLaneSummaryResolvers<ContextType>;
     EventLoopStats: EventLoopStatsResolvers<ContextType>;
-    FlowEmitNode: FlowEmitNodeResolvers<ContextType>;
-    FlowNode: FlowNodeResolvers<ContextType>;
-    FlowNoteNode: FlowNoteNodeResolvers<ContextType>;
-    FlowSignalNode: FlowSignalNodeResolvers<ContextType>;
-    FlowSleepNode: FlowSleepNodeResolvers<ContextType>;
-    FlowStepNode: FlowStepNodeResolvers<ContextType>;
-    FlowSwitchNode: FlowSwitchNodeResolvers<ContextType>;
     GcStats: GcStatsResolvers<ContextType>;
     Hook: HookResolvers<ContextType>;
     InterceptorOwnersSnapshot: InterceptorOwnersSnapshotResolvers<ContextType>;
@@ -2450,8 +2393,13 @@ export type Resolvers<ContextType = CustomGraphQLContext> = ResolversObject<{
     ResourceHealthTotals: ResourceHealthTotalsResolvers<ContextType>;
     ResourceIsolation: ResourceIsolationResolvers<ContextType>;
     ResourceMiddleware: ResourceMiddlewareResolvers<ContextType>;
-    ResourceSubtreeBranch: ResourceSubtreeBranchResolvers<ContextType>;
+    ResourceMiddlewareUsage: ResourceMiddlewareUsageResolvers<ContextType>;
+    ResourceSubtreeIdentityRequirement: ResourceSubtreeIdentityRequirementResolvers<ContextType>;
+    ResourceSubtreeIdentityScope: ResourceSubtreeIdentityScopeResolvers<ContextType>;
+    ResourceSubtreeMiddlewareScope: ResourceSubtreeMiddlewareScopeResolvers<ContextType>;
     ResourceSubtreePolicy: ResourceSubtreePolicyResolvers<ContextType>;
+    ResourceSubtreeResourceBranch: ResourceSubtreeResourceBranchResolvers<ContextType>;
+    ResourceSubtreeTaskBranch: ResourceSubtreeTaskBranchResolvers<ContextType>;
     ResourceSubtreeValidationBranch: ResourceSubtreeValidationBranchResolvers<ContextType>;
     RpcLaneSummary: RpcLaneSummaryResolvers<ContextType>;
     RunDisposeOptions: RunDisposeOptionsResolvers<ContextType>;

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 import { dev } from "./resources/dev.resource";
+import { exportDocs } from "./exportDocs";
 export type { ServerConfig, ServerInstance } from "./resources/server.resource";
 export type { CustomGraphQLContext } from "./schema/context";
 export type { CoverageDetails, CoverageService, CoverageSummary, LineCoverage, } from "./resources/coverage.resource";
 export type { EmissionEntry, ErrorEntry, Live, LogEntry, LogLevel, RunRecord, } from "./resources/live.resource";
 export type { EvalResult, InvokeEventResult, InvokeResult, ISwapManager, SwapResult, SwappedTask, } from "./resources/swap.resource";
-export { Introspector, type SerializedIntrospector, } from "./resources/models/Introspector";
+export { Introspector, type InterceptorOwnersSnapshot, type MiddlewareInterceptorOwnerSnapshot, type SerializedIntrospector, } from "./resources/models/Introspector";
+export type { ExportDocsOptions, ExportDocsResult } from "./exportDocs";
 export * from "./schema/model";
 export declare const resources: {
     server: import("@bluelibs/runner").IResource<import("./resources/server.resource").ServerConfig, Promise<import("./resources/server.resource").ServerInstance>, {
@@ -128,3 +130,4 @@ export declare const resources: {
     }, import("@bluelibs/runner").ResourceTagType[], import("@bluelibs/runner").ResourceMiddlewareAttachmentType[]>;
 };
 export { dev };
+export { exportDocs };