@bluelibs/runner 6.0.0 → 6.1.0

package/dist/universal/index.cjs

@@ -292,6 +292,9 @@ var init_isSameDefinition = __esm({
 function isReservedDefinitionLocalName(name) {
   return reservedDefinitionLocalNameSet.has(name);
 }
+function isReservedInternalDefinitionId(id3) {
+  return reservedInternalDefinitionIdSet.has(id3);
+}
 function canUseFrameworkDottedId(definitionId, allowReservedDottedNamespace) {
   if (!allowReservedDottedNamespace) {
     return false;
@@ -300,6 +303,9 @@ function canUseFrameworkDottedId(definitionId, allowReservedDottedNamespace) {
     (prefix) => definitionId.startsWith(prefix)
   );
 }
+function canUseReservedInternalDefinitionId(allowReservedInternalId) {
+  return allowReservedInternalId === true;
+}
 function toDisplayId(value) {
   if (typeof value === "string") {
     return value.length > 0 ? value : "<empty>";
@@ -342,8 +348,15 @@ function assertDefinitionId(definitionType, id3, options) {
       originalError: `${definitionType} id "${definitionId}" is reserved by Runner and cannot be used as a standalone id.`
     });
   }
+  if (isReservedInternalDefinitionId(definitionId) && !canUseReservedInternalDefinitionId(options?.allowReservedInternalId)) {
+    validationError.throw({
+      subject: `${definitionType} id`,
+      id: definitionId,
+      originalError: `${definitionType} id "${definitionId}" is reserved for internal Runner resources.`
+    });
+  }
 }
-var RESERVED_DEFINITION_LOCAL_NAMES, FRAMEWORK_DOTTED_ID_PREFIXES, reservedDefinitionLocalNameSet;
+var RESERVED_DEFINITION_LOCAL_NAMES, RESERVED_INTERNAL_DEFINITION_IDS, FRAMEWORK_DOTTED_ID_PREFIXES, reservedDefinitionLocalNameSet, reservedInternalDefinitionIdSet;
 var init_assertDefinitionId = __esm({
   "src/definers/assertDefinitionId.ts"() {
     init_errors2();
@@ -356,6 +369,9 @@ var init_assertDefinitionId = __esm({
       "errors",
       "asyncContexts"
     ]);
+    RESERVED_INTERNAL_DEFINITION_IDS = Object.freeze([
+      "runtime-framework-root"
+    ]);
     FRAMEWORK_DOTTED_ID_PREFIXES = Object.freeze([
       "runner.",
       "system."
@@ -363,8 +379,13 @@ var init_assertDefinitionId = __esm({
     reservedDefinitionLocalNameSet = new Set(
       RESERVED_DEFINITION_LOCAL_NAMES
     );
+    reservedInternalDefinitionIdSet = new Set(
+      RESERVED_INTERNAL_DEFINITION_IDS
+    );
     __name(isReservedDefinitionLocalName, "isReservedDefinitionLocalName");
+    __name(isReservedInternalDefinitionId, "isReservedInternalDefinitionId");
     __name(canUseFrameworkDottedId, "canUseFrameworkDottedId");
+    __name(canUseReservedInternalDefinitionId, "canUseReservedInternalDefinitionId");
     __name(toDisplayId, "toDisplayId");
     __name(requireStringId, "requireStringId");
     __name(assertDefinitionId, "assertDefinitionId");
@@ -3517,8 +3538,6 @@ var init_domain_error_ids = __esm({
       RunnerErrorId2["RpcLaneOwnershipConflict"] = "runner.errors.rpcLane.ownershipConflict";
       RunnerErrorId2["RpcLaneExposureOwnerInvalid"] = "runner.errors.rpcLane.exposureOwnerInvalid";
       RunnerErrorId2["ResourceForkNonLeafUnsupported"] = "runner.errors.resourceFork.nonLeafUnsupported";
-      RunnerErrorId2["ResourceForkGatewayUnsupported"] = "runner.errors.resourceFork.gatewayUnsupported";
-      RunnerErrorId2["RunRootGatewayUnsupported"] = "runner.errors.run.rootGatewayUnsupported";
       RunnerErrorId2["BuilderInvalidHttpCode"] = "runner.errors.builder.invalidHttpCode";
       RunnerErrorId2["OverrideUnsupportedBase"] = "runner.errors.override.unsupportedBase";
       RunnerErrorId2["OverrideDefinitionRequired"] = "runner.errors.overrideDefinitionRequired";
@@ -3552,7 +3571,7 @@ var init_domain_error_ids = __esm({
 });
 
 // src/errors/domain-runtime.errors.ts
-var httpBaseUrlRequiredError, httpFetchUnavailableError, httpContextSerializationError, httpEventWithResultUnavailableError, httpClientInputUnsupportedError, middlewareConcurrencyConflictError, middlewareContextRequiredError, middlewareTimeoutError, middlewareCircuitBreakerOpenError, middlewareRateLimitExceededError, middlewareTemporalDisposedError, rpcLaneHttpClientPresetNotFoundError, rpcLaneCommunicatorContractError, rpcLaneInvalidIdError, rpcLaneProfileNotFoundError, rpcLaneBindingNotFoundError, rpcLaneDuplicateBindingError, rpcLaneTaskAssignmentConflictError, rpcLaneEventAssignmentConflictError, rpcLaneApplyToInvalidTargetError, rpcLaneApplyToTargetTypeError, rpcLaneApplyToTargetNotFoundError, rpcLaneAssignmentEventLaneConflictError, rpcLaneCommunicatorResourceInvalidError, rpcLanesExposureModeError, rpcLanesExposureOwnerInvalidError, remoteLaneAuthSignerMissingError, remoteLaneAuthVerifierMissingError, remoteLaneAuthUnauthorizedError, resourceForkNonLeafUnsupportedError, resourceForkGatewayUnsupportedError, runRootGatewayUnsupportedError, builderInvalidHttpCodeError, overrideUnsupportedBaseError, platformUnreachableError, platformInvariantError, serializerInvalidPayloadError, serializerValidationError, serializerPayloadValidationError, serializerDepthExceededError, serializerReferenceResolutionError, serializerUnsupportedFeatureError, serializerTypeRegistryError, serializerSymbolPolicyError, nodeInputFileConsumedError, nodeInputFileUnavailableError, nodeExposureMultipartLimitExceededError, optionalDependencyInvalidExportError, optionalDependencyMissingError, durableStoreShapeError, durableQueueNotInitializedError, eventLaneQueueNotInitializedError, eventLaneInvalidIdError, eventLaneProfileNotFoundError, eventLaneBindingNotFoundError, eventLaneDuplicateBindingError, eventLaneRetryPolicyInvalidError, eventLaneQueueReferenceInvalidError, eventLaneAssignmentConflictError, eventLaneApplyToInvalidTargetError, eventLaneApplyToTargetTypeError, eventLaneApplyToTargetNotFoundError, eventLaneAssignmentRpcLaneConflictError, eventLaneEventNotRegisteredError, eventLaneMessageMalformedError, durableContextCancelledError, durableStepDefinitionError, durableDeterminismViolationError, durableSignalTimeoutError, durableScheduleConfigError, durableExecutionError, durableExecutionInvariantError, durableOperatorUnsupportedStoreCapabilityError, lockableMapLockedError;
+var httpBaseUrlRequiredError, httpFetchUnavailableError, httpContextSerializationError, httpEventWithResultUnavailableError, httpClientInputUnsupportedError, middlewareConcurrencyConflictError, middlewareContextRequiredError, middlewareTimeoutError, middlewareCircuitBreakerOpenError, middlewareRateLimitExceededError, middlewareTemporalDisposedError, rpcLaneHttpClientPresetNotFoundError, rpcLaneCommunicatorContractError, rpcLaneInvalidIdError, rpcLaneProfileNotFoundError, rpcLaneBindingNotFoundError, rpcLaneDuplicateBindingError, rpcLaneTaskAssignmentConflictError, rpcLaneEventAssignmentConflictError, rpcLaneApplyToInvalidTargetError, rpcLaneApplyToTargetTypeError, rpcLaneApplyToTargetNotFoundError, rpcLaneAssignmentEventLaneConflictError, rpcLaneCommunicatorResourceInvalidError, rpcLanesExposureModeError, rpcLanesExposureOwnerInvalidError, remoteLaneAuthSignerMissingError, remoteLaneAuthVerifierMissingError, remoteLaneAuthUnauthorizedError, resourceForkNonLeafUnsupportedError, builderInvalidHttpCodeError, overrideUnsupportedBaseError, platformUnreachableError, platformInvariantError, serializerInvalidPayloadError, serializerValidationError, serializerPayloadValidationError, serializerDepthExceededError, serializerReferenceResolutionError, serializerUnsupportedFeatureError, serializerTypeRegistryError, serializerSymbolPolicyError, nodeInputFileConsumedError, nodeInputFileUnavailableError, nodeExposureMultipartLimitExceededError, optionalDependencyInvalidExportError, optionalDependencyMissingError, durableStoreShapeError, durableQueueNotInitializedError, eventLaneQueueNotInitializedError, eventLaneInvalidIdError, eventLaneProfileNotFoundError, eventLaneBindingNotFoundError, eventLaneDuplicateBindingError, eventLaneRetryPolicyInvalidError, eventLaneQueueReferenceInvalidError, eventLaneAssignmentConflictError, eventLaneApplyToInvalidTargetError, eventLaneApplyToTargetTypeError, eventLaneApplyToTargetNotFoundError, eventLaneAssignmentRpcLaneConflictError, eventLaneEventNotRegisteredError, eventLaneMessageMalformedError, durableContextCancelledError, durableStepDefinitionError, durableDeterminismViolationError, durableSignalTimeoutError, durableScheduleConfigError, durableExecutionError, durableExecutionInvariantError, durableOperatorUnsupportedStoreCapabilityError, lockableMapLockedError;
 var init_domain_runtime_errors = __esm({
   "src/errors/domain-runtime.errors.ts"() {
     init_error2();
@@ -3668,7 +3687,7 @@ var init_domain_runtime_errors = __esm({
       'Use mode: "network" when enabling exposure.http, or remove exposure.http for transparent/local-simulated modes.'
     ).build();
     rpcLanesExposureOwnerInvalidError = frameworkError("runner.errors.rpcLane.exposureOwnerInvalid" /* RpcLaneExposureOwnerInvalid */).format(
-      ({ ownerResourceId }) => `RPC HTTP exposure can only be owned by "platform-node-resources-rpcLanes". Received owner "${ownerResourceId}".`
+      ({ ownerResourceId }) => `RPC HTTP exposure can only be owned by "runner.node.rpcLanes". Received owner "${ownerResourceId}".`
     ).remediation(
       "Start RPC HTTP exposure only through rpcLanesResource.with({ exposure: { http: ... } }) in network mode."
     ).build();
@@ -3692,16 +3711,6 @@ var init_domain_runtime_errors = __esm({
     ).remediation(
       ({ id: id3 }) => `Do not call .fork() on non-leaf resource "${id3}". Compose a distinct parent resource and register distinct children explicitly. Use a dedicated factory API when the template owns a registered subtree.`
     ).build();
-    resourceForkGatewayUnsupportedError = frameworkError("runner.errors.resourceFork.gatewayUnsupported" /* ResourceForkGatewayUnsupported */).format(
-      ({ id: id3 }) => `Resource "${id3}" cannot be forked because gateway resources suppress their own namespace segment.`
-    ).remediation(
-      ({ id: id3 }) => `Do not call .fork() on gateway resource "${id3}". Register a distinct non-gateway resource, or compose separate gateway resources with unique registered children instead.`
-    ).build();
-    runRootGatewayUnsupportedError = frameworkError("runner.errors.run.rootGatewayUnsupported" /* RunRootGatewayUnsupported */).format(
-      ({ id: id3 }) => `Resource "${id3}" cannot be passed to run() because gateway resources are structural-only.`
-    ).remediation(
-      ({ id: id3 }) => `Wrap gateway resource "${id3}" in a distinct non-gateway root resource, then call run(root) instead.`
-    ).build();
     builderInvalidHttpCodeError = frameworkError("runner.errors.builder.invalidHttpCode" /* BuilderInvalidHttpCode */).format(
       ({ value }) => `Error httpCode must be an integer between 100 and 599. Received: ${value}`
     ).remediation(
@@ -3968,7 +3977,6 @@ __export(errors_exports, {
   remoteLaneAuthUnauthorizedError: () => remoteLaneAuthUnauthorizedError,
   remoteLaneAuthVerifierMissingError: () => remoteLaneAuthVerifierMissingError,
   resourceCooldownAdmissionTargetInvalidError: () => resourceCooldownAdmissionTargetInvalidError,
-  resourceForkGatewayUnsupportedError: () => resourceForkGatewayUnsupportedError,
   resourceForkNonLeafUnsupportedError: () => resourceForkNonLeafUnsupportedError,
   resourceNotFoundError: () => resourceNotFoundError,
   resultSchemaValidationError: () => resultSchemaValidationError,
@@ -3990,7 +3998,6 @@ __export(errors_exports, {
   rpcLanesExposureOwnerInvalidError: () => rpcLanesExposureOwnerInvalidError,
   runResultDisposeDuringBootstrapError: () => runResultDisposeDuringBootstrapError,
   runResultDisposedError: () => runResultDisposedError,
-  runRootGatewayUnsupportedError: () => runRootGatewayUnsupportedError,
   runtimeAccessViolationError: () => runtimeAccessViolationError,
   runtimeAdmissionControlDuringBootstrapError: () => runtimeAdmissionControlDuringBootstrapError,
   runtimeAdmissionsPausedError: () => runtimeAdmissionsPausedError,
@@ -4611,6 +4618,21 @@ function normalizeResourceSubtreePolicy(policy) {
   return normalized;
 }
 __name(normalizeResourceSubtreePolicy, "normalizeResourceSubtreePolicy");
+function toSubtreePolicyArray(policy) {
+  if (policy === void 0) {
+    return [];
+  }
+  return Array.isArray(policy) ? [...policy] : [policy];
+}
+__name(toSubtreePolicyArray, "toSubtreePolicyArray");
+function mergeSubtreePolicyList(existing, incoming, options) {
+  let merged = cloneNormalizedSubtreePolicy(existing);
+  for (const policy of toSubtreePolicyArray(incoming)) {
+    merged = mergeResourceSubtreePolicy(merged, policy, options);
+  }
+  return merged;
+}
+__name(mergeSubtreePolicyList, "mergeSubtreePolicyList");
 function mergeSubtreeMiddlewareBranch(existing, incoming, override) {
   if (!existing || override) {
     return {
@@ -4730,8 +4752,8 @@ __name(mergeResourceSubtreeDeclarations, "mergeResourceSubtreeDeclarations");
 function resolveResourceSubtreeDeclarations(declarations, config) {
   let merged;
   for (const declaration of declarations ?? []) {
-    const policy = typeof declaration.policy === "function" ? declaration.policy(config) : declaration.policy;
-    merged = mergeResourceSubtreePolicy(merged, policy, declaration.options);
+    const policyList = typeof declaration.policy === "function" ? declaration.policy(config) : declaration.policy;
+    merged = mergeSubtreePolicyList(merged, policyList, declaration.options);
   }
   return merged;
 }
@@ -4746,7 +4768,7 @@ function createDisplaySubtreePolicy(declarations) {
   if (!hasDynamic) {
     let merged;
     for (const declaration of declarations) {
-      merged = mergeResourceSubtreePolicy(
+      merged = mergeSubtreePolicyList(
         merged,
         declaration.policy,
         declaration.options
@@ -4910,7 +4932,8 @@ function defineResource(constConfig) {
   const filePath = constConfig[symbolFilePath] || getCallerFile();
   const id3 = constConfig.id;
   assertDefinitionId("Resource", id3, {
-    allowReservedDottedNamespace: isFrameworkDefinitionMarked(constConfig)
+    allowReservedDottedNamespace: isFrameworkDefinitionMarked(constConfig),
+    allowReservedInternalId: isFrameworkDefinitionMarked(constConfig)
   });
   const configSchema = normalizeOptionalValidationSchema(
     constConfig.configSchema,
@@ -4936,7 +4959,6 @@ function defineResource(constConfig) {
     [symbolResourceRegistersChildren]: constConfig.register !== void 0 ? true : void 0,
     [symbolFilePath]: filePath,
     id: id3,
-    gateway: constConfig.gateway === true,
     dependencies: constConfig.dependencies,
     dispose: constConfig.dispose,
     ready: constConfig.ready,
@@ -4983,8 +5005,7 @@ function defineResource(constConfig) {
     isolate: current.isolate,
     subtree: current.subtree,
     [symbolResourceIsolateDeclarations]: current[symbolResourceIsolateDeclarations],
-    [symbolResourceSubtreeDeclarations]: current[symbolResourceSubtreeDeclarations],
-    gateway: current.gateway
+    [symbolResourceSubtreeDeclarations]: current[symbolResourceSubtreeDeclarations]
   }), "buildDefinition");
   base.with = function(config) {
     const current = resolveCurrent(this);
@@ -5021,9 +5042,6 @@ function defineResource(constConfig) {
     if (current[symbolResourceRegistersChildren] === true) {
       resourceForkNonLeafUnsupportedError.throw({ id: current.id });
     }
-    if (current.gateway === true) {
-      resourceForkGatewayUnsupportedError.throw({ id: current.id });
-    }
     const forkCallerFilePath = getCallerFile();
     const forked = defineResource({
       ...buildDefinition(current),
@@ -10158,9 +10176,15 @@ init_defineError();
 init_errors2();
 init_check();
 init_symbols();
+
+// src/globals/middleware/keyBuilder.shared.ts
+var defaultTaskKeyBuilder = /* @__PURE__ */ __name((taskId) => taskId, "defaultTaskKeyBuilder");
+
+// src/globals/middleware/rateLimit.middleware.ts
 var rateLimitConfigPattern = exports.Match.ObjectIncluding({
   windowMs: exports.Match.PositiveInteger,
-  max: exports.Match.PositiveInteger
+  max: exports.Match.PositiveInteger,
+  keyBuilder: exports.Match.Optional(Function)
 });
 var RateLimitError = class extends exports.RunnerError {
   static {
@@ -10177,6 +10201,7 @@ var RateLimitError = class extends exports.RunnerError {
     );
   }
 };
+var RATE_LIMIT_STATE_PRUNE_THRESHOLD = 1e3;
 var journalKeys3 = {
   /** Number of remaining requests in the current window */
   remaining: journal.createKey(
@@ -10202,6 +10227,17 @@ var rateLimitResource = defineResource(
     }, "init")
   })
 );
+function pruneExpiredRateLimitStates(keyedStates, now) {
+  if (keyedStates.size < RATE_LIMIT_STATE_PRUNE_THRESHOLD) {
+    return;
+  }
+  for (const [key, keyedState] of keyedStates) {
+    if (now >= keyedState.resetTime) {
+      keyedStates.delete(key);
+    }
+  }
+}
+__name(pruneExpiredRateLimitStates, "pruneExpiredRateLimitStates");
 var rateLimitTaskMiddleware = defineTaskMiddleware(
   markFrameworkDefinition({
     id: "runner.middleware.task.rateLimit",
@@ -10209,15 +10245,24 @@ var rateLimitTaskMiddleware = defineTaskMiddleware(
     configSchema: rateLimitConfigPattern,
     dependencies: { state: rateLimitResource },
     async run({ task: task2, next, journal: journal2 }, { state }, config) {
+      const taskId = task2.definition.id;
+      const keyBuilder = config.keyBuilder ?? defaultTaskKeyBuilder;
+      const key = keyBuilder(taskId, task2.input);
       const { states } = state;
-      let limitState = states.get(config);
       const now = Date.now();
+      let keyedStates = states.get(config);
+      if (!keyedStates) {
+        keyedStates = /* @__PURE__ */ new Map();
+        states.set(config, keyedStates);
+      }
+      pruneExpiredRateLimitStates(keyedStates, now);
+      let limitState = keyedStates.get(key);
       if (!limitState || now >= limitState.resetTime) {
         limitState = {
           count: 0,
           resetTime: now + config.windowMs
         };
-        states.set(config, limitState);
+        keyedStates.set(key, limitState);
       }
       const remaining = Math.max(0, config.max - limitState.count);
       journal2.set(journalKeys3.remaining, remaining, { override: true });
@@ -10245,16 +10290,9 @@ var rateLimitTaskMiddleware = defineTaskMiddleware(
 init_markFrameworkDefinition();
 init_errors2();
 init_check();
-var temporalConfigPattern = exports.Match.ObjectIncluding({
-  ms: exports.Match.PositiveInteger
-});
-var TEMPORAL_DISPOSED_ERROR_MESSAGE = "Temporal middleware resource has been disposed.";
-function createTemporalDisposedError() {
-  return middlewareTemporalDisposedError.new({
-    message: TEMPORAL_DISPOSED_ERROR_MESSAGE
-  });
-}
-__name(createTemporalDisposedError, "createTemporalDisposedError");
+
+// src/globals/middleware/temporal.shared.ts
+var TEMPORAL_STATE_PRUNE_THRESHOLD = 1e3;
 function rejectDebounceState(state, error2) {
   if (state.timeoutId) {
     clearTimeout(state.timeoutId);
@@ -10284,6 +10322,62 @@ function rejectThrottleState(state, error2) {
   });
 }
 __name(rejectThrottleState, "rejectThrottleState");
+function pruneIdleThrottleStates(keyedStates, trackedStates, now, windowMs) {
+  if (keyedStates.size < TEMPORAL_STATE_PRUNE_THRESHOLD) {
+    return;
+  }
+  for (const [key, throttleState] of keyedStates) {
+    const isIdle = throttleState.timeoutId === void 0 && throttleState.currentPromise === void 0 && throttleState.resolveList.length === 0 && throttleState.rejectList.length === 0 && now - throttleState.lastExecution >= windowMs;
+    if (isIdle) {
+      trackedStates.delete(throttleState);
+      keyedStates.delete(key);
+    }
+  }
+}
+__name(pruneIdleThrottleStates, "pruneIdleThrottleStates");
+
+// src/globals/middleware/temporal.middleware.ts
+var temporalConfigPattern = exports.Match.ObjectIncluding({
+  ms: exports.Match.PositiveInteger,
+  keyBuilder: exports.Match.Optional(Function)
+});
+var TEMPORAL_DISPOSED_ERROR_MESSAGE = "Temporal middleware resource has been disposed.";
+function createTemporalDisposedError() {
+  return middlewareTemporalDisposedError.new({
+    message: TEMPORAL_DISPOSED_ERROR_MESSAGE
+  });
+}
+__name(createTemporalDisposedError, "createTemporalDisposedError");
+function buildTemporalMiddlewareKey(config, taskId, input) {
+  const key = (config.keyBuilder ?? defaultTaskKeyBuilder)(taskId, input);
+  if (typeof key !== "string") {
+    validationError.throw({
+      subject: "Middleware config",
+      id: taskId,
+      originalError: `Temporal middleware keyBuilder must return a string. Received ${typeof key}.`
+    });
+  }
+  return key;
+}
+__name(buildTemporalMiddlewareKey, "buildTemporalMiddlewareKey");
+function getDebounceStatesForConfig(state, config) {
+  let keyedStates = state.debounceStates.get(config);
+  if (!keyedStates) {
+    keyedStates = /* @__PURE__ */ new Map();
+    state.debounceStates.set(config, keyedStates);
+  }
+  return keyedStates;
+}
+__name(getDebounceStatesForConfig, "getDebounceStatesForConfig");
+function getThrottleStatesForConfig(state, config) {
+  let keyedStates = state.throttleStates.get(config);
+  if (!keyedStates) {
+    keyedStates = /* @__PURE__ */ new Map();
+    state.throttleStates.set(config, keyedStates);
+  }
+  return keyedStates;
+}
+__name(getThrottleStatesForConfig, "getThrottleStatesForConfig");
 var temporalResource = defineResource(
   markFrameworkDefinition({
     id: "runner.temporal",
@@ -10323,15 +10417,18 @@ var debounceTaskMiddleware = defineTaskMiddleware(
       if (state.isDisposed === true) {
         throw createTemporalDisposedError();
       }
-      const debounceStates = state.debounceStates;
+      const taskId = task2.definition.id;
+      const key = buildTemporalMiddlewareKey(config, taskId, task2.input);
+      const debounceStates = getDebounceStatesForConfig(state, config);
       const trackedDebounceStates = state.trackedDebounceStates;
-      let debounceState = debounceStates.get(config);
+      let debounceState = debounceStates.get(key);
       if (!debounceState) {
         debounceState = {
+          key,
           resolveList: [],
           rejectList: []
         };
-        debounceStates.set(config, debounceState);
+        debounceStates.set(key, debounceState);
         trackedDebounceStates.add(debounceState);
       }
       debounceState.latestInput = task2.input;
@@ -10348,6 +10445,8 @@ var debounceTaskMiddleware = defineTaskMiddleware(
         debounceState.resolveList = [];
         debounceState.rejectList = [];
         debounceState.latestInput = void 0;
+        debounceStates.delete(debounceState.key);
+        trackedDebounceStates.delete(debounceState);
         if (state.isDisposed === true) {
           const disposeError = createTemporalDisposedError();
           rejectList.forEach((reject) => {
@@ -10380,16 +10479,25 @@ var throttleTaskMiddleware = defineTaskMiddleware(
       if (state.isDisposed === true) {
         throw createTemporalDisposedError();
       }
-      const throttleStates = state.throttleStates;
+      const taskId = task2.definition.id;
+      const key = buildTemporalMiddlewareKey(config, taskId, task2.input);
+      const throttleStates = getThrottleStatesForConfig(state, config);
       const trackedThrottleStates = state.trackedThrottleStates;
-      let throttleState = throttleStates.get(config);
+      pruneIdleThrottleStates(
+        throttleStates,
+        trackedThrottleStates,
+        Date.now(),
+        config.ms
+      );
+      let throttleState = throttleStates.get(key);
       if (!throttleState) {
         throttleState = {
+          key,
           lastExecution: 0,
           resolveList: [],
           rejectList: []
         };
-        throttleStates.set(config, throttleState);
+        throttleStates.set(key, throttleState);
         trackedThrottleStates.add(throttleState);
       }
       const now = Date.now();
@@ -17887,8 +17995,9 @@ var StoreRegistryTagIndex = class {
 
 // src/models/store-registry/StoreRegistryWriter.ts
 init_errors2();
+
+// src/models/store-registry/registerableKind.ts
 init_symbols();
-init_assertDefinitionId();
 function hasSymbolBrand(item, symbolKey) {
   if (item === null || item === void 0) {
     return false;
@@ -17934,6 +18043,190 @@ function resolveRegisterableKind(item) {
   return null;
 }
 __name(resolveRegisterableKind, "resolveRegisterableKind");
+
+// src/models/store-registry/CanonicalIdCompiler.ts
+init_errors2();
+init_assertDefinitionId();
+var CanonicalIdCompiler = class {
+  static {
+    __name(this, "CanonicalIdCompiler");
+  }
+  compute(ownerScope, kind, currentId) {
+    this.assertLocalName(ownerScope.resourceId, kind, currentId);
+    if (currentId.startsWith(`${ownerScope.resourceId}.`)) {
+      return currentId;
+    }
+    if (ownerScope.usesFrameworkRootIds) {
+      return this.computeFrameworkRootId(kind, currentId);
+    }
+    return this.computeOwnedId(ownerScope.resourceId, kind, currentId);
+  }
+  computeFrameworkRootId(kind, currentId) {
+    switch (kind) {
+      case "resource" /* Resource */:
+        return currentId;
+      case "task" /* Task */:
+        return `tasks.${currentId}`;
+      case "event" /* Event */:
+        return `events.${currentId}`;
+      case "hook" /* Hook */:
+        return `hooks.${currentId}`;
+      case "taskMiddleware" /* TaskMiddleware */:
+        return `middleware.task.${currentId}`;
+      case "resourceMiddleware" /* ResourceMiddleware */:
+        return `middleware.resource.${currentId}`;
+      case "tag" /* Tag */:
+        return `tags.${currentId}`;
+      case "error" /* Error */:
+        return `errors.${currentId}`;
+      case "asyncContext" /* AsyncContext */:
+        return `asyncContexts.${currentId}`;
+      default:
+        return currentId;
+    }
+  }
+  computeOwnedId(ownerResourceId, kind, currentId) {
+    switch (kind) {
+      case "resource" /* Resource */:
+        return `${ownerResourceId}.${currentId}`;
+      case "task" /* Task */:
+        return `${ownerResourceId}.tasks.${currentId}`;
+      case "event" /* Event */:
+        return `${ownerResourceId}.events.${currentId}`;
+      case "hook" /* Hook */:
+        return `${ownerResourceId}.hooks.${currentId}`;
+      case "taskMiddleware" /* TaskMiddleware */:
+        return `${ownerResourceId}.middleware.task.${currentId}`;
+      case "resourceMiddleware" /* ResourceMiddleware */:
+        return `${ownerResourceId}.middleware.resource.${currentId}`;
+      case "tag" /* Tag */:
+        return `${ownerResourceId}.tags.${currentId}`;
+      case "error" /* Error */:
+        return `${ownerResourceId}.errors.${currentId}`;
+      case "asyncContext" /* AsyncContext */:
+        return `${ownerResourceId}.asyncContexts.${currentId}`;
+      default:
+        return `${ownerResourceId}.${currentId}`;
+    }
+  }
+  assertLocalName(ownerResourceId, kind, currentId) {
+    if (currentId.trim().length === 0) {
+      validationError.throw({
+        subject: "Definition local name",
+        id: `${ownerResourceId}.${kind}`,
+        originalError: "Definition local names must be non-empty strings when using scoped registration."
+      });
+    }
+    if (isReservedDefinitionLocalName(currentId)) {
+      validationError.throw({
+        subject: "Definition local name",
+        id: `${ownerResourceId}.${kind}.${currentId}`,
+        originalError: `Local name "${currentId}" is reserved by Runner and cannot be used.`
+      });
+    }
+  }
+};
+
+// src/models/createFrameworkRootGateway.ts
+init_markFrameworkDefinition();
+
+// src/models/BuiltinsRegistry.ts
+init_errors2();
+function collectUniqueTags() {
+  const uniqueTags = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const tag2 of Object.values(globalTags)) {
+    if (seenIds.has(tag2.id)) {
+      continue;
+    }
+    seenIds.add(tag2.id);
+    uniqueTags.push(tag2);
+  }
+  return uniqueTags;
+}
+__name(collectUniqueTags, "collectUniqueTags");
+var SYSTEM_FRAMEWORK_ITEMS = Object.freeze([
+  globalResources.store,
+  globalResources.eventManager,
+  globalResources.taskRunner,
+  globalResources.middlewareManager,
+  globalResources.runtime,
+  ...collectUniqueTags().filter((tag2) => tag2.id.startsWith("system.")),
+  ...globalEventsArray
+]);
+var RUNNER_FRAMEWORK_ITEMS = Object.freeze([
+  globalResources.health,
+  globalResources.timers,
+  globalResources.logger,
+  globalResources.serializer,
+  globalResources.queue,
+  ...collectUniqueTags().filter((tag2) => tag2.id.startsWith("runner.")),
+  requireContextTaskMiddleware,
+  retryTaskMiddleware,
+  timeoutTaskMiddleware,
+  concurrencyTaskMiddleware,
+  debounceTaskMiddleware,
+  throttleTaskMiddleware,
+  fallbackTaskMiddleware,
+  rateLimitTaskMiddleware,
+  circuitBreakerMiddleware,
+  retryResourceMiddleware,
+  timeoutResourceMiddleware,
+  rateLimitResource,
+  circuitBreakerResource,
+  temporalResource,
+  concurrencyResource,
+  middlewareTimeoutError,
+  middlewareCircuitBreakerOpenError,
+  middlewareRateLimitExceededError,
+  durableExecutionError
+]);
+
+// src/models/createFrameworkRootGateway.ts
+var FRAMEWORK_RUNNER_RESOURCE_ID = "runner";
+var FRAMEWORK_SYSTEM_RESOURCE_ID = "system";
+var FRAMEWORK_ROOT_RESOURCE_ID = "runtime-framework-root";
+function createFrameworkNamespaceResource(resourceId, register) {
+  return defineResource(
+    markFrameworkDefinition({
+      id: resourceId,
+      register: [...register]
+    })
+  );
+}
+__name(createFrameworkNamespaceResource, "createFrameworkNamespaceResource");
+function createFrameworkRootResource({
+  rootItem,
+  debug: debug3
+}) {
+  const runnerRegister = debug3 ? [...RUNNER_FRAMEWORK_ITEMS, debugResource.with(debug3)] : [...RUNNER_FRAMEWORK_ITEMS];
+  const systemResource = createFrameworkNamespaceResource(
+    FRAMEWORK_SYSTEM_RESOURCE_ID,
+    SYSTEM_FRAMEWORK_ITEMS
+  );
+  const runnerResource = createFrameworkNamespaceResource(
+    FRAMEWORK_RUNNER_RESOURCE_ID,
+    runnerRegister
+  );
+  return defineResource(
+    markFrameworkDefinition({
+      id: FRAMEWORK_ROOT_RESOURCE_ID,
+      register: [systemResource, runnerResource, rootItem]
+    })
+  );
+}
+__name(createFrameworkRootResource, "createFrameworkRootResource");
+
+// src/models/store-registry/OwnerScope.ts
+function createOwnerScope(resourceId) {
+  return {
+    resourceId,
+    usesFrameworkRootIds: resourceId === FRAMEWORK_ROOT_RESOURCE_ID
+  };
+}
+__name(createOwnerScope, "createOwnerScope");
+
+// src/models/store-registry/StoreRegistryWriter.ts
 var StoreRegistryWriter = class {
   constructor(collections, validator, visibilityTracker, tagIndex, definitionPreparer, aliasResolver) {
     this.collections = collections;
@@ -17942,6 +18235,7 @@ var StoreRegistryWriter = class {
     this.tagIndex = tagIndex;
     this.definitionPreparer = definitionPreparer;
     this.aliasResolver = aliasResolver;
+    this.canonicalIdCompiler = new CanonicalIdCompiler();
   }
   static {
     __name(this, "StoreRegistryWriter");
@@ -18144,8 +18438,9 @@ var StoreRegistryWriter = class {
     const registerEntries = typeof element.register === "function" ? element.register(config) : element.register;
     const items = registerEntries ?? [];
     this.assignNormalizedRegisterEntries(element, items);
+    const ownerScope = createOwnerScope(element.id);
     const scopedItems = items.map(
-      (item) => this.compileOwnedItem(element.id, element.gateway === true, item)
+      (item) => this.compileOwnedItem(ownerScope, item)
     );
     for (const item of scopedItems) {
       this.visibilityTracker.recordOwnership(element.id, item);
@@ -18167,16 +18462,15 @@ var StoreRegistryWriter = class {
     }
     element.register = items;
   }
-  compileOwnedItem(ownerResourceId, ownerIsGateway, item) {
+  compileOwnedItem(ownerScope, item) {
     const kind = resolveRegisterableKind(item);
     if (!kind) {
       return item;
     }
     if (kind === "resourceWithConfig" /* ResourceWithConfig */) {
       const withConfig = item;
-      const compiledResource = this.compileOwnedDefinition(
-        ownerResourceId,
-        ownerIsGateway,
+      const compiledResource = this.compileOwnedDefinitionWithScope(
+        ownerScope,
         withConfig.resource,
         "resource" /* Resource */
       );
@@ -18200,9 +18494,8 @@ var StoreRegistryWriter = class {
       );
       return compiledWithConfig;
     }
-    const compiled = this.compileOwnedDefinition(
-      ownerResourceId,
-      ownerIsGateway,
+    const compiled = this.compileOwnedDefinitionWithScope(
+      ownerScope,
       item,
       kind
     );
@@ -18211,11 +18504,10 @@ var StoreRegistryWriter = class {
     this.aliasResolver.registerDefinitionAlias(compiled, resolvedId);
     return compiled;
   }
-  compileOwnedDefinition(ownerResourceId, ownerIsGateway, item, kind) {
+  compileOwnedDefinitionWithScope(ownerScope, item, kind) {
     const currentId = item.id;
-    const nextId = this.computeCanonicalId(
-      ownerResourceId,
-      ownerIsGateway,
+    const nextId = this.canonicalIdCompiler.compute(
+      ownerScope,
       kind,
       currentId
     );
@@ -18227,6 +18519,26 @@ var StoreRegistryWriter = class {
       nextId
     );
   }
+  computeCanonicalId(ownerResourceId, ownerUsesFrameworkRootIds, kind, currentId) {
+    return this.canonicalIdCompiler.compute(
+      {
+        resourceId: ownerResourceId,
+        usesFrameworkRootIds: ownerUsesFrameworkRootIds
+      },
+      kind,
+      currentId
+    );
+  }
+  compileOwnedDefinition(ownerResourceId, ownerUsesFrameworkRootIds, item, kind) {
+    return this.compileOwnedDefinitionWithScope(
+      {
+        resourceId: ownerResourceId,
+        usesFrameworkRootIds: ownerUsesFrameworkRootIds
+      },
+      item,
+      kind
+    );
+  }
   cloneDefinitionWithId(definition, id3) {
     const clone10 = Object.create(
       Object.getPrototypeOf(definition)
@@ -18256,79 +18568,11 @@ var StoreRegistryWriter = class {
       configurable: true
     });
   }
-  computeCanonicalId(ownerResourceId, ownerIsGateway, kind, currentId) {
-    this.assertLocalName(ownerResourceId, kind, currentId);
-    if (currentId.startsWith(`${ownerResourceId}.`)) {
-      return currentId;
-    }
-    if (ownerIsGateway) {
-      switch (kind) {
-        case "resource" /* Resource */:
-          return currentId;
-        case "task" /* Task */:
-          return `tasks.${currentId}`;
-        case "event" /* Event */:
-          return `events.${currentId}`;
-        case "hook" /* Hook */:
-          return `hooks.${currentId}`;
-        case "taskMiddleware" /* TaskMiddleware */:
-          return `middleware.task.${currentId}`;
-        case "resourceMiddleware" /* ResourceMiddleware */:
-          return `middleware.resource.${currentId}`;
-        case "tag" /* Tag */:
-          return `tags.${currentId}`;
-        case "error" /* Error */:
-          return `errors.${currentId}`;
-        case "asyncContext" /* AsyncContext */:
-          return `asyncContexts.${currentId}`;
-        default:
-          return currentId;
-      }
-    }
-    switch (kind) {
-      case "resource" /* Resource */:
-        return `${ownerResourceId}.${currentId}`;
-      case "task" /* Task */:
-        return `${ownerResourceId}.tasks.${currentId}`;
-      case "event" /* Event */:
-        return `${ownerResourceId}.events.${currentId}`;
-      case "hook" /* Hook */:
-        return `${ownerResourceId}.hooks.${currentId}`;
-      case "taskMiddleware" /* TaskMiddleware */:
-        return `${ownerResourceId}.middleware.task.${currentId}`;
-      case "resourceMiddleware" /* ResourceMiddleware */:
-        return `${ownerResourceId}.middleware.resource.${currentId}`;
-      case "tag" /* Tag */:
-        return `${ownerResourceId}.tags.${currentId}`;
-      case "error" /* Error */:
-        return `${ownerResourceId}.errors.${currentId}`;
-      case "asyncContext" /* AsyncContext */:
-        return `${ownerResourceId}.asyncContexts.${currentId}`;
-      default:
-        return `${ownerResourceId}.${currentId}`;
-    }
-  }
-  assertLocalName(ownerResourceId, kind, currentId) {
-    if (currentId.trim().length === 0) {
-      validationError.throw({
-        subject: "Definition local name",
-        id: `${ownerResourceId}.${kind}`,
-        originalError: "Definition local names must be non-empty strings when using scoped registration."
-      });
-    }
-    if (isReservedDefinitionLocalName(currentId)) {
-      validationError.throw({
-        subject: "Definition local name",
-        id: `${ownerResourceId}.${kind}.${currentId}`,
-        originalError: `Local name "${currentId}" is reserved by Runner and cannot be used.`
-      });
-    }
-  }
   resolveRegisterableId(item) {
     if (item === null || item === void 0) {
       return void 0;
     }
-    if (hasSymbolBrand(item, symbolResourceWithConfig)) {
+    if (resolveRegisterableKind(item) === "resourceWithConfig" /* ResourceWithConfig */) {
       return item.resource.id;
     }
     if (typeof item === "object" && "id" in item) {
@@ -18407,15 +18651,16 @@ var StoreRegistryWriter = class {
     this.visibilityTracker.recordDefinitionTags(task2.id, tags2);
   }
   normalizeTaskMiddlewareAttachments(task2) {
+    const ownerResourceId = this.resolveOwnerResourceIdFromTaskId(task2.id);
     return this.normalizeMiddlewareAttachments(
-      this.resolveOwnerResourceIdFromTaskId(task2.id),
+      ownerResourceId ? createOwnerScope(ownerResourceId) : null,
       "taskMiddleware" /* TaskMiddleware */,
       task2.middleware
     );
   }
   normalizeResourceMiddlewareAttachments(resource2) {
     return this.normalizeMiddlewareAttachments(
-      resource2.id,
+      createOwnerScope(resource2.id),
       "resourceMiddleware" /* ResourceMiddleware */,
       resource2.middleware
     );
@@ -18433,7 +18678,10 @@ var StoreRegistryWriter = class {
     let normalizedResourcePolicy = subtree.resources;
     if (subtree.tasks?.middleware?.length) {
       const middleware2 = subtree.tasks.middleware.map(
-        (entry) => this.normalizeSubtreeTaskMiddlewareEntry(resource2.id, entry)
+        (entry) => this.normalizeSubtreeTaskMiddlewareEntry(
+          createOwnerScope(resource2.id),
+          entry
+        )
       );
       if (this.didArrayChange(subtree.tasks.middleware, middleware2)) {
         normalizedTaskPolicy = {
@@ -18445,7 +18693,10 @@ var StoreRegistryWriter = class {
     }
     if (subtree.resources?.middleware?.length) {
       const middleware2 = subtree.resources.middleware.map(
-        (entry) => this.normalizeSubtreeResourceMiddlewareEntry(resource2.id, entry)
+        (entry) => this.normalizeSubtreeResourceMiddlewareEntry(
+          createOwnerScope(resource2.id),
+          entry
+        )
       );
       if (this.didArrayChange(subtree.resources.middleware, middleware2)) {
         normalizedResourcePolicy = {
@@ -18464,37 +18715,47 @@ var StoreRegistryWriter = class {
       ...normalizedResourcePolicy ? { resources: normalizedResourcePolicy } : {}
     };
   }
-  normalizeSubtreeTaskMiddlewareEntry(ownerResourceId, entry) {
+  normalizeSubtreeTaskMiddlewareEntry(ownerScopeOrResourceId, entryOrUsesFrameworkRootIds, maybeEntry) {
+    const ownerScope = this.normalizeOwnerScopeArg(
+      ownerScopeOrResourceId,
+      entryOrUsesFrameworkRootIds
+    );
+    const entry = maybeEntry ?? entryOrUsesFrameworkRootIds;
     return this.normalizeSubtreeMiddlewareEntry(
-      ownerResourceId,
+      ownerScope,
       "taskMiddleware" /* TaskMiddleware */,
       entry,
       getSubtreeTaskMiddlewareAttachment
     );
   }
-  normalizeSubtreeResourceMiddlewareEntry(ownerResourceId, entry) {
+  normalizeSubtreeResourceMiddlewareEntry(ownerScopeOrResourceId, entryOrUsesFrameworkRootIds, maybeEntry) {
+    const ownerScope = this.normalizeOwnerScopeArg(
+      ownerScopeOrResourceId,
+      entryOrUsesFrameworkRootIds
+    );
+    const entry = maybeEntry ?? entryOrUsesFrameworkRootIds;
     return this.normalizeSubtreeMiddlewareEntry(
-      ownerResourceId,
+      ownerScope,
       "resourceMiddleware" /* ResourceMiddleware */,
       entry,
       getSubtreeResourceMiddlewareAttachment
     );
   }
-  normalizeMiddlewareAttachments(ownerResourceId, kind, attachments) {
+  normalizeMiddlewareAttachments(ownerScope, kind, attachments) {
     if (!Array.isArray(attachments) || attachments.length === 0) {
       return attachments;
     }
-    if (!ownerResourceId) {
+    if (!ownerScope) {
       return attachments;
     }
     return attachments.map(
-      (attachment) => this.normalizeMiddlewareAttachment(ownerResourceId, kind, attachment)
+      (attachment) => this.normalizeMiddlewareAttachment(ownerScope, kind, attachment)
     );
   }
-  normalizeSubtreeMiddlewareEntry(ownerResourceId, kind, entry, getAttachment) {
+  normalizeSubtreeMiddlewareEntry(ownerScope, kind, entry, getAttachment) {
     const attachment = getAttachment(entry);
     const normalizedAttachment = this.normalizeMiddlewareAttachment(
-      ownerResourceId,
+      ownerScope,
       kind,
       attachment
     );
@@ -18509,17 +18770,11 @@ var StoreRegistryWriter = class {
     }
     return normalizedAttachment;
   }
-  normalizeMiddlewareAttachment(ownerResourceId, kind, attachment) {
-    const ownerIsGateway = this.collections.resources.get(ownerResourceId)?.resource.gateway === true;
+  normalizeMiddlewareAttachment(ownerScope, kind, attachment) {
     const isRegisteredMiddlewareId = /* @__PURE__ */ __name((candidateId) => kind === "taskMiddleware" /* TaskMiddleware */ ? this.collections.taskMiddlewares.has(candidateId) : this.collections.resourceMiddlewares.has(candidateId), "isRegisteredMiddlewareId");
     const resolvedByAliasCandidate = this.aliasResolver.resolveDefinitionId(attachment);
     const resolvedByAlias = typeof resolvedByAliasCandidate === "string" && isRegisteredMiddlewareId(resolvedByAliasCandidate) ? resolvedByAliasCandidate : void 0;
-    const resolvedId = resolvedByAlias ?? this.computeCanonicalId(
-      ownerResourceId,
-      ownerIsGateway,
-      kind,
-      attachment.id
-    );
+    const resolvedId = resolvedByAlias ?? this.canonicalIdCompiler.compute(ownerScope, kind, attachment.id);
     if (resolvedId === attachment.id) {
       return attachment;
     }
@@ -18550,6 +18805,15 @@ var StoreRegistryWriter = class {
     }
     return false;
   }
+  normalizeOwnerScopeArg(ownerScopeOrResourceId, entryOrUsesFrameworkRootIds) {
+    if (typeof ownerScopeOrResourceId !== "string") {
+      return ownerScopeOrResourceId;
+    }
+    return {
+      resourceId: ownerScopeOrResourceId,
+      usesFrameworkRootIds: typeof entryOrUsesFrameworkRootIds === "boolean" ? entryOrUsesFrameworkRootIds : false
+    };
+  }
   normalizeDefinitionTags(tags2) {
     return normalizeTags(tags2).map((tag2) => {
       const resolvedId = this.aliasResolver.resolveDefinitionId(tag2);
@@ -18605,6 +18869,7 @@ var StoreRegistry = class {
     this.definitionIdentityAliases = /* @__PURE__ */ new WeakMap();
     this.definitionAliasesBySourceId = /* @__PURE__ */ new Map();
     this.sourceIdsByCanonicalId = /* @__PURE__ */ new Map();
+    this.displayIdsByCanonicalId = /* @__PURE__ */ new Map();
     const lookupResolver = /* @__PURE__ */ __name((key) => this.resolveDefinitionId(key), "lookupResolver");
     this.tasks.setLookupResolver(lookupResolver);
     this.resources.setLookupResolver(lookupResolver);
@@ -18675,6 +18940,7 @@ var StoreRegistry = class {
     this.recordDefinitionIdentityAlias(reference, canonicalId);
     this.recordSourceIdAlias(reference, canonicalId);
     this.recordCanonicalSourceId(reference, canonicalId);
+    this.computeAndStoreDisplayId(canonicalId);
   }
   resolveDefinitionId(reference) {
     if (typeof reference === "string") {
@@ -18761,16 +19027,35 @@ var StoreRegistry = class {
     return candidates.values().next().value;
   }
   getDisplayId(id3) {
-    const sourceIds = this.sourceIdsByCanonicalId.get(id3);
+    return this.displayIdsByCanonicalId.get(id3) ?? id3;
+  }
+  stripFrameworkRootPrefix(id3) {
+    const prefix = `${FRAMEWORK_ROOT_RESOURCE_ID}.`;
+    return id3.startsWith(prefix) ? id3.slice(prefix.length) : id3;
+  }
+  computeAndStoreDisplayId(canonicalId) {
+    if (canonicalId === FRAMEWORK_ROOT_RESOURCE_ID || canonicalId.startsWith(`${FRAMEWORK_ROOT_RESOURCE_ID}.`)) {
+      this.displayIdsByCanonicalId.set(
+        canonicalId,
+        this.stripFrameworkRootPrefix(canonicalId)
+      );
+      return;
+    }
+    const sourceIds = this.sourceIdsByCanonicalId.get(canonicalId);
     if (!sourceIds || sourceIds.size === 0) {
-      return id3;
+      this.displayIdsByCanonicalId.set(canonicalId, canonicalId);
+      return;
     }
     for (const sourceId of sourceIds) {
-      if (sourceId !== id3) {
-        return sourceId;
+      if (sourceId !== canonicalId) {
+        this.displayIdsByCanonicalId.set(canonicalId, sourceId);
+        return;
       }
     }
-    return sourceIds.values().next().value;
+    this.displayIdsByCanonicalId.set(
+      canonicalId,
+      sourceIds.values().next().value
+    );
   }
   /** Lock every map in the registry, preventing further mutations. */
   lockAll() {
@@ -19980,90 +20265,6 @@ function getTopologicalInitOrder(resources2, initializedResources) {
 }
 __name(getTopologicalInitOrder, "getTopologicalInitOrder");
 
-// src/models/BuiltinsRegistry.ts
-init_errors2();
-function collectUniqueTags() {
-  const uniqueTags = [];
-  const seenIds = /* @__PURE__ */ new Set();
-  for (const tag2 of Object.values(globalTags)) {
-    if (seenIds.has(tag2.id)) {
-      continue;
-    }
-    seenIds.add(tag2.id);
-    uniqueTags.push(tag2);
-  }
-  return uniqueTags;
-}
-__name(collectUniqueTags, "collectUniqueTags");
-var SYSTEM_FRAMEWORK_ITEMS = Object.freeze([
-  globalResources.store,
-  globalResources.eventManager,
-  globalResources.taskRunner,
-  globalResources.middlewareManager,
-  globalResources.runtime,
-  ...collectUniqueTags().filter((tag2) => tag2.id.startsWith("system.")),
-  ...globalEventsArray
-]);
-var RUNNER_FRAMEWORK_ITEMS = Object.freeze([
-  globalResources.health,
-  globalResources.timers,
-  globalResources.logger,
-  globalResources.serializer,
-  globalResources.queue,
-  ...collectUniqueTags().filter((tag2) => tag2.id.startsWith("runner.")),
-  requireContextTaskMiddleware,
-  retryTaskMiddleware,
-  timeoutTaskMiddleware,
-  concurrencyTaskMiddleware,
-  debounceTaskMiddleware,
-  throttleTaskMiddleware,
-  fallbackTaskMiddleware,
-  rateLimitTaskMiddleware,
-  circuitBreakerMiddleware,
-  retryResourceMiddleware,
-  timeoutResourceMiddleware,
-  rateLimitResource,
-  circuitBreakerResource,
-  temporalResource,
-  concurrencyResource,
-  middlewareTimeoutError,
-  middlewareCircuitBreakerOpenError,
-  middlewareRateLimitExceededError,
-  durableExecutionError
-]);
-
-// src/models/createFrameworkRootGateway.ts
-var FRAMEWORK_RUNNER_RESOURCE_ID = "runner";
-var FRAMEWORK_SYSTEM_RESOURCE_ID = "system";
-var FRAMEWORK_ROOT_GATEWAY_ID = "runtime-framework-root";
-function createFrameworkNamespaceResource(resourceId, register) {
-  return defineResource({
-    id: resourceId,
-    register: [...register]
-  });
-}
-__name(createFrameworkNamespaceResource, "createFrameworkNamespaceResource");
-function createFrameworkRootGateway({
-  rootItem,
-  debug: debug3
-}) {
-  const runnerRegister = debug3 ? [...RUNNER_FRAMEWORK_ITEMS, debugResource.with(debug3)] : [...RUNNER_FRAMEWORK_ITEMS];
-  const systemResource = createFrameworkNamespaceResource(
-    FRAMEWORK_SYSTEM_RESOURCE_ID,
-    SYSTEM_FRAMEWORK_ITEMS
-  );
-  const runnerResource = createFrameworkNamespaceResource(
-    FRAMEWORK_RUNNER_RESOURCE_ID,
-    runnerRegister
-  );
-  return defineResource({
-    id: FRAMEWORK_ROOT_GATEWAY_ID,
-    gateway: true,
-    register: [systemResource, runnerResource, rootItem]
-  });
-}
-__name(createFrameworkRootGateway, "createFrameworkRootGateway");
-
 // src/models/Store.ts
 init_symbols();
 var Store = class {
@@ -20325,7 +20526,7 @@ var Store = class {
     if (this.#isInitialized) {
       storeAlreadyInitializedError.throw();
     }
-    const frameworkRoot = createFrameworkRootGateway({
+    const frameworkRoot = createFrameworkRootResource({
       rootItem: root.with(config),
       debug: options?.debug
     });
@@ -20697,7 +20898,6 @@ function resolveExecutionContextConfig(executionContext) {
 __name(resolveExecutionContextConfig, "resolveExecutionContextConfig");
 
 // src/run.ts
-init_errors2();
 var activeRunResults = /* @__PURE__ */ new Set();
 function normalizeRunOptions(options) {
   const debug3 = options?.debug;
@@ -20744,9 +20944,6 @@ async function run(resourceOrResourceWithConfig, options) {
   const { resource: resource2, config } = extractResourceAndConfig(
     resourceOrResourceWithConfig
   );
-  if (resource2.gateway === true) {
-    runRootGatewayUnsupportedError.throw({ id: resource2.id });
-  }
   const services = createRuntimeServices({
     mode: normalizedOptions.mode,
     lifecycleMode: normalizedOptions.lifecycleMode,
@@ -21056,7 +21253,6 @@ function makeResourceBuilder(state) {
     build() {
       const definition = {
         id: state.id,
-        gateway: state.gateway,
         dependencies: state.dependencies,
         register: state.register,
         middleware: state.middleware,
@@ -21095,7 +21291,6 @@ __name(makeResourceBuilder, "makeResourceBuilder");
 function createResourceBuilder(id3, options) {
   const initial = Object.freeze({
     id: id3,
-    gateway: options?.gateway === true,
     filePath: options.filePath,
     dependencies: void 0,
     register: void 0,
@@ -22617,10 +22812,18 @@ init_errors2();
 init_platform();
 init_defineError();
 init_check();
-var resources = Object.freeze({ ...globalResources });
-var events = Object.freeze({ ...globalEvents });
-var middleware = Object.freeze({ ...globalMiddlewares });
-var tags = Object.freeze({ ...globalTags });
+var resources = Object.freeze({
+  ...globalResources
+});
+var events = Object.freeze({
+  ...globalEvents
+});
+var middleware = Object.freeze({
+  ...globalMiddlewares
+});
+var tags = Object.freeze({
+  ...globalTags
+});
 var debug2 = Object.freeze({ levels: debug.levels });
 var r = Object.freeze({
   resource,