@bluelibs/runner-dev 5.1.0 → 6.0.0

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

@@ -61,6 +61,8 @@ export type All = BaseElement & {
     filePath: Maybe<Scalars['String']['output']>;
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -69,6 +71,8 @@ export type All = BaseElement & {
     tags: Maybe<Array<Tag>>;
     /** Detailed tags associated with this element */
     tagsDetailed: Maybe<Array<TagUsage>>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 /** Minimal, generic element used for root and as a fallback when a specific concrete type cannot be resolved. */
 export type AllFileContentsArgs = {
@@ -88,6 +92,8 @@ export type AsyncContext = BaseElement & {
     filePath: Maybe<Scalars['String']['output']>;
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -106,6 +112,8 @@ export type AsyncContext = BaseElement & {
     tagsDetailed: Maybe<Array<TagUsage>>;
     /** Tasks and resources that use this async context as a dependency */
     usedBy: Array<All>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 /** An async context definition for request-scoped data propagation */
 export type AsyncContextFileContentsArgs = {
@@ -120,6 +128,8 @@ export type BaseElement = {
     filePath: Maybe<Scalars['String']['output']>;
     /** Stable identifier */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Optional metadata (title, description, tags) */
@@ -128,6 +138,8 @@ export type BaseElement = {
     tags: Maybe<Array<Tag>>;
     /** Detailed tags associated with this element */
     tagsDetailed: Maybe<Array<TagUsage>>;
+    /** Optional visibility explanation for this element. */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 /** Common fields for all runner elements */
 export type BaseElementFileContentsArgs = {
@@ -208,6 +220,8 @@ export type Error = BaseElement & {
     filePath: Maybe<Scalars['String']['output']>;
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -218,6 +232,8 @@ export type Error = BaseElement & {
     tagsDetailed: Maybe<Array<TagUsage>>;
     /** Tasks and resources that throw this error */
     thrownBy: Array<All>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 /** A defined application error that can be thrown by tasks or resources */
 export type ErrorFileContentsArgs = {
@@ -264,12 +280,16 @@ 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. */
+    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']>;
     /** Path to task file */
     filePath: Maybe<Scalars['String']['output']>;
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Ids of task/hook nodes listening to this event */
     listenedToBy: Array<Scalars['String']['output']>;
     /** Task/hook nodes listening to this event (resolved) */
@@ -278,6 +298,8 @@ export type Event = BaseElement & {
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
     meta: Maybe<Meta>;
+    /** Whether this event allows parallel listener execution. */
+    parallel: Scalars['Boolean']['output'];
     /** Prettified Zod JSON structure for the event payload schema, if provided */
     payloadSchema: Maybe<Scalars['String']['output']>;
     /** Readable text representation of the event payload schema, if provided */
@@ -286,10 +308,16 @@ export type Event = BaseElement & {
     registeredBy: Maybe<Scalars['String']['output']>;
     /** Resource that registered this event (resolved, if any) */
     registeredByResolved: Maybe<Resource>;
+    /** RPC lane summary derived from globals.tags.rpcLane when present. */
+    rpcLane: Maybe<RpcLaneSummary>;
     /** Tags associated with this element. */
     tags: Maybe<Array<Tag>>;
     /** Detailed tags associated with this element */
     tagsDetailed: Maybe<Array<TagUsage>>;
+    /** Whether this event uses transactional listener semantics. */
+    transactional: Scalars['Boolean']['output'];
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 export type EventFileContentsArgs = {
     endLine: InputMaybe<Scalars['Int']['input']>;
@@ -304,6 +332,12 @@ export type EventFilterInput = {
     /** Return only events whose id contains this substring. */
     idIncludes: InputMaybe<Scalars['String']['input']>;
 };
+export type EventLaneSummary = {
+    __typename?: 'EventLaneSummary';
+    laneId: Scalars['String']['output'];
+    metadata: Maybe<Scalars['String']['output']>;
+    orderingKey: Maybe<Scalars['String']['output']>;
+};
 export type EventLoopStats = {
     __typename?: 'EventLoopStats';
     /** Average event loop delay (ms) measured via monitorEventLoopDelay */
@@ -374,15 +408,6 @@ export type GcStats = {
     /** Total time spent in GC (ms) since process start */
     duration: Scalars['Float']['output'];
 };
-export type GlobalMiddleware = {
-    __typename?: 'GlobalMiddleware';
-    /** Whether the middleware is active globally */
-    enabled: Scalars['Boolean']['output'];
-    /** Globally enabled for resources */
-    resources: Scalars['Boolean']['output'];
-    /** Globally enabled for tasks */
-    tasks: Scalars['Boolean']['output'];
-};
 export type Hook = BaseElement & {
     __typename?: 'Hook';
     /** Coverage summary for this element's file (percentage is always resolvable if coverage report is present). */
@@ -413,6 +438,8 @@ export type Hook = BaseElement & {
     inputSchema: Maybe<Scalars['String']['output']>;
     /** Readable text representation of the input schema, if provided */
     inputSchemaReadable: Maybe<Scalars['String']['output']>;
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -435,6 +462,8 @@ export type Hook = BaseElement & {
     tags: Maybe<Array<Tag>>;
     /** Detailed tags associated with this element */
     tagsDetailed: Maybe<Array<TagUsage>>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 export type HookFileContentsArgs = {
     endLine: InputMaybe<Scalars['Int']['input']>;
@@ -445,6 +474,25 @@ export type HookRunsArgs = {
     filter: InputMaybe<RunFilterInput>;
     last: InputMaybe<Scalars['Int']['input']>;
 };
+export type InterceptorOwnersSnapshot = {
+    __typename?: 'InterceptorOwnersSnapshot';
+    middleware: MiddlewareInterceptorOwnersSnapshot;
+    tasksById: Array<TaskInterceptorOwnersEntry>;
+};
+export type IsolationChannels = {
+    __typename?: 'IsolationChannels';
+    dependencies: Maybe<Scalars['Boolean']['output']>;
+    listening: Maybe<Scalars['Boolean']['output']>;
+    middleware: Maybe<Scalars['Boolean']['output']>;
+    tagging: Maybe<Scalars['Boolean']['output']>;
+};
+export type IsolationExportsMode = 'list' | 'none' | 'unset';
+export type IsolationWhitelistEntry = {
+    __typename?: 'IsolationWhitelistEntry';
+    channels: Maybe<IsolationChannels>;
+    for: Array<Scalars['String']['output']>;
+    targets: Array<Scalars['String']['output']>;
+};
 /** Real-time telemetry access: logs, event emissions, errors, runs, and system health. */
 export type Live = {
     __typename?: 'Live';
@@ -458,6 +506,8 @@ export type Live = {
     eventLoop: EventLoopStats;
     /** Garbage collector statistics. By default totals since process start; when windowMs provided, returns stats within that window. */
     gc: GcStats;
+    /** Per-resource health report. Only includes resources with a health() probe defined. */
+    healthReport: Maybe<ResourceHealthReport>;
     /** Live logs with optional timestamp cursor, filters and last N */
     logs: Array<LogEntry>;
     /** Process memory usage */
@@ -548,6 +598,8 @@ export type MetaTagUsage = {
 };
 export type Middleware = BaseElement & {
     __typename?: 'Middleware';
+    /** Automatic middleware application configuration. */
+    autoApply: MiddlewareAutoApply;
     /** Prettified Zod JSON structure for the middleware config schema, if provided */
     configSchema: Maybe<Scalars['String']['output']>;
     /** Readable text representation of the middleware config schema, if provided */
@@ -562,10 +614,10 @@ export type Middleware = BaseElement & {
     fileContents: Maybe<Scalars['String']['output']>;
     /** Path to task file */
     filePath: Maybe<Scalars['String']['output']>;
-    /** Global middleware configuration */
-    global: Maybe<GlobalMiddleware>;
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -592,11 +644,35 @@ export type Middleware = BaseElement & {
     usedByTasksDetailed: Array<MiddlewareTaskUsage>;
     /** Task/hook nodes that use this middleware (resolved) */
     usedByTasksResolved: Array<Task>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 export type MiddlewareFileContentsArgs = {
     endLine: InputMaybe<Scalars['Int']['input']>;
     startLine: InputMaybe<Scalars['Int']['input']>;
 };
+export type MiddlewareApplyScope = 'subtree' | 'where-visible';
+export type MiddlewareAutoApply = {
+    __typename?: 'MiddlewareAutoApply';
+    /** Whether middleware auto-application is enabled. */
+    enabled: Scalars['Boolean']['output'];
+    /** True when a predicate was provided to further filter auto-application targets. */
+    hasPredicate: Scalars['Boolean']['output'];
+    /** Auto-application scope. `where-visible` respects isolation visibility, `subtree` stays within owner subtree. */
+    scope: Maybe<MiddlewareApplyScope>;
+};
+export type MiddlewareInterceptorOwnersEntry = {
+    __typename?: 'MiddlewareInterceptorOwnersEntry';
+    middlewareId: Scalars['String']['output'];
+    ownerResourceIds: Array<Scalars['String']['output']>;
+};
+export type MiddlewareInterceptorOwnersSnapshot = {
+    __typename?: 'MiddlewareInterceptorOwnersSnapshot';
+    globalResourceInterceptorOwnerIds: Array<Scalars['String']['output']>;
+    globalTaskInterceptorOwnerIds: Array<Scalars['String']['output']>;
+    perResourceMiddlewareInterceptorOwnerIds: Array<MiddlewareInterceptorOwnersEntry>;
+    perTaskMiddlewareInterceptorOwnerIds: Array<MiddlewareInterceptorOwnersEntry>;
+};
 export type MiddlewareResourceUsage = {
     __typename?: 'MiddlewareResourceUsage';
     config: Maybe<Scalars['ID']['output']>;
@@ -634,6 +710,8 @@ export type Query = {
     hook: Maybe<Hook>;
     /** Get all hooks (optionally filter by id prefix). */
     hooks: Array<Hook>;
+    /** Snapshot of interceptor ownership: local task interceptors by task id and middleware interceptor ownership from middleware manager. */
+    interceptorOwners: InterceptorOwnersSnapshot;
     /** Access live telemetry (logs, emissions, errors, runs, system stats). Always use filters and last to limit payload. */
     live: Live;
     /** Get a single middleware by its id. */
@@ -648,6 +726,8 @@ export type Query = {
     resources: Array<Resource>;
     /** Root application 'resource'. This is what the main run() received as argument. */
     root: Maybe<Resource>;
+    /** Effective run options used when starting the application via run(). Includes mode, debug flag, and root resource id. */
+    runOptions: RunOptions;
     /** List of tasks currently hot-swapped. */
     swappedTasks: Array<SwappedTask>;
     /** Get reverse usage for a tag id. Returns usedBy lists split by kind. */
@@ -757,8 +837,18 @@ export type Resource = BaseElement & {
     fileContents: Maybe<Scalars['String']['output']>;
     /** Path to task file */
     filePath: Maybe<Scalars['String']['output']>;
+    /** True when this resource defines a cooldown() lifecycle hook. */
+    hasCooldown: Scalars['Boolean']['output'];
+    /** True when this resource defines a health() probe for runtime health reports. */
+    hasHealthCheck: Scalars['Boolean']['output'];
+    /** True when this resource defines a ready() lifecycle hook. */
+    hasReady: Scalars['Boolean']['output'];
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
+    /** Resource isolation policy generated from .isolate({ deny/only/exports }). */
+    isolation: Maybe<ResourceIsolation>;
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -781,21 +871,60 @@ export type Resource = BaseElement & {
     registers: Array<Scalars['String']['output']>;
     /** The items registered by this resource (resolved) */
     registersResolved: Array<BaseElement>;
+    /** Resource subtree governance policy summary from resource.subtree(...). */
+    subtree: Maybe<ResourceSubtreePolicy>;
     /** Tags associated with this element. */
     tags: Maybe<Array<Tag>>;
     /** Detailed tags associated with this element */
     tagsDetailed: Maybe<Array<TagUsage>>;
-    /** Tunnel configuration (present when resource has tunnel tag) */
-    tunnelInfo: Maybe<TunnelInfo>;
     /** Task nodes using this resource (resolved) */
     usedBy: Array<Task>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 export type ResourceFileContentsArgs = {
     endLine: InputMaybe<Scalars['Int']['input']>;
     startLine: InputMaybe<Scalars['Int']['input']>;
 };
+export type ResourceHealthEntry = {
+    __typename?: 'ResourceHealthEntry';
+    /** Serialized details from the health probe */
+    details: Maybe<Scalars['String']['output']>;
+    /** Resource identifier */
+    id: Scalars['String']['output'];
+    /** Whether the resource has been initialized */
+    initialized: Scalars['Boolean']['output'];
+    /** Optional status message from the health probe */
+    message: Maybe<Scalars['String']['output']>;
+    /** Health status: healthy, degraded, or unhealthy */
+    status: ResourceHealthStatus;
+};
+export type ResourceHealthReport = {
+    __typename?: 'ResourceHealthReport';
+    report: Array<ResourceHealthEntry>;
+    totals: ResourceHealthTotals;
+};
+export type ResourceHealthStatus = 'degraded' | 'healthy' | 'unhealthy';
+export type ResourceHealthTotals = {
+    __typename?: 'ResourceHealthTotals';
+    degraded: Scalars['Int']['output'];
+    healthy: Scalars['Int']['output'];
+    /** Total number of health-enabled resources */
+    resources: Scalars['Int']['output'];
+    unhealthy: Scalars['Int']['output'];
+};
+export type ResourceIsolation = {
+    __typename?: 'ResourceIsolation';
+    deny: Array<Scalars['String']['output']>;
+    exports: Array<Scalars['String']['output']>;
+    exportsMode: IsolationExportsMode;
+    only: Array<Scalars['String']['output']>;
+    whitelist: Array<IsolationWhitelistEntry>;
+};
 export type ResourceMiddleware = BaseElement & {
     __typename?: 'ResourceMiddleware';
+    /** Automatic middleware application configuration. */
+    autoApply: MiddlewareAutoApply;
     /** Prettified Zod JSON structure for the middleware config schema, if provided */
     configSchema: Maybe<Scalars['String']['output']>;
     /** Readable text representation of the middleware config schema, if provided */
@@ -810,10 +939,10 @@ export type ResourceMiddleware = BaseElement & {
     fileContents: Maybe<Scalars['String']['output']>;
     /** Path to task file */
     filePath: Maybe<Scalars['String']['output']>;
-    /** Global middleware configuration */
-    global: Maybe<GlobalMiddleware>;
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -832,11 +961,54 @@ export type ResourceMiddleware = BaseElement & {
     usedBy: Array<Resource>;
     /** Detailed resource usages with per-usage config */
     usedByDetailed: Array<MiddlewareResourceUsage>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 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 ResourceSubtreePolicy = {
+    __typename?: 'ResourceSubtreePolicy';
+    events: Maybe<ResourceSubtreeValidationBranch>;
+    hooks: Maybe<ResourceSubtreeValidationBranch>;
+    resourceMiddleware: Maybe<ResourceSubtreeValidationBranch>;
+    resources: Maybe<ResourceSubtreeBranch>;
+    tags: Maybe<ResourceSubtreeValidationBranch>;
+    taskMiddleware: Maybe<ResourceSubtreeValidationBranch>;
+    tasks: Maybe<ResourceSubtreeBranch>;
+};
+export type ResourceSubtreeValidationBranch = {
+    __typename?: 'ResourceSubtreeValidationBranch';
+    validatorCount: Scalars['Int']['output'];
+};
+export type RpcLaneSummary = {
+    __typename?: 'RpcLaneSummary';
+    laneId: Scalars['String']['output'];
+};
+/** Effective shutdown disposal configuration used by run(). */
+export type RunDisposeOptions = {
+    __typename?: 'RunDisposeOptions';
+    /** Post-cooldown admission window in milliseconds during shutdown. Null when unknown. */
+    cooldownWindowMs: Maybe<Scalars['Float']['output']>;
+    /** Drain wait budget in milliseconds during shutdown. Null when unknown. */
+    drainingBudgetMs: Maybe<Scalars['Float']['output']>;
+    /** Total shutdown disposal budget in milliseconds. Null when unknown. */
+    totalBudgetMs: Maybe<Scalars['Float']['output']>;
+};
+/** Effective execution context configuration used by run(). */
+export type RunExecutionContextOptions = {
+    __typename?: 'RunExecutionContextOptions';
+    /** Whether execution-context cycle detection is enabled. Null when disabled or unknown. */
+    cycleDetection: Maybe<Scalars['Boolean']['output']>;
+    /** Whether execution context capture is enabled. */
+    enabled: Scalars['Boolean']['output'];
+};
 /** Filters for execution run records */
 export type RunFilterInput = {
     /** Filter by correlation ids */
@@ -852,6 +1024,42 @@ export type RunFilterInput = {
     /** Only include runs with specific root ids */
     rootIds: InputMaybe<Array<Scalars['String']['input']>>;
 };
+/** Effective run options that were used when starting the application via run(). */
+export type RunOptions = {
+    __typename?: 'RunOptions';
+    /** Whether the debug resource was enabled at startup. True when run() received a debug option. */
+    debug: Scalars['Boolean']['output'];
+    /** High-level debug mode summary: "normal", "verbose", "custom", or "disabled". */
+    debugMode: Maybe<Scalars['String']['output']>;
+    /** Effective shutdown disposal configuration. */
+    dispose: RunDisposeOptions;
+    /** Whether startup runs in dry-run mode. */
+    dryRun: Scalars['Boolean']['output'];
+    /** Whether process-level error boundaries are enabled. Null when unknown. */
+    errorBoundary: Maybe<Scalars['Boolean']['output']>;
+    /** Effective execution context configuration. */
+    executionContext: RunExecutionContextOptions;
+    /** Presence flag for an onUnhandledError callback. */
+    hasOnUnhandledError: Scalars['Boolean']['output'];
+    /** Whether lazy resource mode is enabled. */
+    lazy: Scalars['Boolean']['output'];
+    /** Startup/disposal scheduler mode: "sequential" or "parallel". */
+    lifecycleMode: Scalars['String']['output'];
+    /** Whether the logger buffers logs in memory. */
+    logsBuffer: Scalars['Boolean']['output'];
+    /** Whether logger output is printed. False when printThreshold is null. */
+    logsEnabled: Scalars['Boolean']['output'];
+    /** Effective logger print strategy when available. */
+    logsPrintStrategy: Maybe<Scalars['String']['output']>;
+    /** Effective logger print threshold, or null when disabled. */
+    logsPrintThreshold: Maybe<Scalars['String']['output']>;
+    /** The mode in which the runner is operating: "dev", "prod", or "test". */
+    mode: Scalars['String']['output'];
+    /** The id of the root resource passed to run(). */
+    rootId: Scalars['String']['output'];
+    /** Whether SIGINT/SIGTERM shutdown hooks are enabled. Null when unknown. */
+    shutdownHooks: Maybe<Scalars['Boolean']['output']>;
+};
 export type RunRecord = {
     __typename?: 'RunRecord';
     /** Correlation id for tracing */
@@ -898,6 +1106,7 @@ export type Tag = BaseElement & {
     coverage: Maybe<CoverageInfo>;
     /** Raw coverage report contents from the project (entire file), or null if not available. */
     coverageContents: Maybe<Scalars['String']['output']>;
+    errors: Array<Error>;
     events: Array<Event>;
     /** 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']>;
@@ -906,22 +1115,29 @@ export type Tag = BaseElement & {
     hooks: Array<Hook>;
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
     meta: Maybe<Meta>;
-    middlewares: Array<Middleware>;
+    resourceMiddlewares: Array<ResourceMiddleware>;
     resources: Array<Resource>;
     /** Tags associated with this element. */
     tags: Maybe<Array<Tag>>;
     /** Detailed tags associated with this element */
     tagsDetailed: Maybe<Array<TagUsage>>;
+    targets: Array<TagTarget>;
+    taskMiddlewares: Array<TaskMiddleware>;
     tasks: Array<Task>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 export type TagFileContentsArgs = {
     endLine: InputMaybe<Scalars['Int']['input']>;
     startLine: InputMaybe<Scalars['Int']['input']>;
 };
+export type TagTarget = 'errors' | 'events' | 'hooks' | 'resources' | 'resourceMiddlewares' | 'tasks' | 'taskMiddlewares';
 export type TagUsage = {
     __typename?: 'TagUsage';
     config: Maybe<Scalars['String']['output']>;
@@ -952,14 +1168,22 @@ export type Task = BaseElement & {
     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 */
     id: Scalars['ID']['output'];
     /** Prettified Zod JSON structure for the input schema, if provided */
     inputSchema: Maybe<Scalars['String']['output']>;
     /** Readable text representation of the input schema, if provided */
     inputSchemaReadable: Maybe<Scalars['String']['output']>;
+    /** Number of runtime task interceptors registered via taskDependency.intercept(...). */
+    interceptorCount: Scalars['Int']['output'];
+    /** Resource ids that registered local task interceptors for this task. */
+    interceptorOwnerIds: Array<Scalars['String']['output']>;
     /** Whether this task is a durable workflow (tagged with durable.workflow) */
     isDurable: Scalars['Boolean']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -976,12 +1200,16 @@ export type Task = BaseElement & {
     registeredBy: Maybe<Scalars['String']['output']>;
     /** Resource that registered this task (resolved, if any) */
     registeredByResolved: Maybe<Resource>;
+    /** RPC lane summary derived from globals.tags.rpcLane when present. */
+    rpcLane: Maybe<RpcLaneSummary>;
     /** Execution run records for this task */
     runs: Array<RunRecord>;
     /** Tags associated with this element. */
     tags: Maybe<Array<Tag>>;
     /** Detailed tags associated with this element */
     tagsDetailed: Maybe<Array<TagUsage>>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 export type TaskFileContentsArgs = {
     endLine: InputMaybe<Scalars['Int']['input']>;
@@ -1003,8 +1231,15 @@ export type TaskDependsOn = {
     /** Tasks this task depends on */
     tasks: Array<BaseElement>;
 };
+export type TaskInterceptorOwnersEntry = {
+    __typename?: 'TaskInterceptorOwnersEntry';
+    ownerResourceIds: Array<Scalars['String']['output']>;
+    taskId: Scalars['String']['output'];
+};
 export type TaskMiddleware = BaseElement & {
     __typename?: 'TaskMiddleware';
+    /** Automatic middleware application configuration. */
+    autoApply: MiddlewareAutoApply;
     /** Prettified Zod JSON structure for the middleware config schema, if provided */
     configSchema: Maybe<Scalars['String']['output']>;
     /** Readable text representation of the middleware config schema, if provided */
@@ -1019,10 +1254,10 @@ export type TaskMiddleware = BaseElement & {
     fileContents: Maybe<Scalars['String']['output']>;
     /** Path to task file */
     filePath: Maybe<Scalars['String']['output']>;
-    /** Global middleware configuration */
-    global: Maybe<GlobalMiddleware>;
     /** Unique identifier for the element */
     id: Scalars['ID']['output'];
+    /** True when this element is private to a resource boundary defined by isolate(). */
+    isPrivate: Scalars['Boolean']['output'];
     /** Markdown composed from meta.title and meta.description (if present) */
     markdownDescription: Scalars['String']['output'];
     /** Metadata for the element */
@@ -1041,6 +1276,8 @@ export type TaskMiddleware = BaseElement & {
     usedBy: Array<Task>;
     /** Detailed task/hook usages with per-usage config */
     usedByDetailed: Array<MiddlewareTaskUsage>;
+    /** Optional visibility explanation (useful for debugging isolate() boundaries). */
+    visibilityReason: Maybe<Scalars['String']['output']>;
 };
 export type TaskMiddlewareFileContentsArgs = {
     endLine: InputMaybe<Scalars['Int']['input']>;
@@ -1052,34 +1289,6 @@ export type TaskMiddlewareUsage = {
     id: Scalars['ID']['output'];
     node: TaskMiddleware;
 };
-/** How events are delivered between local and remote runtimes */
-export type TunnelEventDeliveryMode = 'local-only' | 'mirror' | 'remote-first' | 'remote-only';
-/** Tunnel configuration and routing information */
-export type TunnelInfo = {
-    __typename?: 'TunnelInfo';
-    /** Authentication method used by the tunnel */
-    auth: Maybe<Scalars['String']['output']>;
-    /** Remote endpoint URL (for client tunnels) */
-    endpoint: Maybe<Scalars['String']['output']>;
-    /** How events are delivered between local and remote runtimes */
-    eventDeliveryMode: Maybe<TunnelEventDeliveryMode>;
-    /** Event IDs tunneled through this resource */
-    events: Maybe<Array<Scalars['String']['output']>>;
-    /** Events tunneled through this resource (resolved) */
-    eventsResolved: Maybe<Array<Event>>;
-    /** Tunnel operation mode */
-    mode: TunnelMode;
-    /** Task IDs tunneled through this resource */
-    tasks: Maybe<Array<Scalars['String']['output']>>;
-    /** Tasks tunneled through this resource (resolved) */
-    tasksResolved: Maybe<Array<Task>>;
-    /** Transport mechanism used by the tunnel */
-    transport: TunnelTransport;
-};
-/** Tunnel operation mode */
-export type TunnelMode = 'both' | 'client' | 'server';
-/** Tunnel transport mechanism */
-export type TunnelTransport = 'http' | 'other';
 export type WithIndex<TObject> = TObject & Record<string, any>;
 export type ResolversObject<TObject> = WithIndex<TObject>;
 export type ResolverTypeWrapper<T> = Promise<T> | T;
@@ -1137,7 +1346,8 @@ export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> =
         registeredByResolved: Maybe<_RefType['Resource']>;
         runs: Array<_RefType['RunRecord']>;
         tags: Maybe<Array<_RefType['Tag']>>;
-    }) | (Omit<Middleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedByResourcesDetailed' | 'usedByResourcesResolved' | 'usedByTasksDetailed' | 'usedByTasksResolved'> & {
+    }) | (Omit<Middleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedByResourcesDetailed' | 'usedByResourcesResolved' | 'usedByTasksDetailed' | 'usedByTasksResolved'> & {
+        autoApply: _RefType['MiddlewareAutoApply'];
         emits: Array<_RefType['Event']>;
         registeredByResolved: Maybe<_RefType['Resource']>;
         tags: Maybe<Array<_RefType['Tag']>>;
@@ -1145,7 +1355,7 @@ export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> =
         usedByResourcesResolved: Array<_RefType['Resource']>;
         usedByTasksDetailed: Array<_RefType['MiddlewareTaskUsage']>;
         usedByTasksResolved: Array<_RefType['Task']>;
-    }) | (Omit<Resource, 'dependsOnResolved' | 'emits' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'overridesResolved' | 'registeredByResolved' | 'registersResolved' | 'tags' | 'tunnelInfo' | 'usedBy'> & {
+    }) | (Omit<Resource, 'dependsOnResolved' | 'emits' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'overridesResolved' | 'registeredByResolved' | 'registersResolved' | 'tags' | 'usedBy'> & {
         dependsOnResolved: Array<_RefType['Resource']>;
         emits: Array<_RefType['Event']>;
         middlewareResolved: Array<_RefType['ResourceMiddleware']>;
@@ -1154,21 +1364,23 @@ export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> =
         registeredByResolved: Maybe<_RefType['Resource']>;
         registersResolved: Array<_RefType['BaseElement']>;
         tags: Maybe<Array<_RefType['Tag']>>;
-        tunnelInfo: Maybe<_RefType['TunnelInfo']>;
         usedBy: Array<_RefType['Task']>;
-    }) | (Omit<ResourceMiddleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+    }) | (Omit<ResourceMiddleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+        autoApply: _RefType['MiddlewareAutoApply'];
         emits: Array<_RefType['Event']>;
         registeredByResolved: Maybe<_RefType['Resource']>;
         tags: Maybe<Array<_RefType['Tag']>>;
         usedBy: Array<_RefType['Resource']>;
         usedByDetailed: Array<_RefType['MiddlewareResourceUsage']>;
-    }) | (Omit<Tag, 'all' | 'events' | 'hooks' | 'middlewares' | 'resources' | 'tags' | 'tasks'> & {
+    }) | (Omit<Tag, 'all' | 'errors' | 'events' | 'hooks' | 'resourceMiddlewares' | 'resources' | 'tags' | 'taskMiddlewares' | 'tasks'> & {
         all: Array<_RefType['BaseElement']>;
+        errors: Array<_RefType['Error']>;
         events: Array<_RefType['Event']>;
         hooks: Array<_RefType['Hook']>;
-        middlewares: Array<_RefType['Middleware']>;
+        resourceMiddlewares: Array<_RefType['ResourceMiddleware']>;
         resources: Array<_RefType['Resource']>;
         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'> & {
         dependsOnResolved: _RefType['TaskDependsOn'];
@@ -1181,7 +1393,8 @@ export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> =
         registeredByResolved: Maybe<_RefType['Resource']>;
         runs: Array<_RefType['RunRecord']>;
         tags: Maybe<Array<_RefType['Tag']>>;
-    }) | (Omit<TaskMiddleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+    }) | (Omit<TaskMiddleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+        autoApply: _RefType['MiddlewareAutoApply'];
         emits: Array<_RefType['Event']>;
         registeredByResolved: Maybe<_RefType['Resource']>;
         tags: Maybe<Array<_RefType['Tag']>>;
@@ -1228,6 +1441,7 @@ export type ResolversTypes = ResolversObject<{
         tags: Maybe<Array<ResolversTypes['Tag']>>;
     }>;
     EventFilterInput: EventFilterInput;
+    EventLaneSummary: ResolverTypeWrapper<EventLaneSummary>;
     EventLoopStats: ResolverTypeWrapper<EventLoopStats>;
     Float: ResolverTypeWrapper<Scalars['Float']['output']>;
     FlowEmitNode: ResolverTypeWrapper<FlowEmitNode>;
@@ -1238,7 +1452,6 @@ export type ResolversTypes = ResolversObject<{
     FlowStepNode: ResolverTypeWrapper<FlowStepNode>;
     FlowSwitchNode: ResolverTypeWrapper<FlowSwitchNode>;
     GcStats: ResolverTypeWrapper<GcStats>;
-    GlobalMiddleware: ResolverTypeWrapper<GlobalMiddleware>;
     Hook: ResolverTypeWrapper<Omit<Hook, 'depenendsOnResolved' | 'emitsResolved' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
         depenendsOnResolved: Array<ResolversTypes['BaseElement']>;
         emitsResolved: Array<ResolversTypes['Event']>;
@@ -1250,6 +1463,10 @@ export type ResolversTypes = ResolversObject<{
     }>;
     ID: ResolverTypeWrapper<Scalars['ID']['output']>;
     Int: ResolverTypeWrapper<Scalars['Int']['output']>;
+    InterceptorOwnersSnapshot: ResolverTypeWrapper<InterceptorOwnersSnapshot>;
+    IsolationChannels: ResolverTypeWrapper<IsolationChannels>;
+    IsolationExportsMode: null;
+    IsolationWhitelistEntry: ResolverTypeWrapper<IsolationWhitelistEntry>;
     Live: ResolverTypeWrapper<Omit<Live, 'emissions' | 'errors' | 'runs'> & {
         emissions: Array<ResolversTypes['EmissionEntry']>;
         errors: Array<ResolversTypes['ErrorEntry']>;
@@ -1261,7 +1478,8 @@ export type ResolversTypes = ResolversObject<{
     MemoryStats: ResolverTypeWrapper<MemoryStats>;
     Meta: ResolverTypeWrapper<Meta>;
     MetaTagUsage: ResolverTypeWrapper<MetaTagUsage>;
-    Middleware: ResolverTypeWrapper<Omit<Middleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedByResourcesDetailed' | 'usedByResourcesResolved' | 'usedByTasksDetailed' | 'usedByTasksResolved'> & {
+    Middleware: ResolverTypeWrapper<Omit<Middleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedByResourcesDetailed' | 'usedByResourcesResolved' | 'usedByTasksDetailed' | 'usedByTasksResolved'> & {
+        autoApply: ResolversTypes['MiddlewareAutoApply'];
         emits: Array<ResolversTypes['Event']>;
         registeredByResolved: Maybe<ResolversTypes['Resource']>;
         tags: Maybe<Array<ResolversTypes['Tag']>>;
@@ -1270,6 +1488,10 @@ export type ResolversTypes = ResolversObject<{
         usedByTasksDetailed: Array<ResolversTypes['MiddlewareTaskUsage']>;
         usedByTasksResolved: Array<ResolversTypes['Task']>;
     }>;
+    MiddlewareApplyScope: null;
+    MiddlewareAutoApply: ResolverTypeWrapper<MiddlewareAutoApply>;
+    MiddlewareInterceptorOwnersEntry: ResolverTypeWrapper<MiddlewareInterceptorOwnersEntry>;
+    MiddlewareInterceptorOwnersSnapshot: ResolverTypeWrapper<MiddlewareInterceptorOwnersSnapshot>;
     MiddlewareResourceUsage: ResolverTypeWrapper<Omit<MiddlewareResourceUsage, 'node'> & {
         node: ResolversTypes['Resource'];
     }>;
@@ -1278,7 +1500,7 @@ export type ResolversTypes = ResolversObject<{
     }>;
     NodeKindEnum: NodeKindEnum;
     Query: ResolverTypeWrapper<{}>;
-    Resource: ResolverTypeWrapper<Omit<Resource, 'dependsOnResolved' | 'emits' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'overridesResolved' | 'registeredByResolved' | 'registersResolved' | 'tags' | 'tunnelInfo' | 'usedBy'> & {
+    Resource: ResolverTypeWrapper<Omit<Resource, 'dependsOnResolved' | 'emits' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'overridesResolved' | 'registeredByResolved' | 'registersResolved' | 'tags' | 'usedBy'> & {
         dependsOnResolved: Array<ResolversTypes['Resource']>;
         emits: Array<ResolversTypes['Event']>;
         middlewareResolved: Array<ResolversTypes['ResourceMiddleware']>;
@@ -1287,17 +1509,29 @@ export type ResolversTypes = ResolversObject<{
         registeredByResolved: Maybe<ResolversTypes['Resource']>;
         registersResolved: Array<ResolversTypes['BaseElement']>;
         tags: Maybe<Array<ResolversTypes['Tag']>>;
-        tunnelInfo: Maybe<ResolversTypes['TunnelInfo']>;
         usedBy: Array<ResolversTypes['Task']>;
     }>;
-    ResourceMiddleware: ResolverTypeWrapper<Omit<ResourceMiddleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+    ResourceHealthEntry: ResolverTypeWrapper<ResourceHealthEntry>;
+    ResourceHealthReport: ResolverTypeWrapper<ResourceHealthReport>;
+    ResourceHealthStatus: ResourceHealthStatus;
+    ResourceHealthTotals: ResolverTypeWrapper<ResourceHealthTotals>;
+    ResourceIsolation: ResolverTypeWrapper<ResourceIsolation>;
+    ResourceMiddleware: ResolverTypeWrapper<Omit<ResourceMiddleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+        autoApply: ResolversTypes['MiddlewareAutoApply'];
         emits: Array<ResolversTypes['Event']>;
         registeredByResolved: Maybe<ResolversTypes['Resource']>;
         tags: Maybe<Array<ResolversTypes['Tag']>>;
         usedBy: Array<ResolversTypes['Resource']>;
         usedByDetailed: Array<ResolversTypes['MiddlewareResourceUsage']>;
     }>;
+    ResourceSubtreeBranch: ResolverTypeWrapper<ResourceSubtreeBranch>;
+    ResourceSubtreePolicy: ResolverTypeWrapper<ResourceSubtreePolicy>;
+    ResourceSubtreeValidationBranch: ResolverTypeWrapper<ResourceSubtreeValidationBranch>;
+    RpcLaneSummary: ResolverTypeWrapper<RpcLaneSummary>;
+    RunDisposeOptions: ResolverTypeWrapper<RunDisposeOptions>;
+    RunExecutionContextOptions: ResolverTypeWrapper<RunExecutionContextOptions>;
     RunFilterInput: RunFilterInput;
+    RunOptions: ResolverTypeWrapper<RunOptions>;
     RunRecord: ResolverTypeWrapper<Omit<RunRecord, 'nodeResolved'> & {
         nodeResolved: Maybe<ResolversTypes['BaseElement']>;
     }>;
@@ -1305,15 +1539,18 @@ export type ResolversTypes = ResolversObject<{
     String: ResolverTypeWrapper<Scalars['String']['output']>;
     SwapResult: ResolverTypeWrapper<SwapResult>;
     SwappedTask: ResolverTypeWrapper<SwappedTask>;
-    Tag: ResolverTypeWrapper<Omit<Tag, 'all' | 'events' | 'hooks' | 'middlewares' | 'resources' | 'tags' | 'tasks'> & {
+    Tag: ResolverTypeWrapper<Omit<Tag, 'all' | 'errors' | 'events' | 'hooks' | 'resourceMiddlewares' | 'resources' | 'tags' | 'taskMiddlewares' | 'tasks'> & {
         all: Array<ResolversTypes['BaseElement']>;
+        errors: Array<ResolversTypes['Error']>;
         events: Array<ResolversTypes['Event']>;
         hooks: Array<ResolversTypes['Hook']>;
-        middlewares: Array<ResolversTypes['Middleware']>;
+        resourceMiddlewares: Array<ResolversTypes['ResourceMiddleware']>;
         resources: Array<ResolversTypes['Resource']>;
         tags: Maybe<Array<ResolversTypes['Tag']>>;
+        taskMiddlewares: Array<ResolversTypes['TaskMiddleware']>;
         tasks: Array<ResolversTypes['Task']>;
     }>;
+    TagTarget: null;
     TagUsage: ResolverTypeWrapper<TagUsage>;
     Task: ResolverTypeWrapper<Omit<Task, 'dependsOnResolved' | 'depenendsOnResolved' | 'durableResource' | 'emitsResolved' | 'flowShape' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
         dependsOnResolved: ResolversTypes['TaskDependsOn'];
@@ -1333,7 +1570,9 @@ export type ResolversTypes = ResolversObject<{
         resources: Array<ResolversTypes['Resource']>;
         tasks: Array<ResolversTypes['BaseElement']>;
     }>;
-    TaskMiddleware: ResolverTypeWrapper<Omit<TaskMiddleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+    TaskInterceptorOwnersEntry: ResolverTypeWrapper<TaskInterceptorOwnersEntry>;
+    TaskMiddleware: ResolverTypeWrapper<Omit<TaskMiddleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+        autoApply: ResolversTypes['MiddlewareAutoApply'];
         emits: Array<ResolversTypes['Event']>;
         registeredByResolved: Maybe<ResolversTypes['Resource']>;
         tags: Maybe<Array<ResolversTypes['Tag']>>;
@@ -1343,13 +1582,6 @@ export type ResolversTypes = ResolversObject<{
     TaskMiddlewareUsage: ResolverTypeWrapper<Omit<TaskMiddlewareUsage, 'node'> & {
         node: ResolversTypes['TaskMiddleware'];
     }>;
-    TunnelEventDeliveryMode: null;
-    TunnelInfo: ResolverTypeWrapper<Omit<TunnelInfo, 'eventsResolved' | 'tasksResolved'> & {
-        eventsResolved: Maybe<Array<ResolversTypes['Event']>>;
-        tasksResolved: Maybe<Array<ResolversTypes['Task']>>;
-    }>;
-    TunnelMode: TunnelMode;
-    TunnelTransport: TunnelTransport;
 }>;
 /** Mapping between all available schema types and the resolvers parents */
 export type ResolversParentTypes = ResolversObject<{
@@ -1390,6 +1622,7 @@ export type ResolversParentTypes = ResolversObject<{
         tags: Maybe<Array<ResolversParentTypes['Tag']>>;
     };
     EventFilterInput: EventFilterInput;
+    EventLaneSummary: EventLaneSummary;
     EventLoopStats: EventLoopStats;
     Float: Scalars['Float']['output'];
     FlowEmitNode: FlowEmitNode;
@@ -1400,7 +1633,6 @@ export type ResolversParentTypes = ResolversObject<{
     FlowStepNode: FlowStepNode;
     FlowSwitchNode: FlowSwitchNode;
     GcStats: GcStats;
-    GlobalMiddleware: GlobalMiddleware;
     Hook: Omit<Hook, 'depenendsOnResolved' | 'emitsResolved' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'registeredByResolved' | 'runs' | 'tags'> & {
         depenendsOnResolved: Array<ResolversParentTypes['BaseElement']>;
         emitsResolved: Array<ResolversParentTypes['Event']>;
@@ -1412,6 +1644,9 @@ export type ResolversParentTypes = ResolversObject<{
     };
     ID: Scalars['ID']['output'];
     Int: Scalars['Int']['output'];
+    InterceptorOwnersSnapshot: InterceptorOwnersSnapshot;
+    IsolationChannels: IsolationChannels;
+    IsolationWhitelistEntry: IsolationWhitelistEntry;
     Live: Omit<Live, 'emissions' | 'errors' | 'runs'> & {
         emissions: Array<ResolversParentTypes['EmissionEntry']>;
         errors: Array<ResolversParentTypes['ErrorEntry']>;
@@ -1422,7 +1657,8 @@ export type ResolversParentTypes = ResolversObject<{
     MemoryStats: MemoryStats;
     Meta: Meta;
     MetaTagUsage: MetaTagUsage;
-    Middleware: Omit<Middleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedByResourcesDetailed' | 'usedByResourcesResolved' | 'usedByTasksDetailed' | 'usedByTasksResolved'> & {
+    Middleware: Omit<Middleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedByResourcesDetailed' | 'usedByResourcesResolved' | 'usedByTasksDetailed' | 'usedByTasksResolved'> & {
+        autoApply: ResolversParentTypes['MiddlewareAutoApply'];
         emits: Array<ResolversParentTypes['Event']>;
         registeredByResolved: Maybe<ResolversParentTypes['Resource']>;
         tags: Maybe<Array<ResolversParentTypes['Tag']>>;
@@ -1431,6 +1667,9 @@ export type ResolversParentTypes = ResolversObject<{
         usedByTasksDetailed: Array<ResolversParentTypes['MiddlewareTaskUsage']>;
         usedByTasksResolved: Array<ResolversParentTypes['Task']>;
     };
+    MiddlewareAutoApply: MiddlewareAutoApply;
+    MiddlewareInterceptorOwnersEntry: MiddlewareInterceptorOwnersEntry;
+    MiddlewareInterceptorOwnersSnapshot: MiddlewareInterceptorOwnersSnapshot;
     MiddlewareResourceUsage: Omit<MiddlewareResourceUsage, 'node'> & {
         node: ResolversParentTypes['Resource'];
     };
@@ -1438,7 +1677,7 @@ export type ResolversParentTypes = ResolversObject<{
         node: ResolversParentTypes['Task'];
     };
     Query: {};
-    Resource: Omit<Resource, 'dependsOnResolved' | 'emits' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'overridesResolved' | 'registeredByResolved' | 'registersResolved' | 'tags' | 'tunnelInfo' | 'usedBy'> & {
+    Resource: Omit<Resource, 'dependsOnResolved' | 'emits' | 'middlewareResolved' | 'middlewareResolvedDetailed' | 'overridesResolved' | 'registeredByResolved' | 'registersResolved' | 'tags' | 'usedBy'> & {
         dependsOnResolved: Array<ResolversParentTypes['Resource']>;
         emits: Array<ResolversParentTypes['Event']>;
         middlewareResolved: Array<ResolversParentTypes['ResourceMiddleware']>;
@@ -1447,30 +1686,43 @@ export type ResolversParentTypes = ResolversObject<{
         registeredByResolved: Maybe<ResolversParentTypes['Resource']>;
         registersResolved: Array<ResolversParentTypes['BaseElement']>;
         tags: Maybe<Array<ResolversParentTypes['Tag']>>;
-        tunnelInfo: Maybe<ResolversParentTypes['TunnelInfo']>;
         usedBy: Array<ResolversParentTypes['Task']>;
     };
-    ResourceMiddleware: Omit<ResourceMiddleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+    ResourceHealthEntry: ResourceHealthEntry;
+    ResourceHealthReport: ResourceHealthReport;
+    ResourceHealthTotals: ResourceHealthTotals;
+    ResourceIsolation: ResourceIsolation;
+    ResourceMiddleware: Omit<ResourceMiddleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+        autoApply: ResolversParentTypes['MiddlewareAutoApply'];
         emits: Array<ResolversParentTypes['Event']>;
         registeredByResolved: Maybe<ResolversParentTypes['Resource']>;
         tags: Maybe<Array<ResolversParentTypes['Tag']>>;
         usedBy: Array<ResolversParentTypes['Resource']>;
         usedByDetailed: Array<ResolversParentTypes['MiddlewareResourceUsage']>;
     };
+    ResourceSubtreeBranch: ResourceSubtreeBranch;
+    ResourceSubtreePolicy: ResourceSubtreePolicy;
+    ResourceSubtreeValidationBranch: ResourceSubtreeValidationBranch;
+    RpcLaneSummary: RpcLaneSummary;
+    RunDisposeOptions: RunDisposeOptions;
+    RunExecutionContextOptions: RunExecutionContextOptions;
     RunFilterInput: RunFilterInput;
+    RunOptions: RunOptions;
     RunRecord: Omit<RunRecord, 'nodeResolved'> & {
         nodeResolved: Maybe<ResolversParentTypes['BaseElement']>;
     };
     String: Scalars['String']['output'];
     SwapResult: SwapResult;
     SwappedTask: SwappedTask;
-    Tag: Omit<Tag, 'all' | 'events' | 'hooks' | 'middlewares' | 'resources' | 'tags' | 'tasks'> & {
+    Tag: Omit<Tag, 'all' | 'errors' | 'events' | 'hooks' | 'resourceMiddlewares' | 'resources' | 'tags' | 'taskMiddlewares' | 'tasks'> & {
         all: Array<ResolversParentTypes['BaseElement']>;
+        errors: Array<ResolversParentTypes['Error']>;
         events: Array<ResolversParentTypes['Event']>;
         hooks: Array<ResolversParentTypes['Hook']>;
-        middlewares: Array<ResolversParentTypes['Middleware']>;
+        resourceMiddlewares: Array<ResolversParentTypes['ResourceMiddleware']>;
         resources: Array<ResolversParentTypes['Resource']>;
         tags: Maybe<Array<ResolversParentTypes['Tag']>>;
+        taskMiddlewares: Array<ResolversParentTypes['TaskMiddleware']>;
         tasks: Array<ResolversParentTypes['Task']>;
     };
     TagUsage: TagUsage;
@@ -1492,7 +1744,9 @@ export type ResolversParentTypes = ResolversObject<{
         resources: Array<ResolversParentTypes['Resource']>;
         tasks: Array<ResolversParentTypes['BaseElement']>;
     };
-    TaskMiddleware: Omit<TaskMiddleware, 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+    TaskInterceptorOwnersEntry: TaskInterceptorOwnersEntry;
+    TaskMiddleware: Omit<TaskMiddleware, 'autoApply' | 'emits' | 'registeredByResolved' | 'tags' | 'usedBy' | 'usedByDetailed'> & {
+        autoApply: ResolversParentTypes['MiddlewareAutoApply'];
         emits: Array<ResolversParentTypes['Event']>;
         registeredByResolved: Maybe<ResolversParentTypes['Resource']>;
         tags: Maybe<Array<ResolversParentTypes['Tag']>>;
@@ -1502,10 +1756,6 @@ export type ResolversParentTypes = ResolversObject<{
     TaskMiddlewareUsage: Omit<TaskMiddlewareUsage, 'node'> & {
         node: ResolversParentTypes['TaskMiddleware'];
     };
-    TunnelInfo: Omit<TunnelInfo, 'eventsResolved' | 'tasksResolved'> & {
-        eventsResolved: Maybe<Array<ResolversParentTypes['Event']>>;
-        tasksResolved: Maybe<Array<ResolversParentTypes['Task']>>;
-    };
 }>;
 export type AllResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['All'] = ResolversParentTypes['All']> = ResolversObject<{
     coverage: Resolver<Maybe<ResolversTypes['CoverageInfo']>, ParentType, ContextType>;
@@ -1513,10 +1763,12 @@ export type AllResolvers<ContextType = CustomGraphQLContext, ParentType extends
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, AllFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type AsyncContextResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['AsyncContext'] = ResolversParentTypes['AsyncContext']> = ResolversObject<{
@@ -1525,6 +1777,7 @@ export type AsyncContextResolvers<ContextType = CustomGraphQLContext, ParentType
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, AsyncContextFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     parse: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1534,6 +1787,7 @@ export type AsyncContextResolvers<ContextType = CustomGraphQLContext, ParentType
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
     usedBy: Resolver<Array<ResolversTypes['All']>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type BaseElementResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['BaseElement'] = ResolversParentTypes['BaseElement']> = ResolversObject<{
@@ -1541,10 +1795,12 @@ export type BaseElementResolvers<ContextType = CustomGraphQLContext, ParentType
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, BaseElementFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
 }>;
 export type CoverageInfoResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['CoverageInfo'] = ResolversParentTypes['CoverageInfo']> = ResolversObject<{
     coveredStatements: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
@@ -1587,11 +1843,13 @@ export type ErrorResolvers<ContextType = CustomGraphQLContext, ParentType extend
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, ErrorFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
     thrownBy: Resolver<Array<ResolversTypes['All']>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type ErrorEntryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ErrorEntry'] = ResolversParentTypes['ErrorEntry']> = ResolversObject<{
@@ -1610,19 +1868,31 @@ export type EventResolvers<ContextType = CustomGraphQLContext, ParentType extend
     coverageContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     emittedBy: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     emittedByResolved: Resolver<Array<ResolversTypes['BaseElement']>, ParentType, ContextType>;
+    eventLane: Resolver<Maybe<ResolversTypes['EventLaneSummary']>, ParentType, ContextType>;
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, EventFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     listenedToBy: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     listenedToByResolved: Resolver<Array<ResolversTypes['Hook']>, ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
+    parallel: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     payloadSchema: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     payloadSchemaReadable: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     registeredBy: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     registeredByResolved: Resolver<Maybe<ResolversTypes['Resource']>, ParentType, ContextType>;
+    rpcLane: Resolver<Maybe<ResolversTypes['RpcLaneSummary']>, ParentType, ContextType>;
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
+    transactional: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type EventLaneSummaryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['EventLaneSummary'] = ResolversParentTypes['EventLaneSummary']> = ResolversObject<{
+    laneId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    metadata: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    orderingKey: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type EventLoopStatsResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['EventLoopStats'] = ResolversParentTypes['EventLoopStats']> = ResolversObject<{
@@ -1674,12 +1944,6 @@ export type GcStatsResolvers<ContextType = CustomGraphQLContext, ParentType exte
     duration: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
-export type GlobalMiddlewareResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['GlobalMiddleware'] = ResolversParentTypes['GlobalMiddleware']> = ResolversObject<{
-    enabled: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
-    resources: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
-    tasks: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
 export type HookResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['Hook'] = ResolversParentTypes['Hook']> = ResolversObject<{
     coverage: Resolver<Maybe<ResolversTypes['CoverageInfo']>, ParentType, ContextType>;
     coverageContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1695,6 +1959,7 @@ export type HookResolvers<ContextType = CustomGraphQLContext, ParentType extends
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
     inputSchema: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     inputSchemaReadable: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     middleware: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1706,6 +1971,30 @@ export type HookResolvers<ContextType = CustomGraphQLContext, ParentType extends
     runs: Resolver<Array<ResolversTypes['RunRecord']>, ParentType, ContextType, HookRunsArgs>;
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type InterceptorOwnersSnapshotResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['InterceptorOwnersSnapshot'] = ResolversParentTypes['InterceptorOwnersSnapshot']> = ResolversObject<{
+    middleware: Resolver<ResolversTypes['MiddlewareInterceptorOwnersSnapshot'], ParentType, ContextType>;
+    tasksById: Resolver<Array<ResolversTypes['TaskInterceptorOwnersEntry']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type IsolationChannelsResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['IsolationChannels'] = ResolversParentTypes['IsolationChannels']> = ResolversObject<{
+    dependencies: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+    listening: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+    middleware: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+    tagging: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type IsolationExportsModeResolvers = {
+    LIST: 'list';
+    NONE: 'none';
+    UNSET: 'unset';
+};
+export type IsolationWhitelistEntryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['IsolationWhitelistEntry'] = ResolversParentTypes['IsolationWhitelistEntry']> = ResolversObject<{
+    channels: Resolver<Maybe<ResolversTypes['IsolationChannels']>, ParentType, ContextType>;
+    for: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    targets: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type LiveResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['Live'] = ResolversParentTypes['Live']> = ResolversObject<{
@@ -1714,6 +2003,7 @@ export type LiveResolvers<ContextType = CustomGraphQLContext, ParentType extends
     errors: Resolver<Array<ResolversTypes['ErrorEntry']>, ParentType, ContextType, LiveErrorsArgs>;
     eventLoop: Resolver<ResolversTypes['EventLoopStats'], ParentType, ContextType, LiveEventLoopArgs>;
     gc: Resolver<ResolversTypes['GcStats'], ParentType, ContextType, LiveGcArgs>;
+    healthReport: Resolver<Maybe<ResolversTypes['ResourceHealthReport']>, ParentType, ContextType>;
     logs: Resolver<Array<ResolversTypes['LogEntry']>, ParentType, ContextType, LiveLogsArgs>;
     memory: Resolver<ResolversTypes['MemoryStats'], ParentType, ContextType>;
     runs: Resolver<Array<ResolversTypes['RunRecord']>, ParentType, ContextType, LiveRunsArgs>;
@@ -1746,6 +2036,7 @@ export type MetaTagUsageResolvers<ContextType = CustomGraphQLContext, ParentType
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type MiddlewareResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['Middleware'] = ResolversParentTypes['Middleware']> = ResolversObject<{
+    autoApply: Resolver<ResolversTypes['MiddlewareAutoApply'], ParentType, ContextType>;
     configSchema: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     configSchemaReadable: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     coverage: Resolver<Maybe<ResolversTypes['CoverageInfo']>, ParentType, ContextType>;
@@ -1753,8 +2044,8 @@ export type MiddlewareResolvers<ContextType = CustomGraphQLContext, ParentType e
     emits: Resolver<Array<ResolversTypes['Event']>, ParentType, ContextType>;
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, MiddlewareFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    global: Resolver<Maybe<ResolversTypes['GlobalMiddleware']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     overriddenBy: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1768,6 +2059,29 @@ export type MiddlewareResolvers<ContextType = CustomGraphQLContext, ParentType e
     usedByTasks: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     usedByTasksDetailed: Resolver<Array<ResolversTypes['MiddlewareTaskUsage']>, ParentType, ContextType>;
     usedByTasksResolved: Resolver<Array<ResolversTypes['Task']>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type MiddlewareApplyScopeResolvers = {
+    SUBTREE: 'subtree';
+    WHERE_VISIBLE: 'where-visible';
+};
+export type MiddlewareAutoApplyResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['MiddlewareAutoApply'] = ResolversParentTypes['MiddlewareAutoApply']> = ResolversObject<{
+    enabled: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    hasPredicate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    scope: Resolver<Maybe<ResolversTypes['MiddlewareApplyScope']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type MiddlewareInterceptorOwnersEntryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['MiddlewareInterceptorOwnersEntry'] = ResolversParentTypes['MiddlewareInterceptorOwnersEntry']> = ResolversObject<{
+    middlewareId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    ownerResourceIds: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type MiddlewareInterceptorOwnersSnapshotResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['MiddlewareInterceptorOwnersSnapshot'] = ResolversParentTypes['MiddlewareInterceptorOwnersSnapshot']> = ResolversObject<{
+    globalResourceInterceptorOwnerIds: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    globalTaskInterceptorOwnerIds: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    perResourceMiddlewareInterceptorOwnerIds: Resolver<Array<ResolversTypes['MiddlewareInterceptorOwnersEntry']>, ParentType, ContextType>;
+    perTaskMiddlewareInterceptorOwnerIds: Resolver<Array<ResolversTypes['MiddlewareInterceptorOwnersEntry']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type MiddlewareResourceUsageResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['MiddlewareResourceUsage'] = ResolversParentTypes['MiddlewareResourceUsage']> = ResolversObject<{
@@ -1793,6 +2107,7 @@ export type QueryResolvers<ContextType = CustomGraphQLContext, ParentType extend
     events: Resolver<Array<ResolversTypes['Event']>, ParentType, ContextType, QueryEventsArgs>;
     hook: Resolver<Maybe<ResolversTypes['Hook']>, ParentType, ContextType, RequireFields<QueryHookArgs, 'id'>>;
     hooks: Resolver<Array<ResolversTypes['Hook']>, ParentType, ContextType, QueryHooksArgs>;
+    interceptorOwners: Resolver<ResolversTypes['InterceptorOwnersSnapshot'], ParentType, ContextType>;
     live: Resolver<ResolversTypes['Live'], ParentType, ContextType>;
     middleware: Resolver<Maybe<ResolversTypes['Middleware']>, ParentType, ContextType, RequireFields<QueryMiddlewareArgs, 'id'>>;
     middlewares: Resolver<Array<ResolversTypes['Middleware']>, ParentType, ContextType, QueryMiddlewaresArgs>;
@@ -1800,6 +2115,7 @@ export type QueryResolvers<ContextType = CustomGraphQLContext, ParentType extend
     resourceMiddlewares: Resolver<Array<ResolversTypes['ResourceMiddleware']>, ParentType, ContextType, QueryResourceMiddlewaresArgs>;
     resources: Resolver<Array<ResolversTypes['Resource']>, ParentType, ContextType, QueryResourcesArgs>;
     root: Resolver<Maybe<ResolversTypes['Resource']>, ParentType, ContextType>;
+    runOptions: Resolver<ResolversTypes['RunOptions'], ParentType, ContextType>;
     swappedTasks: Resolver<Array<ResolversTypes['SwappedTask']>, ParentType, ContextType>;
     tag: Resolver<Maybe<ResolversTypes['Tag']>, ParentType, ContextType, RequireFields<QueryTagArgs, 'id'>>;
     tags: Resolver<Array<ResolversTypes['Tag']>, ParentType, ContextType>;
@@ -1819,7 +2135,12 @@ export type ResourceResolvers<ContextType = CustomGraphQLContext, ParentType ext
     emits: Resolver<Array<ResolversTypes['Event']>, ParentType, ContextType>;
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, ResourceFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    hasCooldown: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    hasHealthCheck: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    hasReady: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    isolation: Resolver<Maybe<ResolversTypes['ResourceIsolation']>, ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     middleware: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1831,13 +2152,43 @@ export type ResourceResolvers<ContextType = CustomGraphQLContext, ParentType ext
     registeredByResolved: Resolver<Maybe<ResolversTypes['Resource']>, ParentType, ContextType>;
     registers: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     registersResolved: Resolver<Array<ResolversTypes['BaseElement']>, ParentType, ContextType>;
+    subtree: Resolver<Maybe<ResolversTypes['ResourceSubtreePolicy']>, ParentType, ContextType>;
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
-    tunnelInfo: Resolver<Maybe<ResolversTypes['TunnelInfo']>, ParentType, ContextType>;
     usedBy: Resolver<Array<ResolversTypes['Task']>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceHealthEntryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceHealthEntry'] = ResolversParentTypes['ResourceHealthEntry']> = ResolversObject<{
+    details: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    id: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    initialized: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    message: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    status: Resolver<ResolversTypes['ResourceHealthStatus'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceHealthReportResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceHealthReport'] = ResolversParentTypes['ResourceHealthReport']> = ResolversObject<{
+    report: Resolver<Array<ResolversTypes['ResourceHealthEntry']>, ParentType, ContextType>;
+    totals: Resolver<ResolversTypes['ResourceHealthTotals'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceHealthTotalsResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceHealthTotals'] = ResolversParentTypes['ResourceHealthTotals']> = ResolversObject<{
+    degraded: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+    healthy: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+    resources: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+    unhealthy: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceIsolationResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceIsolation'] = ResolversParentTypes['ResourceIsolation']> = ResolversObject<{
+    deny: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    exports: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    exportsMode: Resolver<ResolversTypes['IsolationExportsMode'], ParentType, ContextType>;
+    only: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    whitelist: Resolver<Array<ResolversTypes['IsolationWhitelistEntry']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type ResourceMiddlewareResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceMiddleware'] = ResolversParentTypes['ResourceMiddleware']> = ResolversObject<{
+    autoApply: Resolver<ResolversTypes['MiddlewareAutoApply'], ParentType, ContextType>;
     configSchema: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     configSchemaReadable: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     coverage: Resolver<Maybe<ResolversTypes['CoverageInfo']>, ParentType, ContextType>;
@@ -1845,8 +2196,8 @@ export type ResourceMiddlewareResolvers<ContextType = CustomGraphQLContext, Pare
     emits: Resolver<Array<ResolversTypes['Event']>, ParentType, ContextType>;
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, ResourceMiddlewareFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    global: Resolver<Maybe<ResolversTypes['GlobalMiddleware']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     overriddenBy: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1856,6 +2207,60 @@ export type ResourceMiddlewareResolvers<ContextType = CustomGraphQLContext, Pare
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
     usedBy: Resolver<Array<ResolversTypes['Resource']>, ParentType, ContextType>;
     usedByDetailed: Resolver<Array<ResolversTypes['MiddlewareResourceUsage']>, ParentType, ContextType>;
+    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>;
+    __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>;
+    resourceMiddleware: Resolver<Maybe<ResolversTypes['ResourceSubtreeValidationBranch']>, ParentType, ContextType>;
+    resources: Resolver<Maybe<ResolversTypes['ResourceSubtreeBranch']>, ParentType, ContextType>;
+    tags: Resolver<Maybe<ResolversTypes['ResourceSubtreeValidationBranch']>, ParentType, ContextType>;
+    taskMiddleware: Resolver<Maybe<ResolversTypes['ResourceSubtreeValidationBranch']>, ParentType, ContextType>;
+    tasks: Resolver<Maybe<ResolversTypes['ResourceSubtreeBranch']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type ResourceSubtreeValidationBranchResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['ResourceSubtreeValidationBranch'] = ResolversParentTypes['ResourceSubtreeValidationBranch']> = ResolversObject<{
+    validatorCount: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type RpcLaneSummaryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['RpcLaneSummary'] = ResolversParentTypes['RpcLaneSummary']> = ResolversObject<{
+    laneId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type RunDisposeOptionsResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['RunDisposeOptions'] = ResolversParentTypes['RunDisposeOptions']> = ResolversObject<{
+    cooldownWindowMs: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
+    drainingBudgetMs: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
+    totalBudgetMs: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type RunExecutionContextOptionsResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['RunExecutionContextOptions'] = ResolversParentTypes['RunExecutionContextOptions']> = ResolversObject<{
+    cycleDetection: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+    enabled: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type RunOptionsResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['RunOptions'] = ResolversParentTypes['RunOptions']> = ResolversObject<{
+    debug: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    debugMode: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    dispose: Resolver<ResolversTypes['RunDisposeOptions'], ParentType, ContextType>;
+    dryRun: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    errorBoundary: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+    executionContext: Resolver<ResolversTypes['RunExecutionContextOptions'], ParentType, ContextType>;
+    hasOnUnhandledError: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    lazy: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    lifecycleMode: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    logsBuffer: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    logsEnabled: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    logsPrintStrategy: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    logsPrintThreshold: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    mode: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    rootId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    shutdownHooks: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type RunRecordResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['RunRecord'] = ResolversParentTypes['RunRecord']> = ResolversObject<{
@@ -1889,20 +2294,34 @@ export type TagResolvers<ContextType = CustomGraphQLContext, ParentType extends
     configSchema: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     coverage: Resolver<Maybe<ResolversTypes['CoverageInfo']>, ParentType, ContextType>;
     coverageContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    errors: Resolver<Array<ResolversTypes['Error']>, ParentType, ContextType>;
     events: Resolver<Array<ResolversTypes['Event']>, ParentType, ContextType>;
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, TagFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     hooks: Resolver<Array<ResolversTypes['Hook']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
-    middlewares: Resolver<Array<ResolversTypes['Middleware']>, ParentType, ContextType>;
+    resourceMiddlewares: Resolver<Array<ResolversTypes['ResourceMiddleware']>, ParentType, ContextType>;
     resources: Resolver<Array<ResolversTypes['Resource']>, ParentType, ContextType>;
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
+    targets: Resolver<Array<ResolversTypes['TagTarget']>, ParentType, ContextType>;
+    taskMiddlewares: Resolver<Array<ResolversTypes['TaskMiddleware']>, ParentType, ContextType>;
     tasks: Resolver<Array<ResolversTypes['Task']>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
+export type TagTargetResolvers = {
+    ERRORS: 'errors';
+    EVENTS: 'events';
+    HOOKS: 'hooks';
+    RESOURCES: 'resources';
+    RESOURCE_MIDDLEWARES: 'resourceMiddlewares';
+    TASKS: 'tasks';
+    TASK_MIDDLEWARES: 'taskMiddlewares';
+};
 export type TagUsageResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['TagUsage'] = ResolversParentTypes['TagUsage']> = ResolversObject<{
     config: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     configSchema: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1921,10 +2340,14 @@ export type TaskResolvers<ContextType = CustomGraphQLContext, ParentType extends
     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>;
     inputSchemaReadable: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    interceptorCount: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+    interceptorOwnerIds: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
     isDurable: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     middleware: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1933,9 +2356,11 @@ export type TaskResolvers<ContextType = CustomGraphQLContext, ParentType extends
     overriddenBy: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     registeredBy: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     registeredByResolved: Resolver<Maybe<ResolversTypes['Resource']>, ParentType, ContextType>;
+    rpcLane: Resolver<Maybe<ResolversTypes['RpcLaneSummary']>, ParentType, ContextType>;
     runs: Resolver<Array<ResolversTypes['RunRecord']>, ParentType, ContextType, TaskRunsArgs>;
     tags: Resolver<Maybe<Array<ResolversTypes['Tag']>>, ParentType, ContextType>;
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type TaskDependsOnResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['TaskDependsOn'] = ResolversParentTypes['TaskDependsOn']> = ResolversObject<{
@@ -1945,7 +2370,13 @@ export type TaskDependsOnResolvers<ContextType = CustomGraphQLContext, ParentTyp
     tasks: Resolver<Array<ResolversTypes['BaseElement']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
+export type TaskInterceptorOwnersEntryResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['TaskInterceptorOwnersEntry'] = ResolversParentTypes['TaskInterceptorOwnersEntry']> = ResolversObject<{
+    ownerResourceIds: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+    taskId: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
 export type TaskMiddlewareResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['TaskMiddleware'] = ResolversParentTypes['TaskMiddleware']> = ResolversObject<{
+    autoApply: Resolver<ResolversTypes['MiddlewareAutoApply'], ParentType, ContextType>;
     configSchema: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     configSchemaReadable: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     coverage: Resolver<Maybe<ResolversTypes['CoverageInfo']>, ParentType, ContextType>;
@@ -1953,8 +2384,8 @@ export type TaskMiddlewareResolvers<ContextType = CustomGraphQLContext, ParentTy
     emits: Resolver<Array<ResolversTypes['Event']>, ParentType, ContextType>;
     fileContents: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, TaskMiddlewareFileContentsArgs>;
     filePath: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    global: Resolver<Maybe<ResolversTypes['GlobalMiddleware']>, ParentType, ContextType>;
     id: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+    isPrivate: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     markdownDescription: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     meta: Resolver<Maybe<ResolversTypes['Meta']>, ParentType, ContextType>;
     overriddenBy: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1964,6 +2395,7 @@ export type TaskMiddlewareResolvers<ContextType = CustomGraphQLContext, ParentTy
     tagsDetailed: Resolver<Maybe<Array<ResolversTypes['TagUsage']>>, ParentType, ContextType>;
     usedBy: Resolver<Array<ResolversTypes['Task']>, ParentType, ContextType>;
     usedByDetailed: Resolver<Array<ResolversTypes['MiddlewareTaskUsage']>, ParentType, ContextType>;
+    visibilityReason: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 export type TaskMiddlewareUsageResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['TaskMiddlewareUsage'] = ResolversParentTypes['TaskMiddlewareUsage']> = ResolversObject<{
@@ -1972,24 +2404,6 @@ export type TaskMiddlewareUsageResolvers<ContextType = CustomGraphQLContext, Par
     node: Resolver<ResolversTypes['TaskMiddleware'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
-export type TunnelEventDeliveryModeResolvers = {
-    local_only: 'local-only';
-    mirror: 'mirror';
-    remote_first: 'remote-first';
-    remote_only: 'remote-only';
-};
-export type TunnelInfoResolvers<ContextType = CustomGraphQLContext, ParentType extends ResolversParentTypes['TunnelInfo'] = ResolversParentTypes['TunnelInfo']> = ResolversObject<{
-    auth: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    endpoint: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    eventDeliveryMode: Resolver<Maybe<ResolversTypes['TunnelEventDeliveryMode']>, ParentType, ContextType>;
-    events: Resolver<Maybe<Array<ResolversTypes['String']>>, ParentType, ContextType>;
-    eventsResolved: Resolver<Maybe<Array<ResolversTypes['Event']>>, ParentType, ContextType>;
-    mode: Resolver<ResolversTypes['TunnelMode'], ParentType, ContextType>;
-    tasks: Resolver<Maybe<Array<ResolversTypes['String']>>, ParentType, ContextType>;
-    tasksResolved: Resolver<Maybe<Array<ResolversTypes['Task']>>, ParentType, ContextType>;
-    transport: Resolver<ResolversTypes['TunnelTransport'], ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
 export type Resolvers<ContextType = CustomGraphQLContext> = ResolversObject<{
     All: AllResolvers<ContextType>;
     AsyncContext: AsyncContextResolvers<ContextType>;
@@ -2002,6 +2416,7 @@ export type Resolvers<ContextType = CustomGraphQLContext> = ResolversObject<{
     Error: ErrorResolvers<ContextType>;
     ErrorEntry: ErrorEntryResolvers<ContextType>;
     Event: EventResolvers<ContextType>;
+    EventLaneSummary: EventLaneSummaryResolvers<ContextType>;
     EventLoopStats: EventLoopStatsResolvers<ContextType>;
     FlowEmitNode: FlowEmitNodeResolvers<ContextType>;
     FlowNode: FlowNodeResolvers<ContextType>;
@@ -2011,28 +2426,46 @@ export type Resolvers<ContextType = CustomGraphQLContext> = ResolversObject<{
     FlowStepNode: FlowStepNodeResolvers<ContextType>;
     FlowSwitchNode: FlowSwitchNodeResolvers<ContextType>;
     GcStats: GcStatsResolvers<ContextType>;
-    GlobalMiddleware: GlobalMiddlewareResolvers<ContextType>;
     Hook: HookResolvers<ContextType>;
+    InterceptorOwnersSnapshot: InterceptorOwnersSnapshotResolvers<ContextType>;
+    IsolationChannels: IsolationChannelsResolvers<ContextType>;
+    IsolationExportsMode: IsolationExportsModeResolvers;
+    IsolationWhitelistEntry: IsolationWhitelistEntryResolvers<ContextType>;
     Live: LiveResolvers<ContextType>;
     LogEntry: LogEntryResolvers<ContextType>;
     MemoryStats: MemoryStatsResolvers<ContextType>;
     Meta: MetaResolvers<ContextType>;
     MetaTagUsage: MetaTagUsageResolvers<ContextType>;
     Middleware: MiddlewareResolvers<ContextType>;
+    MiddlewareApplyScope: MiddlewareApplyScopeResolvers;
+    MiddlewareAutoApply: MiddlewareAutoApplyResolvers<ContextType>;
+    MiddlewareInterceptorOwnersEntry: MiddlewareInterceptorOwnersEntryResolvers<ContextType>;
+    MiddlewareInterceptorOwnersSnapshot: MiddlewareInterceptorOwnersSnapshotResolvers<ContextType>;
     MiddlewareResourceUsage: MiddlewareResourceUsageResolvers<ContextType>;
     MiddlewareTaskUsage: MiddlewareTaskUsageResolvers<ContextType>;
     Query: QueryResolvers<ContextType>;
     Resource: ResourceResolvers<ContextType>;
+    ResourceHealthEntry: ResourceHealthEntryResolvers<ContextType>;
+    ResourceHealthReport: ResourceHealthReportResolvers<ContextType>;
+    ResourceHealthTotals: ResourceHealthTotalsResolvers<ContextType>;
+    ResourceIsolation: ResourceIsolationResolvers<ContextType>;
     ResourceMiddleware: ResourceMiddlewareResolvers<ContextType>;
+    ResourceSubtreeBranch: ResourceSubtreeBranchResolvers<ContextType>;
+    ResourceSubtreePolicy: ResourceSubtreePolicyResolvers<ContextType>;
+    ResourceSubtreeValidationBranch: ResourceSubtreeValidationBranchResolvers<ContextType>;
+    RpcLaneSummary: RpcLaneSummaryResolvers<ContextType>;
+    RunDisposeOptions: RunDisposeOptionsResolvers<ContextType>;
+    RunExecutionContextOptions: RunExecutionContextOptionsResolvers<ContextType>;
+    RunOptions: RunOptionsResolvers<ContextType>;
     RunRecord: RunRecordResolvers<ContextType>;
     SwapResult: SwapResultResolvers<ContextType>;
     SwappedTask: SwappedTaskResolvers<ContextType>;
     Tag: TagResolvers<ContextType>;
+    TagTarget: TagTargetResolvers;
     TagUsage: TagUsageResolvers<ContextType>;
     Task: TaskResolvers<ContextType>;
     TaskDependsOn: TaskDependsOnResolvers<ContextType>;
+    TaskInterceptorOwnersEntry: TaskInterceptorOwnersEntryResolvers<ContextType>;
     TaskMiddleware: TaskMiddlewareResolvers<ContextType>;
     TaskMiddlewareUsage: TaskMiddlewareUsageResolvers<ContextType>;
-    TunnelEventDeliveryMode: TunnelEventDeliveryModeResolvers;
-    TunnelInfo: TunnelInfoResolvers<ContextType>;
 }>;