@setu-ts/kernel 0.9.0 → 0.10.0

package/src/context/response.ts

@@ -198,11 +198,7 @@ class BufferedResponseSnapshot implements Extract<ResponseSnapshot, { readonly s
   readonly status: number;
   readonly body: Uint8Array | string | null;
 
-  constructor(
-    response: ResponseBuilder,
-    status: number,
-    body: Uint8Array | string | null,
-  ) {
+  constructor(response: ResponseBuilder, status: number, body: Uint8Array | string | null) {
     this.#response = response;
     this.status = status;
     this.body = body;
@@ -224,11 +220,7 @@ class StreamingResponseSnapshot implements Extract<ResponseSnapshot, { readonly
   readonly status: number;
   readonly body: ReadableStream<Uint8Array>;
 
-  constructor(
-    response: ResponseBuilder,
-    status: number,
-    body: ReadableStream<Uint8Array>,
-  ) {
+  constructor(response: ResponseBuilder, status: number, body: ReadableStream<Uint8Array>) {
     this.#response = response;
     this.status = status;
     this.body = body;

package/src/diagnostics/buffer.ts

@@ -59,19 +59,21 @@ const EVENT_SKELETON_BYTES = 220;
  * @returns `true` when the encoded event is within {@linkcode MAX_EVENT_BYTES}
  * @since 0.8.0
  */
-export function eventWithinByteCap(
-  fieldLengths: {
-    readonly operationId: number;
-    readonly parentOperationId: number;
-    readonly nodeId: number;
-    readonly traceId: number;
-    readonly spanId: number;
-    readonly statusCode: boolean;
-  },
-): boolean {
-  const bounded = EVENT_SKELETON_BYTES +
-    fieldLengths.operationId + fieldLengths.parentOperationId + fieldLengths.nodeId +
-    fieldLengths.traceId + fieldLengths.spanId +
+export function eventWithinByteCap(fieldLengths: {
+  readonly operationId: number;
+  readonly parentOperationId: number;
+  readonly nodeId: number;
+  readonly traceId: number;
+  readonly spanId: number;
+  readonly statusCode: boolean;
+}): boolean {
+  const bounded =
+    EVENT_SKELETON_BYTES +
+    fieldLengths.operationId +
+    fieldLengths.parentOperationId +
+    fieldLengths.nodeId +
+    fieldLengths.traceId +
+    fieldLengths.spanId +
     (fieldLengths.statusCode ? 21 : 0);
   return bounded <= MAX_EVENT_BYTES;
 }
@@ -111,15 +113,15 @@ export function validateReadCursor(
   limit: number | undefined,
   lastSequence: number,
 ): { after: number; limit: number } {
-  if (
-    typeof after !== 'number' || !Number.isSafeInteger(after) || after < 0
-  ) {
+  if (typeof after !== 'number' || !Number.isSafeInteger(after) || after < 0) {
     throw new RangeError('Invalid diagnostics cursor: expected a non-negative safe integer.');
   }
   const effectiveLimit = limit ?? MAX_READ_LIMIT;
   if (
-    typeof effectiveLimit !== 'number' || !Number.isSafeInteger(effectiveLimit) ||
-    effectiveLimit < 1 || effectiveLimit > MAX_READ_LIMIT
+    typeof effectiveLimit !== 'number' ||
+    !Number.isSafeInteger(effectiveLimit) ||
+    effectiveLimit < 1 ||
+    effectiveLimit > MAX_READ_LIMIT
   ) {
     throw new RangeError(
       `Invalid diagnostics read limit: expected an integer from 1 to ${MAX_READ_LIMIT}.`,

package/src/diagnostics/collector.ts

@@ -508,9 +508,8 @@ export class DiagnosticsCollector implements IDiagnosticsSource {
         stages.push(stage);
       }
       this.#routeMiddlewareNodes.set(event.entryIndex, stages);
-      const ownerNode = event.owner === undefined
-        ? undefined
-        : this.#pluginNodesByName.get(event.owner);
+      const ownerNode =
+        event.owner === undefined ? undefined : this.#pluginNodesByName.get(event.owner);
       if (ownerNode !== undefined) {
         this.#addEdge(ownerNode.id, id, 'owns');
       }
@@ -631,9 +630,10 @@ export class DiagnosticsCollector implements IDiagnosticsSource {
     startedAtMs: number | null;
     durationMs: number | null;
   }): void {
-    const node = parts.scope === 'global'
-      ? this.#globalMiddlewareNodes[parts.position]?.id
-      : this.#routeMiddlewareNodes.get(parts.routeEntryIndex ?? -1)?.[parts.position]?.id;
+    const node =
+      parts.scope === 'global'
+        ? this.#globalMiddlewareNodes[parts.position]?.id
+        : this.#routeMiddlewareNodes.get(parts.routeEntryIndex ?? -1)?.[parts.position]?.id;
     this.#emitEvent({
       kind: 'middleware',
       stage: parts.scope,
@@ -797,11 +797,7 @@ export class DiagnosticsCollector implements IDiagnosticsSource {
     this.#snapshotDirty = true;
   }
 
-  #nextNodeId(
-    prefix: string,
-    current: number,
-    assign: (next: number) => void,
-  ): string | undefined {
+  #nextNodeId(prefix: string, current: number, assign: (next: number) => void): string | undefined {
     // Fixed v1 limit: stop ADDING topology at 1,024 nodes and report the
     // truncation rather than retaining unbounded metadata.
     if (this.#nodes.length >= MAX_NODES) {
@@ -926,12 +922,14 @@ export class DiagnosticsCollector implements IDiagnosticsSource {
     }
     // Identifiers are carried only when they are well-formed and non-zero —
     // the W3C all-zero ids mean "invalid", not "anonymous".
-    const traceId = TRACE_ID_PATTERN.test(context.traceId) && NON_ZERO.test(context.traceId)
-      ? context.traceId
-      : undefined;
-    const spanId = SPAN_ID_PATTERN.test(context.spanId) && NON_ZERO.test(context.spanId)
-      ? context.spanId
-      : undefined;
+    const traceId =
+      TRACE_ID_PATTERN.test(context.traceId) && NON_ZERO.test(context.traceId)
+        ? context.traceId
+        : undefined;
+    const spanId =
+      SPAN_ID_PATTERN.test(context.spanId) && NON_ZERO.test(context.spanId)
+        ? context.spanId
+        : undefined;
     return {
       ...(traceId !== undefined ? { traceId } : {}),
       ...(spanId !== undefined ? { spanId } : {}),
@@ -967,9 +965,10 @@ export class DiagnosticsCollector implements IDiagnosticsSource {
     // A status is recorded as the application set it — any finite number,
     // ranged or not — but a non-finite one is omitted, for the same reason a
     // non-finite priority is: it would serialize to `null` in a `number` field.
-    const statusCode = parts.statusCode !== undefined && Number.isFinite(parts.statusCode)
-      ? parts.statusCode
-      : undefined;
+    const statusCode =
+      parts.statusCode !== undefined && Number.isFinite(parts.statusCode)
+        ? parts.statusCode
+        : undefined;
     const parentLength = parts.parentOperationId?.length ?? 0;
     const withinCap = eventWithinByteCap({
       operationId: parts.operationId.length,

package/src/lifecycle/lifecycle-manager.ts

@@ -22,12 +22,7 @@ type ErrorHook = (error: Error, ctx: IRequestContext) => void | Promise<void>;
  * @since 0.8.0
  */
 export type LifecycleHookPhase =
-  | 'register-hook'
-  | 'init'
-  | 'bootstrap'
-  | 'stopping'
-  | 'shutdown'
-  | 'close';
+  'register-hook' | 'init' | 'bootstrap' | 'stopping' | 'shutdown' | 'close';
 
 /**
  * One hook invocation observed with its fixed phase plus execution ordinal —

package/src/pipeline/execute-chain.ts

@@ -123,9 +123,7 @@ export async function executeChain(
         // anonymous function — so `??` never fell back and the message read
         // "…in middleware " with a blank name. `||` is the correct operator.
         const label = names?.[position] || fn.name || '<anonymous>';
-        throw new Error(
-          `next() called multiple times in middleware ${label}`,
-        );
+        throw new Error(`next() called multiple times in middleware ${label}`);
       }
       nextCalled = true;
       if (observer !== undefined && responseEnded()) {

package/src/pipeline/middleware-pipeline.ts

@@ -71,9 +71,7 @@ export class MiddlewarePipeline implements IMiddlewareApi {
     if (this.#compiled !== null) {
       return this.#compiled;
     }
-    const sorted = [...this.#entries].sort(
-      (a, b) => a.priority - b.priority || a.index - b.index,
-    );
+    const sorted = [...this.#entries].sort((a, b) => a.priority - b.priority || a.index - b.index);
     this.#compiled = sorted.map((entry) => entry.fn);
     this.#compiledNames = sorted.map((entry) => entry.name);
     this.#compiledDescriptors = sorted.map((entry, position) => ({

package/src/registry/service-registry.ts

@@ -162,17 +162,11 @@ export class ServiceRegistry implements IServiceRegistry {
   }
 
   /** Installs the application-owned callback for startup-time mutations. */
-  setObserver(
-    observer: (kind: 'override' | 'unregister', token: CapabilityToken) => void,
-  ): void {
+  setObserver(observer: (kind: 'override' | 'unregister', token: CapabilityToken) => void): void {
     this.#observer = observer;
   }
 
-  register<T extends object>(
-    token: CapabilityToken,
-    service: T,
-    options?: RegisterOptions,
-  ): void {
+  register<T extends object>(token: CapabilityToken, service: T, options?: RegisterOptions): void {
     this.#store(token, { instance: service }, options);
   }
 
@@ -187,7 +181,8 @@ export class ServiceRegistry implements IServiceRegistry {
   get<T extends object>(token: CapabilityToken): T {
     const registration = this.#lookup(token);
     if (registration === undefined) {
-      const advice = this.#missExplanation?.(token) ??
+      const advice =
+        this.#missExplanation?.(token) ??
         'Register a plugin that provides it, or check the token spelling against CAPABILITIES.';
       throw new Error(`No service registered for capability '${token}'. ${advice}`);
     }

package/src/router/route-matcher.ts

@@ -53,18 +53,21 @@ export function parsePattern(pattern: string): readonly Segment[] {
   if (normalized === '/') {
     return [{ type: 'static', value: '' }];
   }
-  return normalized.slice(1).split('/').map((part) => {
-    if (part.startsWith(':')) {
-      return { type: 'param', name: part.slice(1) };
-    }
-    // Exactly `*`, never a segment merely CONTAINING one: `/a*` is not a pattern
-    // any first-party plugin registers, and treating it as a wildcard would lower
-    // the specificity of a path that matches literally.
-    if (part === '*') {
-      return { type: 'wildcard' };
-    }
-    return { type: 'static', value: part };
-  });
+  return normalized
+    .slice(1)
+    .split('/')
+    .map((part) => {
+      if (part.startsWith(':')) {
+        return { type: 'param', name: part.slice(1) };
+      }
+      // Exactly `*`, never a segment merely CONTAINING one: `/a*` is not a pattern
+      // any first-party plugin registers, and treating it as a wildcard would lower
+      // the specificity of a path that matches literally.
+      if (part === '*') {
+        return { type: 'wildcard' };
+      }
+      return { type: 'static', value: part };
+    });
 }
 
 /**