alepha 0.20.2 → 0.20.4

package/src/core/Alepha.ts

@@ -827,7 +827,7 @@ export class Alepha {
   }
 
   /**
-   * Alias for {@link Alepha#with}.
+   * @alias {@link Alepha#with}.
    */
   public register<T extends object>(
     serviceEntry: ServiceEntry<T> | { default: ServiceEntry<T> },
@@ -849,6 +849,16 @@ export class Alepha {
       opts.parent !== undefined ? opts.parent : (__alephaRef?.parent ?? Alepha);
 
     const transient = lifetime === "transient";
+    // TODO: warn-once when scoped lifetime silently falls back to the global
+    //   singleton registry. This happens when AsyncLocalStorage is not available
+    //   (typically in the browser, where AlsProvider is a no-op) — the user
+    //   asked for per-request isolation and got a cross-request singleton.
+    //   Today this is silent. Plan: detect (this.context.get("registry") === undefined)
+    //   on a "scoped" inject, log a one-shot warning via the Logger module
+    //   ("[alepha] scoped DI requested for <Service> but no AsyncLocalStorage
+    //   context — falling back to singleton. This is expected in browser
+    //   builds; in server runtimes ensure the request is wrapped in
+    //   alepha.context.run()."). Gate behind a Set<Service> so we don't spam.
     const registry =
       lifetime === "scoped"
         ? (this.context.get<Map<Service, ServiceDefinition>>("registry") ??

package/src/core/helpers/ref.ts

@@ -54,4 +54,22 @@ export const __alephaRef: {
  *
  * One main goal of Alepha is working with classes but without the class verbosity.
  * Forcing to pass Alepha instance in constructors would be a step back in that direction!
+ *
+ * ---------------------------------------------------------------------------------------------------------------------
+ *
+ * TODO: harden the cursor against mid-instantiation throws.
+ *
+ * Today, the cleanup of `__alephaRef.alepha`, `__alephaRef.service`, `__alephaRef.parent`
+ * is performed by the caller after the synchronous instantiation returns. If the
+ * instantiation throws (e.g., a primitive factory blows up, or a user constructor
+ * raises), the cursor can be left holding stale references until the next
+ * instantiation overwrites them. In practice this is harmless because Alepha is
+ * single-threaded synchronous during boot and the next inject() rewrites the
+ * cursor — but it is a sharp edge for debuggers (frame inspection shows ghost
+ * state) and any future tooling that introspects __alephaRef out-of-band.
+ *
+ * Plan: wrap each cursor mutation in Alepha.ts in a try/finally that snapshots
+ * the previous value and restores it on exit (even on throw). Equivalent to a
+ * lexically-scoped "with" — pushes/pops cleanly. Should be a 5-line refactor in
+ * Alepha.ts:1131-1132 once we touch it.
  */

package/src/core/index.shared.ts

@@ -36,6 +36,7 @@ export * from "./providers/Json.ts";
 export * from "./providers/JsonSchemaCodec.ts";
 export * from "./providers/KeylessJsonSchemaCodec.ts";
 export * from "./providers/SchemaCodec.ts";
+export * from "./providers/SchemaValidator.ts";
 export * from "./providers/StateManager.ts";
 export * from "./providers/TypeProvider.ts";
 export * from "./schemas/pageQuerySchema.ts";

package/src/core/interfaces/Service.ts

@@ -8,7 +8,9 @@ export type Service<T extends object = any> =
   | AbstractClass<T>
   | RunFunction<T>;
 
-export type RunFunction<T extends object = any> = (...args: any[]) => T | void;
+export type RunFunction<T extends object = any> = (
+  ...args: any[]
+) => T | undefined;
 
 export type InstantiableClass<T extends object = any> = new (
   ...args: any[]

package/src/core/providers/SchemaValidator.ts

@@ -1,8 +1,9 @@
 import type { TSchema } from "typebox";
 import { Compile, type Validator } from "typebox/compile";
+import * as Value from "typebox/value";
 import { TypeBoxError } from "../errors/TypeBoxError.ts";
 import { $hook } from "../primitives/$hook.ts";
-import { type Static, t, Value } from "./TypeProvider.ts";
+import { type Static, t } from "./TypeProvider.ts";
 
 export class SchemaValidator {
   protected cache = new Map<TSchema, Validator>();
@@ -38,6 +39,13 @@ export class SchemaValidator {
     }
   }
 
+  /**
+   * Deep clone a schema. Useful when a schema is going to be mutated.
+   */
+  public clone<T extends TSchema>(schema: T): T {
+    return Value.Clone(schema);
+  }
+
   protected getValidator<T extends TSchema>(schema: T): Validator<{}, T> {
     if (this.cache.has(schema)) {
       return this.cache.get(schema) as Validator<{}, T>;

package/src/core/providers/TypeProvider.ts

@@ -27,12 +27,11 @@ import type {
 import { Type } from "typebox";
 import Format from "typebox/format";
 import { Settings } from "typebox/system";
-import * as Value from "typebox/value";
 import { OPTIONS } from "../constants/OPTIONS.ts";
 import type { TypeBoxError } from "../errors/TypeBoxError.ts";
 import { isTypeFile, type TFile, type TStream } from "../helpers/FileLike.ts";
 
-export { Format, Type, Value };
+export { Format, Type };
 
 // https://github.com/sinclairzx81/typebox/blob/main/changelog/1.1.0.md
 Settings.Set({ correctiveParse: true });
@@ -447,7 +446,7 @@ export class TypeProvider {
   /**
    * Create a schema that maps all properties of an object schema to nullable.
    */
-  public nullify = <T extends TSchema>(schema: T, options?: TObjectOptions) =>
+  public nullify = (schema: TSchema, options?: TObjectOptions): TSchema =>
     Type.Mapped(
       Type.Identifier("K"),
       Type.KeyOf(schema),

package/src/datetime/REFACTORING.md

@@ -0,0 +1,118 @@
+# DateTime — Refactoring Roadmap
+
+## Context
+
+Step 1 (done) isolated dayjs behind two wrapper classes — `DateTime` and `Duration` — exposed by `DateTimeProvider`. Nothing in the codebase imports dayjs directly anymore; only this module does.
+
+Step 2 (this document) is the engine swap: replace the dayjs internals of those wrappers with `Temporal` + `Intl`, then remove dayjs entirely. **Public API stays identical**, so call-sites across the framework do not change.
+
+This refactoring is **deferred** until `Temporal` is natively available across our supported runtimes (Node, Bun, modern browsers). Today (2026-05) only Firefox ships it stably; V8/JSC are still flagged. Pulling the trigger before then would force every consumer to ship a ~28 KB polyfill — a regression vs the current dayjs footprint.
+
+When the time comes, the migration is contained to **two files** (`DateTimeProvider.ts` and `react/i18n/providers/I18nProvider.ts`) plus `package.json`.
+
+## Polyfill policy
+
+`alepha` will **not** bundle or depend on a Temporal polyfill. Apps that need to support runtimes without native Temporal install one themselves and load it once at startup:
+
+```ts
+// app entry point
+import "temporal-polyfill/global";
+```
+
+Rationale:
+- Polyfill choice is an app concern (bundle size, runtime targets).
+- The polyfill is global-only by nature; importing it from a library would force it on every consumer regardless of need.
+- Once native support is universal, the polyfill becomes a no-op and apps drop the import. `alepha` itself never had to change.
+
+The framework's documentation should mention the polyfill recommendation in the upgrade notes for the release that performs the swap.
+
+## Wrappers — what changes inside
+
+### `DateTime`
+
+Currently wraps `Dayjs`. After the swap it wraps a `Temporal.Instant` (and an optional timezone string for the `tz()` chain). Per-method translation:
+
+| Method | Temporal mapping |
+|---|---|
+| `add(n, unit)` / `add(Duration)` | `instant.add(Temporal.Duration.from({ [unit]: n }))` |
+| `subtract(n, unit)` / `subtract(Duration)` | `instant.subtract(...)` |
+| `startOf(unit)` / `endOf(unit)` | Convert to `ZonedDateTime`, zero out lower fields, convert back. ~10 lines per unit. No native equivalent. |
+| `isAfter` / `isBefore` / `isSame` | `Temporal.Instant.compare(a, b)` |
+| `diff(other, unit?)` | `instant.since(other).total({ unit })` (default unit: `"milliseconds"`) |
+| `tz(zone)` | Store `zone` on the wrapper; convert via `instant.toZonedDateTimeISO(zone)` when needed for formatting/`startOf`. |
+| `locale(lang)` | Store `lang` on the wrapper (consumed only by `format`/`fromNow`). Or drop the chained form and pass `lang` directly. |
+| `format(template?)` | See **Format tokens** below. |
+| `fromNow(withoutSuffix?)` | `Intl.RelativeTimeFormat` — pick the largest non-zero unit from `since(now)`. ~25 lines. Needs `lang` (currently inherited from `.locale()` chain). |
+| `toISOString()` | `instant.toString()` |
+| `toDate()` | `new Date(instant.epochMilliseconds)` |
+| `valueOf()` | `instant.epochMilliseconds` |
+| `unix()` | `Math.floor(instant.epochMilliseconds / 1000)` |
+| `toJSON` / `toString` | same as `toISOString()` |
+| `toDayjs()` | **Removed.** Verify with grep first — currently used only inside `DateTimeProvider`. |
+
+### `Duration`
+
+Currently wraps `dayjsDuration.Duration`. After the swap it wraps `Temporal.Duration`. Per-method translation:
+
+| Method | Temporal mapping |
+|---|---|
+| `asMilliseconds()` etc. | `duration.total({ unit: "milliseconds" })` etc. |
+| `as(unit)` | `duration.total({ unit })` |
+| `toISOString()` | `duration.toString()` (Temporal already emits ISO 8601) |
+| `toDayjs()` | **Removed.** |
+
+Constructor input normalization (number, `[n, unit]` tuple, ISO string `"PT5M"`, existing `Duration`) stays in `DateTimeProvider.duration()`. Temporal parses ISO strings natively via `Temporal.Duration.from()`; the tuple form needs a 3-line shim.
+
+## Format tokens — the one open decision
+
+`DateTime.format(template)` currently delegates to dayjs and supports two flavours:
+
+1. **Localized presets** — `"L"`, `"LL"`, `"LLL"`, `"lll"`, etc. (from `dayjs/plugin/localizedFormat`).
+2. **Token strings** — `"YYYY-MM-DD HH:mm:ss"`.
+
+`Intl.DateTimeFormat` uses option objects, not tokens. Two paths:
+
+**(a) Drop tokens — preferred.** Force callers to use `Intl.DateTimeFormat` options. `I18nProvider.l` already supports this path (`options.date` accepts an `Intl.DateTimeFormatOptions` object). The token-string path becomes the fallback to remove. Audit before removal — current callers of `format(token)`:
+
+- `react/i18n/providers/I18nProvider.ts` — `dt.locale(lang).format(options.date)` when `options.date` is a string
+- `scheduler/providers/WorkerdCronProvider.ts` — `now.format()` (no template — equivalent to ISO string)
+
+If those are the only callers, deletion is a 5-line change.
+
+**(b) Token mapper.** Keep tokens, write a small dayjs-token → `Intl.DateTimeFormat` translator (~80 lines for `YYYY/MM/DD/HH/mm/ss/L/LL/LLL/lll`). Higher maintenance cost, no real ergonomic win. Recommend against unless external consumers depend on the token form.
+
+## I18n provider changes
+
+`react/i18n/providers/I18nProvider.ts` is the only file outside `datetime/` that exercises the soon-to-change parts of the API:
+
+- `dt.tz(timezone)` — unchanged signature, unchanged caller code.
+- `dt.locale(lang).fromNow()` — becomes `dt.fromNow(lang)` (or `relativeFormat(dt, lang)` helper). Caller updated.
+- `dt.locale(lang).format(token)` — covered by the format-token decision above.
+- The `Intl.DateTimeFormat`/`Intl.NumberFormat` paths in this file already work and are unaffected.
+
+## Test surface
+
+- `datetime/__tests__/DateTimeProvider.spec.ts` — exercises `pause`/`travel`/`createTimeout`/`wait`/`deadline`/`duration`/`isDurationLike`. All operate on epoch-ms internals; should pass unchanged.
+- All ~3400 other tests across the framework hit the wrappers via the public API. They are the safety net.
+
+## Removal checklist
+
+When Step 2 ships:
+
+1. `package.json` — remove `dayjs`. No new dep added (polyfill is app-side).
+2. `DateTimeProvider.ts` — remove all `dayjs/*` imports, the `PLUGINS` static, the `for (plugin of PLUGINS) DayjsApi.extend(plugin)` constructor block, and the `unwrap`/`toDayjs` helpers.
+3. `DateTime.toDayjs()` and `Duration.toDayjs()` — delete.
+4. Re-exported dayjs unit types (`ManipulateType`, `OpUnitType`, `QUnitType`, `DurationUnitType`) — replace with locally-defined union types covering the units we actually use. Keep the names if they're referenced externally; just stop sourcing them from dayjs.
+5. `react/i18n/providers/I18nProvider.ts` — adjust per the I18n section above.
+6. Verify: `grep -r dayjs packages apps` returns nothing.
+7. Run `yarn lint && yarn typecheck && yarn test`.
+
+## Why not now
+
+- Polyfill weight: temporal-polyfill ~28 KB gz vs current dayjs+plugins+locales ~15–20 KB gz. Net regression until native lands.
+- No functional gain for users today — same behaviour, same wire format (ISO 8601 strings via `t.datetime()`), same testing affordances (`pause`/`travel`).
+- The cost of waiting is zero: Step 1 already gave us the abstraction. The engine swap is mechanical when the time is right.
+
+## Estimated effort when triggered
+
+~1 focused day. The wrapper rewrite is mechanical, the I18n adjustment is small, and the test suite catches regressions immediately.

package/src/datetime/providers/DateTimeProvider.ts

@@ -9,24 +9,189 @@ import { $hook, $inject, Alepha } from "alepha";
 import DayjsApi, {
   type Dayjs,
   type ManipulateType,
+  type OpUnitType,
   type PluginFunc,
+  type QUnitType,
 } from "dayjs";
-import dayjsDuration from "dayjs/plugin/duration.js";
+import dayjsDuration, { type DurationUnitType } from "dayjs/plugin/duration.js";
 import dayjsLocalizedFormat from "dayjs/plugin/localizedFormat.js";
 import dayjsRelativeTime from "dayjs/plugin/relativeTime.js";
 import dayjsTimezone from "dayjs/plugin/timezone.js";
 import dayjsUtc from "dayjs/plugin/utc.js";
 
-export type DateTime = DayjsApi.Dayjs;
-export type Duration = dayjsDuration.Duration;
-export type DurationLike =
-  | number
-  | dayjsDuration.Duration
-  | [number, ManipulateType];
+export type { DurationUnitType, ManipulateType, OpUnitType, QUnitType };
+
+export type DateTimeInput = string | number | Date | DateTime | Dayjs;
+
+export type DurationLike = number | Duration | [number, ManipulateType];
+
+/**
+ * Immutable wrapper around the underlying date-time engine.
+ *
+ * Designed to isolate consumers from the engine in use (currently dayjs).
+ * Methods that produce a new value return a new `DateTime` instance.
+ */
+export class DateTime {
+  protected readonly inner: Dayjs;
+
+  constructor(inner: Dayjs) {
+    this.inner = inner;
+  }
+
+  /**
+   * Add a duration to this date-time.
+   */
+  add(amount: number, unit?: ManipulateType): DateTime;
+  add(duration: Duration): DateTime;
+  add(amount: number | Duration, unit?: ManipulateType): DateTime {
+    if (amount instanceof Duration) {
+      return new DateTime(this.inner.add(amount.toDayjs()));
+    }
+    return new DateTime(this.inner.add(amount, unit));
+  }
+
+  /**
+   * Subtract a duration from this date-time.
+   */
+  subtract(amount: number, unit?: ManipulateType): DateTime;
+  subtract(duration: Duration): DateTime;
+  subtract(amount: number | Duration, unit?: ManipulateType): DateTime {
+    if (amount instanceof Duration) {
+      return new DateTime(this.inner.subtract(amount.toDayjs()));
+    }
+    return new DateTime(this.inner.subtract(amount, unit));
+  }
+
+  startOf(unit: OpUnitType): DateTime {
+    return new DateTime(this.inner.startOf(unit));
+  }
+
+  endOf(unit: OpUnitType): DateTime {
+    return new DateTime(this.inner.endOf(unit));
+  }
+
+  isAfter(other: DateTimeInput): boolean {
+    return this.inner.isAfter(toDayjs(other));
+  }
+
+  isBefore(other: DateTimeInput): boolean {
+    return this.inner.isBefore(toDayjs(other));
+  }
+
+  isSame(other: DateTimeInput, unit?: OpUnitType): boolean {
+    return this.inner.isSame(toDayjs(other), unit);
+  }
+
+  diff(other: DateTimeInput, unit?: QUnitType | OpUnitType): number {
+    return this.inner.diff(toDayjs(other), unit);
+  }
+
+  tz(timezone: string): DateTime {
+    return new DateTime(this.inner.tz(timezone));
+  }
+
+  locale(lang: string): DateTime {
+    return new DateTime(this.inner.locale(lang));
+  }
+
+  format(template?: string): string {
+    return this.inner.format(template);
+  }
+
+  fromNow(withoutSuffix?: boolean): string {
+    return this.inner.fromNow(withoutSuffix);
+  }
+
+  toISOString(): string {
+    return this.inner.toISOString();
+  }
+
+  toDate(): Date {
+    return this.inner.toDate();
+  }
+
+  valueOf(): number {
+    return this.inner.valueOf();
+  }
+
+  unix(): number {
+    return this.inner.unix();
+  }
+
+  toJSON(): string {
+    return this.inner.toISOString();
+  }
+
+  toString(): string {
+    return this.inner.toISOString();
+  }
+
+  /**
+   * Escape hatch for the underlying dayjs instance.
+   *
+   * Use sparingly — anything calling this becomes coupled to dayjs and
+   * will need to migrate when the engine is replaced.
+   */
+  toDayjs(): Dayjs {
+    return this.inner;
+  }
+}
+
+/**
+ * Immutable wrapper around the underlying duration engine.
+ */
+export class Duration {
+  protected readonly inner: dayjsDuration.Duration;
+
+  constructor(inner: dayjsDuration.Duration) {
+    this.inner = inner;
+  }
+
+  asMilliseconds(): number {
+    return this.inner.asMilliseconds();
+  }
+
+  asSeconds(): number {
+    return this.inner.asSeconds();
+  }
+
+  asMinutes(): number {
+    return this.inner.asMinutes();
+  }
+
+  asHours(): number {
+    return this.inner.asHours();
+  }
+
+  asDays(): number {
+    return this.inner.asDays();
+  }
+
+  as(unit: DurationUnitType): number {
+    return this.inner.as(unit);
+  }
+
+  toISOString(): string {
+    return this.inner.toISOString();
+  }
+
+  /**
+   * Escape hatch for the underlying dayjs duration.
+   */
+  toDayjs(): dayjsDuration.Duration {
+    return this.inner;
+  }
+}
 
-export const dayjs = DayjsApi;
 export const isDateTime = (value: unknown): value is DateTime => {
-  return dayjs.isDayjs(value);
+  return value instanceof DateTime;
+};
+
+const toDayjs = (value: DateTimeInput): Dayjs => {
+  if (value instanceof DateTime) {
+    return value.toDayjs();
+  }
+  return DayjsApi(value as any);
 };
 
 export class DateTimeProvider {
@@ -45,7 +210,7 @@ export class DateTimeProvider {
 
   constructor() {
     for (const plugin of DateTimeProvider.PLUGINS) {
-      dayjs.extend(plugin);
+      DayjsApi.extend(plugin);
     }
   }
 
@@ -81,33 +246,34 @@ export class DateTimeProvider {
   });
 
   public setLocale(locale: string): void {
-    dayjs.locale(locale);
+    DayjsApi.locale(locale);
   }
 
   public isDateTime(value: unknown): value is DateTime {
-    return dayjs.isDayjs(value);
+    return value instanceof DateTime;
   }
 
   /**
    * Create a new UTC DateTime instance.
    */
-  public utc(
-    date: string | number | Date | Dayjs | null | undefined,
-  ): DateTime {
-    return dayjs.utc(date);
+  public utc(date: DateTimeInput | null | undefined): DateTime {
+    return new DateTime(DayjsApi.utc(unwrap(date)));
   }
 
   /**
    * Create a new DateTime instance.
    */
-  public of(date: string | number | Date | Dayjs | null | undefined): DateTime {
-    return dayjs(date);
+  public of(date: DateTimeInput | null | undefined): DateTime {
+    if (date instanceof DateTime) {
+      return date;
+    }
+    return new DateTime(DayjsApi(date as any));
   }
 
   /**
    * Get the current date as a string.
    */
-  public toISOString(date: Date | string | DateTime = this.now()): string {
+  public toISOString(date: DateTimeInput = this.now()): string {
     return this.of(date).toISOString();
   }
 
@@ -152,7 +318,7 @@ export class DateTimeProvider {
       return this.ref;
     }
 
-    return dayjs();
+    return new DateTime(DayjsApi());
   }
 
   /**
@@ -162,12 +328,16 @@ export class DateTimeProvider {
     duration: DurationLike,
     unit?: ManipulateType,
   ): Duration => {
+    if (duration instanceof Duration) {
+      return duration;
+    }
+
     if (Array.isArray(duration)) {
-      return dayjs.duration(duration[0], duration[1]);
+      return new Duration(DayjsApi.duration(duration[0], duration[1]));
     }
 
     if (typeof duration === "number") {
-      return dayjs.duration(duration, unit || "milliseconds");
+      return new Duration(DayjsApi.duration(duration, unit || "milliseconds"));
     }
 
     return duration;
@@ -175,7 +345,9 @@ export class DateTimeProvider {
 
   public isDurationLike(value: unknown): value is DurationLike {
     try {
-      return dayjs.isDuration(this.duration(value as DurationLike));
+      return DayjsApi.isDuration(
+        this.duration(value as DurationLike).toDayjs(),
+      );
     } catch {
       return false;
     }
@@ -261,7 +433,7 @@ export class DateTimeProvider {
   ): Timeout {
     if (this.ref && now) {
       const next = this.of(now).add(this.duration(duration));
-      if (next < this.now()) {
+      if (next.valueOf() < this.now().valueOf()) {
         callback();
       }
       return {
@@ -403,6 +575,13 @@ export class DateTimeProvider {
   }
 }
 
+const unwrap = (value: DateTimeInput | null | undefined): any => {
+  if (value instanceof DateTime) {
+    return value.toDayjs();
+  }
+  return value;
+};
+
 export interface Interval {
   timer?: any;
   duration: number;

package/src/lock/core/index.ts

@@ -13,6 +13,37 @@ export * from "./providers/MemoryLockProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
+declare module "alepha" {
+  interface Hooks {
+    /**
+     * Fires when a lock is successfully acquired.
+     */
+    "lock:acquired": {
+      name: string;
+      id: string;
+      maxDurationMs: number;
+    };
+    /**
+     * Fires when a lock is released (handler completed or threw).
+     */
+    "lock:released": {
+      name: string;
+      id: string;
+      heldMs: number;
+    };
+    /**
+     * Fires when a lock acquisition contends with another holder.
+     * Emitted whether the caller eventually acquires (`wait: true`) or fails.
+     */
+    "lock:contended": {
+      name: string;
+      id: string;
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
 /**
  * Resource locking for distributed systems.
  *

package/src/lock/core/primitives/$lock.ts

@@ -43,7 +43,7 @@ export const $lock = (options: LockMiddlewareOptions): Middleware => {
   return createMiddleware({
     name: "$lock",
     options: options as unknown as Record<string, unknown>,
-    handler: ({ next }) => {
+    handler: ({ alepha, next }) => {
       const id = crypto.randomUUID();
       const maxDurationMs = dateTimeProvider
         .duration(options.maxDuration ?? [5, "minutes"])
@@ -71,11 +71,13 @@ export const $lock = (options: LockMiddlewareOptions): Middleware => {
 
         // Lock already ended (grace period active)
         if (endedAtStr) {
+          await alepha.events.emit("lock:contended", { name, id });
           throw new LockAcquireError(name);
         }
 
         // Lock held by someone else
         if (lockId !== id) {
+          await alepha.events.emit("lock:contended", { name, id });
           if (options.wait) {
             // Poll until lock is released
             const start = dateTimeProvider.nowMillis();
@@ -109,10 +111,21 @@ export const $lock = (options: LockMiddlewareOptions): Middleware => {
         }
 
         // We hold the lock — execute handler
+        const acquiredAt = dateTimeProvider.nowMillis();
+        await alepha.events.emit("lock:acquired", {
+          name,
+          id,
+          maxDurationMs,
+        });
         try {
           return await next(...args);
         } finally {
           await lockProvider.del(name);
+          await alepha.events.emit("lock:released", {
+            name,
+            id,
+            heldMs: dateTimeProvider.nowMillis() - acquiredAt,
+          });
         }
       };
     },

package/src/logger/services/Logger.ts

@@ -146,7 +146,7 @@ export class Logger implements LoggerInterface {
     }
 
     let _data: object | Error | undefined;
-    if (typeof data === "object" && !!data) {
+    if (typeof data === "object" && data) {
       _data = data;
     } else if (typeof message === "object" && message) {
       _data = message;

package/src/mcp/__tests__/$resource.spec.ts

@@ -364,7 +364,7 @@ describe("$resource primitive", () => {
         uri: "protected://resource",
         handler: async ({ context }) => {
           const authHeader = context?.headers?.authorization;
-          if (!authHeader || !authHeader.toString().startsWith("Bearer ")) {
+          if (!authHeader?.toString().startsWith("Bearer ")) {
             throw new Error("Unauthorized");
           }
           return { text: "Secret content" };

package/src/mcp/__tests__/$tool.spec.ts

@@ -379,7 +379,7 @@ describe("$tool primitive", () => {
         },
         handler: async ({ context }) => {
           const authHeader = context?.headers?.authorization;
-          if (!authHeader || !authHeader.toString().startsWith("Bearer ")) {
+          if (!authHeader?.toString().startsWith("Bearer ")) {
             throw new Error("Unauthorized");
           }
           return "Access granted";

package/src/mcp/__tests__/McpServerProvider.spec.ts

@@ -751,7 +751,7 @@ describe("McpServerProvider", () => {
           schema: { result: t.text() },
           handler: async ({ context }) => {
             const auth = context?.headers?.authorization;
-            if (!auth || !auth.toString().startsWith("Bearer ")) {
+            if (!auth?.toString().startsWith("Bearer ")) {
               throw new Error("Unauthorized");
             }
             return "Access granted";