@bluelibs/runner 6.0.0 → 6.1.0

package/dist/types/definers/assertDefinitionId.d.ts

@@ -2,4 +2,5 @@ export declare const RESERVED_DEFINITION_LOCAL_NAMES: readonly ["tasks", "events
 export declare function isReservedDefinitionLocalName(name: string): boolean;
 export declare function assertDefinitionId(definitionType: string, id: unknown, options?: {
     allowReservedDottedNamespace?: boolean;
+    allowReservedInternalId?: boolean;
 }): asserts id is string;

package/dist/types/definers/builders/resource/index.d.ts

@@ -5,9 +5,7 @@ export * from "./types";
 /**
  * Creates a new resource builder with the given id.
  */
-export type ResourceBuilderOptions = {
-    gateway?: boolean;
-};
+export type ResourceBuilderOptions = {};
 export declare function resourceBuilder<TConfig = void>(id: string, options?: ResourceBuilderOptions): ResourceFluentBuilder<TConfig, Promise<any>, {}, any, IResourceMeta, ResourceTagType[], ResourceMiddlewareAttachmentType[]>;
 /**
  * Alias for resourceBuilder - common shorthand.

package/dist/types/definers/builders/resource/types.d.ts

@@ -5,7 +5,6 @@ import type { ThrowsList } from "../../../types/error";
  */
 export type BuilderState<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext, TMeta extends IResourceMeta, TTags extends ResourceTagType[], TMiddleware extends ResourceMiddlewareAttachmentType[]> = Readonly<{
     id: string;
-    gateway: boolean;
     filePath: string;
     dependencies?: TDeps | ((config: TConfig) => TDeps);
     register?: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);

package/dist/types/errors/domain-error-ids.d.ts

@@ -18,8 +18,6 @@ export declare enum RunnerErrorId {
     RpcLaneOwnershipConflict = "runner.errors.rpcLane.ownershipConflict",
     RpcLaneExposureOwnerInvalid = "runner.errors.rpcLane.exposureOwnerInvalid",
     ResourceForkNonLeafUnsupported = "runner.errors.resourceFork.nonLeafUnsupported",
-    ResourceForkGatewayUnsupported = "runner.errors.resourceFork.gatewayUnsupported",
-    RunRootGatewayUnsupported = "runner.errors.run.rootGatewayUnsupported",
     BuilderInvalidHttpCode = "runner.errors.builder.invalidHttpCode",
     OverrideUnsupportedBase = "runner.errors.override.unsupportedBase",
     OverrideDefinitionRequired = "runner.errors.overrideDefinitionRequired",

package/dist/types/errors/domain-runtime.errors.d.ts

@@ -103,12 +103,6 @@ export declare const remoteLaneAuthUnauthorizedError: import("..").IErrorHelper<
 export declare const resourceForkNonLeafUnsupportedError: import("..").IErrorHelper<{
     id: string;
 } & DefaultErrorType>;
-export declare const resourceForkGatewayUnsupportedError: import("..").IErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
-export declare const runRootGatewayUnsupportedError: import("..").IErrorHelper<{
-    id: string;
-} & DefaultErrorType>;
 export declare const builderInvalidHttpCodeError: import("..").IErrorHelper<{
     value: number;
 } & DefaultErrorType>;

package/dist/types/globals/globalResources.d.ts

@@ -59,7 +59,7 @@ export declare const runnerResources: {
         description: string;
     }, import("..").ResourceTagType[], import("..").ResourceMiddlewareAttachmentType[]>;
     readonly rateLimit: import("..").IResource<void, Promise<{
-        states: WeakMap<import("./types").RateLimitMiddlewareConfig, import("./types").RateLimitState>;
+        states: WeakMap<import("./types").RateLimitMiddlewareConfig, Map<string, import("./types").RateLimitState>>;
     }>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
@@ -68,7 +68,7 @@ export declare const runnerResources: {
     }>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
-    readonly temporal: import("..").IResource<void, Promise<import("./middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("..").ITag<{
+    readonly temporal: import("..").IResource<void, Promise<import("./middleware/temporal.shared").TemporalResourceState<import("./types").TemporalMiddlewareConfig>>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
     readonly concurrency: import("..").IResource<void, Promise<{
@@ -128,7 +128,7 @@ export declare const globalResources: {
         description: string;
     }, import("..").ResourceTagType[], import("..").ResourceMiddlewareAttachmentType[]>;
     readonly rateLimit: import("..").IResource<void, Promise<{
-        states: WeakMap<import("./types").RateLimitMiddlewareConfig, import("./types").RateLimitState>;
+        states: WeakMap<import("./types").RateLimitMiddlewareConfig, Map<string, import("./types").RateLimitState>>;
     }>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
@@ -137,7 +137,7 @@ export declare const globalResources: {
     }>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
-    readonly temporal: import("..").IResource<void, Promise<import("./middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("..").ITag<{
+    readonly temporal: import("..").IResource<void, Promise<import("./middleware/temporal.shared").TemporalResourceState<import("./types").TemporalMiddlewareConfig>>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
     readonly concurrency: import("..").IResource<void, Promise<{

package/dist/types/globals/middleware/keyBuilder.shared.d.ts

@@ -0,0 +1,2 @@
+export type MiddlewareKeyBuilder = (taskId: string, input: unknown) => string;
+export declare const defaultTaskKeyBuilder: MiddlewareKeyBuilder;

package/dist/types/globals/middleware/rateLimit.middleware.d.ts

@@ -1,4 +1,5 @@
 import { RunnerError } from "../../definers/defineError";
+import { type MiddlewareKeyBuilder } from "./keyBuilder.shared";
 export interface RateLimitMiddlewareConfig {
     /**
      * Time window in milliseconds
@@ -8,6 +9,11 @@ export interface RateLimitMiddlewareConfig {
      * Maximum number of requests within the window
      */
     max: number;
+    /**
+     * Builds the partition key used to isolate fixed-window counters.
+     * Defaults to the task id.
+     */
+    keyBuilder?: MiddlewareKeyBuilder;
 }
 /**
  * Custom error class for rate limit errors.
@@ -34,7 +40,7 @@ export declare const journalKeys: {
     readonly limit: import("../..").JournalKey<number>;
 };
 export declare const rateLimitResource: import("../..").IResource<void, Promise<{
-    states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
+    states: WeakMap<RateLimitMiddlewareConfig, Map<string, RateLimitState>>;
 }>, {}, any, any, import("../..").ITag<{
     metadata?: Record<string, any>;
 }, void, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
@@ -43,7 +49,7 @@ export declare const rateLimitResource: import("../..").IResource<void, Promise<
  */
 export declare const rateLimitTaskMiddleware: import("../..").ITaskMiddleware<RateLimitMiddlewareConfig, any, any, {
     state: import("../..").IResource<void, Promise<{
-        states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
+        states: WeakMap<RateLimitMiddlewareConfig, Map<string, RateLimitState>>;
     }>, {}, any, any, import("../..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/globals/middleware/temporal.middleware.d.ts

@@ -1,38 +1,20 @@
+import { type MiddlewareKeyBuilder } from "./keyBuilder.shared";
+import { type TemporalResourceState } from "./temporal.shared";
 export interface TemporalMiddlewareConfig {
     ms: number;
+    keyBuilder?: MiddlewareKeyBuilder;
 }
-type TimeoutHandle = ReturnType<typeof setTimeout>;
-export interface DebounceState {
-    timeoutId?: TimeoutHandle;
-    latestInput?: unknown;
-    resolveList: ((value: unknown) => void)[];
-    rejectList: ((error: unknown) => void)[];
-}
-export interface ThrottleState {
-    lastExecution: number;
-    timeoutId?: TimeoutHandle;
-    latestInput?: unknown;
-    resolveList: ((value: unknown) => void)[];
-    rejectList: ((error: unknown) => void)[];
-    currentPromise?: Promise<unknown>;
-}
-export interface TemporalResourceState {
-    debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
-    throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
-    trackedDebounceStates: Set<DebounceState>;
-    trackedThrottleStates: Set<ThrottleState>;
-    isDisposed: boolean;
-}
-export declare const temporalResource: import("../..").IResource<void, Promise<TemporalResourceState>, {}, any, any, import("../..").ITag<{
+export declare const temporalResource: import("../..").IResource<void, Promise<TemporalResourceState<TemporalMiddlewareConfig>>, {}, any, any, import("../..").ITag<{
     metadata?: Record<string, any>;
 }, void, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export type { DebounceState, ThrottleState, TemporalResourceState, } from "./temporal.shared";
 /**
  * Debounce middleware: delays execution until `ms` has passed since the last call.
  * If multiple calls occur within the window, only the last one is executed,
  * and all callers receive the same result.
  */
 export declare const debounceTaskMiddleware: import("../..").ITaskMiddleware<TemporalMiddlewareConfig, any, any, {
-    state: import("../..").IResource<void, Promise<TemporalResourceState>, {}, any, any, import("../..").ITag<{
+    state: import("../..").IResource<void, Promise<TemporalResourceState<TemporalMiddlewareConfig>>, {}, any, any, import("../..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }>;
@@ -41,8 +23,7 @@ export declare const debounceTaskMiddleware: import("../..").ITaskMiddleware<Tem
  * If calls occur within the window, the last one is scheduled for the end of the window.
  */
 export declare const throttleTaskMiddleware: import("../..").ITaskMiddleware<TemporalMiddlewareConfig, any, any, {
-    state: import("../..").IResource<void, Promise<TemporalResourceState>, {}, any, any, import("../..").ITag<{
+    state: import("../..").IResource<void, Promise<TemporalResourceState<TemporalMiddlewareConfig>>, {}, any, any, import("../..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }>;
-export {};

package/dist/types/globals/middleware/temporal.shared.d.ts

@@ -0,0 +1,28 @@
+type TimeoutHandle = ReturnType<typeof setTimeout>;
+export interface DebounceState {
+    timeoutId?: TimeoutHandle;
+    latestInput?: unknown;
+    resolveList: ((value: unknown) => void)[];
+    rejectList: ((error: unknown) => void)[];
+    key: string;
+}
+export interface ThrottleState {
+    lastExecution: number;
+    timeoutId?: TimeoutHandle;
+    latestInput?: unknown;
+    resolveList: ((value: unknown) => void)[];
+    rejectList: ((error: unknown) => void)[];
+    currentPromise?: Promise<unknown>;
+    key: string;
+}
+export interface TemporalResourceState<TConfig extends object = object> {
+    debounceStates: WeakMap<TConfig, Map<string, DebounceState>>;
+    throttleStates: WeakMap<TConfig, Map<string, ThrottleState>>;
+    trackedDebounceStates: Set<DebounceState>;
+    trackedThrottleStates: Set<ThrottleState>;
+    isDisposed: boolean;
+}
+export declare function rejectDebounceState(state: DebounceState, error: Error): void;
+export declare function rejectThrottleState(state: ThrottleState, error: Error): void;
+export declare function pruneIdleThrottleStates(keyedStates: Map<string, ThrottleState>, trackedStates: Set<ThrottleState>, now: number, windowMs: number): void;
+export {};

package/dist/types/models/Store.d.ts

@@ -1,4 +1,4 @@
-import { IResource, RegisterableItems, ITag, TagDependencyAccessor } from "../defs";
+import { IResource, ITag, RegisterableItems, TagDependencyAccessor } from "../defs";
 import { EventManager } from "./EventManager";
 import { Logger } from "./Logger";
 import { ResourceStoreElementType, TaskStoreElementType, EventStoreElementType, DisposeWave, InitWave } from "../types/storeTypes";

package/dist/types/models/StoreRegistry.d.ts

@@ -22,6 +22,7 @@ export declare class StoreRegistry {
     private readonly definitionIdentityAliases;
     private readonly definitionAliasesBySourceId;
     private readonly sourceIdsByCanonicalId;
+    private readonly displayIdsByCanonicalId;
     readonly tagIndex: Map<string, TagIndexBucket>;
     private readonly validator;
     private readonly tagIndexer;
@@ -35,6 +36,8 @@ export declare class StoreRegistry {
     private recordCanonicalSourceId;
     private resolveUniqueSourceIdAlias;
     getDisplayId(id: string): string;
+    private stripFrameworkRootPrefix;
+    private computeAndStoreDisplayId;
     /** Lock every map in the registry, preventing further mutations. */
     lockAll(): void;
     storeGenericItem<_C>(item: RegisterableItems): void;

package/dist/types/models/createFrameworkRootGateway.d.ts

@@ -2,9 +2,11 @@ import type { IResource, IResourceWithConfig } from "../defs";
 import type { DebugFriendlyConfig } from "../globals/resources/debug";
 export declare const FRAMEWORK_RUNNER_RESOURCE_ID = "runner";
 export declare const FRAMEWORK_SYSTEM_RESOURCE_ID = "system";
+export declare const FRAMEWORK_ROOT_RESOURCE_ID = "runtime-framework-root";
 type FrameworkRootInput = {
     rootItem: IResource<any, any, any, any, any> | IResourceWithConfig<any, any>;
     debug: DebugFriendlyConfig | undefined;
 };
-export declare function createFrameworkRootGateway({ rootItem, debug, }: FrameworkRootInput): IResource<void, Promise<void>>;
+export declare function createFrameworkRootResource({ rootItem, debug, }: FrameworkRootInput): IResource<void, Promise<void>>;
+export declare const createFrameworkRootGateway: typeof createFrameworkRootResource;
 export {};

package/dist/types/models/store-registry/CanonicalIdCompiler.d.ts

@@ -0,0 +1,8 @@
+import { RegisterableKind } from "./registerableKind";
+import type { OwnerScope } from "./OwnerScope";
+export declare class CanonicalIdCompiler {
+    compute(ownerScope: OwnerScope, kind: Exclude<RegisterableKind, RegisterableKind.ResourceWithConfig>, currentId: string): string;
+    private computeFrameworkRootId;
+    private computeOwnedId;
+    private assertLocalName;
+}

package/dist/types/models/store-registry/OwnerScope.d.ts

@@ -0,0 +1,5 @@
+export type OwnerScope = Readonly<{
+    resourceId: string;
+    usesFrameworkRootIds: boolean;
+}>;
+export declare function createOwnerScope(resourceId: string): OwnerScope;

package/dist/types/models/store-registry/StoreRegistryWriter.d.ts

@@ -3,6 +3,7 @@ import { IAsyncContext } from "../../types/asyncContext";
 import { IErrorHelper } from "../../types/error";
 import { VisibilityTracker } from "../VisibilityTracker";
 import { StoreRegistryDefinitionPreparer } from "./StoreRegistryDefinitionPreparer";
+import { RegisterableKind } from "./registerableKind";
 import { StoreRegistryTagIndex } from "./StoreRegistryTagIndex";
 import { StoringMode } from "./types";
 type StoreRegistryCollections = {
@@ -31,6 +32,7 @@ export declare class StoreRegistryWriter {
     private readonly tagIndex;
     private readonly definitionPreparer;
     private readonly aliasResolver;
+    private readonly canonicalIdCompiler;
     constructor(collections: StoreRegistryCollections, validator: StoreRegistryValidation, visibilityTracker: VisibilityTracker, tagIndex: StoreRegistryTagIndex, definitionPreparer: StoreRegistryDefinitionPreparer, aliasResolver: StoreRegistryAliasResolver);
     storeGenericItem<_C>(item: RegisterableItems): void;
     storeError<_C>(item: IErrorHelper<any>): void;
@@ -44,11 +46,11 @@ export declare class StoreRegistryWriter {
     computeRegistrationDeeply<_C>(element: IResource<_C>, config?: _C): void;
     private assignNormalizedRegisterEntries;
     private compileOwnedItem;
-    private compileOwnedDefinition;
+    private compileOwnedDefinitionWithScope;
+    computeCanonicalId(ownerResourceId: string, ownerUsesFrameworkRootIds: boolean, kind: Exclude<RegisterableKind, RegisterableKind.ResourceWithConfig>, currentId: string): string;
+    compileOwnedDefinition(ownerResourceId: string, ownerUsesFrameworkRootIds: boolean, item: RegisterableItems, kind: Exclude<RegisterableKind, RegisterableKind.ResourceWithConfig>): RegisterableItems;
     private cloneDefinitionWithId;
     private assignClonedDefinitionId;
-    private computeCanonicalId;
-    private assertLocalName;
     private resolveRegisterableId;
     storeResource<_C>(item: IResource<any, any, any>, overrideMode?: StoringMode): AnyResource;
     storeTask<_C>(item: ITask<any, any, {}>, storingMode?: StoringMode): void;
@@ -62,6 +64,7 @@ export declare class StoreRegistryWriter {
     private normalizeMiddlewareAttachment;
     private resolveOwnerResourceIdFromTaskId;
     private didArrayChange;
+    private normalizeOwnerScopeArg;
     private normalizeDefinitionTags;
 }
 export {};

package/dist/types/models/store-registry/registerableKind.d.ts

@@ -0,0 +1,19 @@
+import { RegisterableItems } from "../../defs";
+export declare enum RegisterableKind {
+    Task = "task",
+    Error = "error",
+    Hook = "hook",
+    Resource = "resource",
+    Event = "event",
+    AsyncContext = "asyncContext",
+    TaskMiddleware = "taskMiddleware",
+    ResourceMiddleware = "resourceMiddleware",
+    ResourceWithConfig = "resourceWithConfig",
+    Tag = "tag"
+}
+/**
+ * Shared registerable classification used by both registration and validation
+ * paths so new definition kinds cannot drift between those code paths.
+ */
+export declare function resolveRegisterableKind(item: RegisterableItems): RegisterableKind | null;
+export declare function describeRegisterableKind(kind: RegisterableKind | null): string;

package/dist/types/node/node.d.ts

@@ -68,7 +68,7 @@ export declare const resources: Readonly<{
         description: string;
     }, import("..").ResourceTagType[], import("..").ResourceMiddlewareAttachmentType[]>;
     rateLimit: import("..").IResource<void, Promise<{
-        states: WeakMap<import("..").RateLimitMiddlewareConfig, import("..").RateLimitState>;
+        states: WeakMap<import("..").RateLimitMiddlewareConfig, Map<string, import("..").RateLimitState>>;
     }>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
@@ -77,7 +77,7 @@ export declare const resources: Readonly<{
     }>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
-    temporal: import("..").IResource<void, Promise<import("../globals/middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("..").ITag<{
+    temporal: import("..").IResource<void, Promise<import("../globals/middleware/temporal.shared").TemporalResourceState<import("..").TemporalMiddlewareConfig>>, {}, any, any, import("..").ITag<{
         metadata?: Record<string, any>;
     }, void, void, void>[], import("..").ResourceMiddlewareAttachmentType[]>;
     concurrency: import("..").IResource<void, Promise<{

package/dist/types/node/rpc-lanes/rpcLanes.resource.d.ts

@@ -1,2 +1,3 @@
 import type { RpcLanesResourceConfig, RpcLanesResourceValue } from "./types";
+export declare const RPC_LANES_RESOURCE_ID = "runner.node.rpcLanes";
 export declare const rpcLanesResource: import("../..").IResource<RpcLanesResourceConfig<import("./types").RpcLanesTopology, string>, Promise<RpcLanesResourceValue>, {}, any, any, import("../..").ResourceTagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/public.d.ts

@@ -1,201 +1,22 @@
 import { defineTask, defineResource, defineEvent, defineEventLane, defineRpcLane, defineTaskMiddleware, defineResourceMiddleware, defineOverride, defineTag, defineHook, isTask, isResource, isResourceWithConfig, isEvent, isEventLane, isRpcLane, isHook, isTaskMiddleware, isResourceMiddleware, isTag, isTagStartup, isOptional, isError, isAsyncContext, isOverrideDefinition, isSubtreeFilter, isIsolationScope } from "./define";
 import { defineAsyncContext } from "./definers/defineAsyncContext";
+import { globalEvents } from "./globals/globalEvents";
+import { globalResources } from "./globals/globalResources";
+import { globalMiddlewares } from "./globals/globalMiddleware";
+import { globalTags } from "./globals/globalTags";
+import { debug as globalDebug } from "./globals/debug";
 import { run } from "./run";
 import { onAnyOf, isOneOf } from "./types/event";
 import { subtreeOf as subtreeOfFn } from "./tools/subtreeOf";
 import { scope as scopeFn } from "./tools/scope";
 import { isSameDefinition } from "./tools/isSameDefinition";
 import { asyncContexts } from "./asyncContexts";
-export declare const resources: Readonly<{
-    health: import("./defs").IResource<void, Promise<import("./defs").IHealthReporter>, {
-        store: typeof import("./globals/globalResources").store;
-    }, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    timers: import("./defs").IResource<void, Promise<import("./public-types").ITimers>, {
-        store: typeof import("./globals/globalResources").store;
-    }, {
-        controller?: import("./models").RuntimeTimers;
-    }, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    logger: import("./defs").IResource<void, Promise<import("./models").Logger>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    debug: import("./defs").IResource<import("./public").DebugFriendlyConfig, Promise<any>, {}, any, {
-        title: string;
-        description: string;
-    }, import("./defs").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    serializer: import("./defs").IResource<void, Promise<import("./serializer").SerializerLike>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    cacheProvider: import("./defs").IResource<void, Promise<import("./globals/middleware/cache.shared").CacheProvider>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    cache: import("./defs").IResource<import("./public").CacheResourceConfig, Promise<{
-        map: Map<string, import("./defs").ICacheProvider>;
-        pendingCreates: Map<string, Promise<import("./defs").ICacheProvider>>;
-        cacheProvider: import("./globals/middleware/cache.shared").CacheProvider;
-        totalBudgetBytes?: number;
-        sharedBudget?: import("./globals/middleware/cache.shared").SharedCacheBudgetState;
-        defaultOptions: import("./globals/middleware/cache.shared").CacheFactoryOptions;
-    }>, {
-        cacheProvider: typeof import("./globals/middleware/cache.middleware").cacheProviderResource;
-    }, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    cron: import("./defs").IResource<import("./public").CronResourceConfig, Promise<import("./public").CronResourceValue>, import("./defs").DependencyMapType & {
-        cron: typeof import("./globals/cron/cron.tag").cronTag;
-        logger: typeof import("./globals/resources/logger.resource").loggerResource;
-        store: typeof import("./globals/globalResources").store;
-        taskRunner: typeof import("./globals/resources/taskRunner.resource").taskRunnerResource;
-    }, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    queue: import("./defs").IResource<void, Promise<{
-        map: any;
-        run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
-    }>, {}, {
-        disposed: boolean;
-        map: Map<string, import("./models").Queue>;
-        cleanupTimers: Map<string, NodeJS.Timeout>;
-    }, {
-        title: string;
-        description: string;
-    }, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    rateLimit: import("./defs").IResource<void, Promise<{
-        states: WeakMap<import("./public").RateLimitMiddlewareConfig, import("./public").RateLimitState>;
-    }>, {}, any, any, import("./defs").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    circuitBreaker: import("./defs").IResource<void, Promise<{
-        statusMap: Map<string, import("./public").CircuitBreakerStatus>;
-    }>, {}, any, any, import("./defs").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    temporal: import("./defs").IResource<void, Promise<import("./globals/middleware/temporal.middleware").TemporalResourceState>, {}, any, any, import("./defs").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    concurrency: import("./defs").IResource<void, Promise<{
-        semaphoresByConfig: WeakMap<import("./public").ConcurrencyMiddlewareConfig, import("./models").Semaphore>;
-        semaphoresByKey: Map<string, {
-            semaphore: import("./models").Semaphore;
-            limit: number;
-        }>;
-        semaphores: Set<import("./models").Semaphore>;
-    }>, {}, any, any, import("./defs").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    store: import("./defs").IResource<void, Promise<import("./models").Store>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    middlewareManager: import("./defs").IResource<void, Promise<import("./models").MiddlewareManager>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("./defs").IResource<void, Promise<import("./models").EventManager>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    taskRunner: import("./defs").IResource<void, Promise<import("./models").TaskRunner>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-    runtime: import("./defs").IResource<void, Promise<import("./models").RunResult<unknown>>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-}>;
-export declare const events: Readonly<{
-    ready: import("./defs").IEvent<void> & {
-        parallel?: boolean | undefined;
-        transactional?: boolean | undefined;
-    };
-    disposing: import("./defs").IEvent<void> & {
-        parallel?: boolean | undefined;
-        transactional?: boolean | undefined;
-    };
-    drained: import("./defs").IEvent<void> & {
-        parallel?: boolean | undefined;
-        transactional?: boolean | undefined;
-    };
-}>;
-export declare const middleware: Readonly<{
-    requireContext: typeof import("./globals/middleware/requireContext.middleware").requireContextTaskMiddleware;
-    task: {
-        requireContext: typeof import("./globals/middleware/requireContext.middleware").requireContextTaskMiddleware;
-        cache: import("./defs").ITaskMiddleware<import("./globals/middleware/cache.shared").CacheFactoryOptions & {
-            keyBuilder?: (taskId: string, input: unknown) => string;
-        }, any, any, {
-            cache: import("./defs").IResource<import("./public").CacheResourceConfig, Promise<{
-                map: Map<string, import("./defs").ICacheProvider>;
-                pendingCreates: Map<string, Promise<import("./defs").ICacheProvider>>;
-                cacheProvider: import("./globals/middleware/cache.shared").CacheProvider;
-                totalBudgetBytes?: number;
-                sharedBudget?: import("./globals/middleware/cache.shared").SharedCacheBudgetState;
-                defaultOptions: import("./globals/middleware/cache.shared").CacheFactoryOptions;
-            }>, {
-                cacheProvider: typeof import("./globals/middleware/cache.middleware").cacheProviderResource;
-            }, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-            logger: import("./defs").IOptionalDependency<import("./defs").IResource<void, Promise<import("./models").Logger>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>>;
-        }> & {
-            journalKeys: {
-                readonly hit: import("./public-types").JournalKey<boolean>;
-            };
-        };
-        concurrency: typeof import("./globals/middleware/concurrency.middleware").concurrencyTaskMiddleware;
-        debounce: typeof import("./globals/middleware/temporal.middleware").debounceTaskMiddleware;
-        throttle: typeof import("./globals/middleware/temporal.middleware").throttleTaskMiddleware;
-        fallback: import("./defs").ITaskMiddleware<import("./public").FallbackMiddlewareConfig, any, any, {
-            taskRunner: import("./defs").IResource<void, Promise<import("./models").TaskRunner>, {}, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-        }> & {
-            journalKeys: {
-                readonly active: import("./public-types").JournalKey<boolean>;
-                readonly error: import("./public-types").JournalKey<Error>;
-            };
-        };
-        rateLimit: import("./defs").ITaskMiddleware<import("./public").RateLimitMiddlewareConfig, any, any, {
-            state: import("./defs").IResource<void, Promise<{
-                states: WeakMap<import("./public").RateLimitMiddlewareConfig, import("./public").RateLimitState>;
-            }>, {}, any, any, import("./defs").ITag<{
-                metadata?: Record<string, any>;
-            }, void, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-        }> & {
-            journalKeys: {
-                readonly remaining: import("./public-types").JournalKey<number>;
-                readonly resetTime: import("./public-types").JournalKey<number>;
-                readonly limit: import("./public-types").JournalKey<number>;
-            };
-        };
-        retry: import("./defs").ITaskMiddleware<import("./public").RetryMiddlewareConfig, any, any, any> & {
-            journalKeys: {
-                readonly attempt: import("./public-types").JournalKey<number>;
-                readonly lastError: import("./public-types").JournalKey<Error>;
-            };
-        };
-        timeout: import("./defs").ITaskMiddleware<import("./public").TimeoutMiddlewareConfig, any, any, any> & {
-            journalKeys: {
-                readonly abortController: import("./public-types").JournalKey<AbortController>;
-            };
-        };
-        circuitBreaker: import("./defs").ITaskMiddleware<import("./public").CircuitBreakerMiddlewareConfig, any, any, {
-            state: import("./defs").IResource<void, Promise<{
-                statusMap: Map<string, import("./public").CircuitBreakerStatus>;
-            }>, {}, any, any, import("./defs").ITag<{
-                metadata?: Record<string, any>;
-            }, void, void, void>[], import("./defs").ResourceMiddlewareAttachmentType[]>;
-        }> & {
-            journalKeys: {
-                readonly state: import("./public-types").JournalKey<import("./public").CircuitBreakerState>;
-                readonly failures: import("./public-types").JournalKey<number>;
-            };
-        };
-    };
-    resource: {
-        retry: typeof import("./globals/middleware/retry.middleware").retryResourceMiddleware;
-        timeout: typeof import("./globals/middleware/timeout.middleware").timeoutResourceMiddleware;
-    };
-}>;
-export declare const tags: Readonly<{
-    system: import("./defs").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void, void>;
-    excludeFromGlobalHooks: import("./defs").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void, void>;
-    eventLane: import("./defs").ITag<{
-        lane: import("./defs").IEventLaneDefinition;
-    }, void, void, void>;
-    rpcLane: import("./defs").ITag<{
-        lane: import("./defs").IRpcLaneDefinition;
-    }, void, void, void>;
-    rpcLanes: import("./defs").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void, void>;
-    debug: import("./defs").ITag<import("./public").DebugFriendlyConfig, void, void, void>;
-    cron: import("./defs").ITag<import("./public").CronTagConfig, void, void, void>;
-    authValidator: import("./defs").ITag<void, void, void, void>;
-    failWhenUnhealthy: import("./defs").ITag<readonly (string | import("./defs").IResource<any, any, any, any, any, import("./defs").ResourceTagType[], import("./defs").ResourceMiddlewareAttachmentType[]>)[], void, void, void>;
-}>;
+export declare const resources: Readonly<typeof globalResources>;
+export declare const events: Readonly<typeof globalEvents>;
+export declare const middleware: Readonly<typeof globalMiddlewares>;
+export declare const tags: Readonly<typeof globalTags>;
 export declare const debug: Readonly<{
-    levels: {
-        normal: import("./public").DebugConfig;
-        verbose: import("./public").DebugConfig;
-    };
+    levels: typeof globalDebug.levels;
 }>;
 export { defineTask, defineResource, defineEvent, defineEventLane, defineRpcLane, defineTaskMiddleware, defineResourceMiddleware, defineAsyncContext, defineTag, defineOverride, defineHook, isTask, isResource, isResourceWithConfig, isEvent, isEventLane, isRpcLane, isHook, isTaskMiddleware, isResourceMiddleware, isTag, isTagStartup, isOptional, isError, isAsyncContext, isOverrideDefinition, isSubtreeFilter, isIsolationScope, run, onAnyOf, isOneOf, isSameDefinition, subtreeOfFn as subtreeOf, scopeFn as scope, asyncContexts, };
 /**

package/dist/types/types/resource.d.ts

@@ -228,11 +228,6 @@ export interface IResourceDefinition<TConfig = any, TValue extends Promise<any>
     [symbolResourceSubtreeDeclarations]?: ReadonlyArray<ResourceSubtreePolicyDeclaration<TConfig>>;
     /** @internal Ordered isolate declarations preserved across builder composition. */
     [symbolResourceIsolateDeclarations]?: ReadonlyArray<IsolationPolicyDeclaration<TConfig>>;
-    /**
-     * When true, this resource acts as a namespace gateway and does not add its
-     * own id prefix when compiling ids for items in its register tree.
-     */
-    gateway?: boolean;
     tags?: TTags;
 }
 /**
@@ -270,10 +265,6 @@ export interface IResource<TConfig = void, TValue extends Promise<any> = Promise
     [symbolResourceSubtreeDeclarations]?: ReadonlyArray<ResourceSubtreePolicyDeclaration<TConfig>>;
     /** @internal Ordered isolate declarations preserved across builder composition. */
     [symbolResourceIsolateDeclarations]?: ReadonlyArray<IsolationPolicyDeclaration<TConfig>>;
-    /**
-     * Namespace gateway flag copied from the definition.
-     */
-    gateway?: boolean;
     /** Return an optional dependency wrapper for this resource. */
     optional: () => IOptionalDependency<IResource<TConfig, TValue, TDependencies, TContext, TMeta, TTags, TMiddleware>>;
     tags: TTags;

package/dist/types/types/subtree.d.ts

@@ -100,8 +100,10 @@ export type NormalizedResourceSubtreePolicy = {
 export type SubtreePolicyOptions = {
     override?: boolean;
 };
-export type ResourceSubtreePolicyResolver<TConfig = unknown> = (config: TConfig) => ResourceSubtreePolicy;
-export type ResourceSubtreePolicyInput<TConfig = unknown> = ResourceSubtreePolicy | ResourceSubtreePolicyResolver<TConfig>;
+export type ResourceSubtreePolicyValue = ResourceSubtreePolicy;
+export type ResourceSubtreePolicyList = ResourceSubtreePolicyValue | ResourceSubtreePolicyValue[];
+export type ResourceSubtreePolicyResolver<TConfig = unknown> = (config: TConfig) => ResourceSubtreePolicyList;
+export type ResourceSubtreePolicyInput<TConfig = unknown> = ResourceSubtreePolicyList | ResourceSubtreePolicyResolver<TConfig>;
 export type ResourceSubtreePolicyDeclaration<TConfig = unknown> = {
     policy: ResourceSubtreePolicyInput<TConfig>;
     options?: SubtreePolicyOptions;