brass-runtime 1.13.8 → 1.15.0

package/dist/{stream-BvukHxCv.d.ts → stream-FQm9h4Mg.d.ts}

@@ -1,4 +1,4 @@
-import { Z as ZIO, O as Option, E as Exit, A as Async } from './effect-ISvXPLgc.js';
+import { Z as ZIO, O as Option, E as Exit, A as Async } from './effect-CMOQKX8y.js';
 
 type Empty<R, E, A> = {
     readonly _tag: "Empty";
@@ -38,7 +38,11 @@ type Managed<R, E, A> = {
         release: (exit: Exit<any, any>) => Async<R, any, void>;
     }>;
 };
-type ZStream<R, E, A> = Empty<R, E, A> | Emit<R, E, A> | Concat<R, E, A> | FromPull<R, E, A> | Flatten<R, E, A> | Merge<R, E, A> | Scoped<R, E, A> | Managed<R, E, A>;
+type FromArray<R, E, A> = {
+    readonly _tag: "FromArray";
+    readonly values: readonly A[];
+};
+type ZStream<R, E, A> = Empty<R, E, A> | Emit<R, E, A> | Concat<R, E, A> | FromPull<R, E, A> | FromArray<R, E, A> | Flatten<R, E, A> | Merge<R, E, A> | Scoped<R, E, A> | Managed<R, E, A>;
 type Normalize<E> = (u: unknown) => E;
 declare const widenOpt: <E1, E2>(opt: Option<E1>) => Option<E1 | E2>;
 declare const fromPull: <R, E, A>(pull: ZIO<R, Option<E>, [A, ZStream<R, E, A>]>) => ZStream<R, E, A>;
@@ -61,6 +65,10 @@ declare function zip<R, E1, A, E2, B>(left: ZStream<R, E1, A>, right: ZStream<R,
 declare function foreachStream<R, E, A, R2, E2>(stream: ZStream<R, E, A>, f: (a: A) => Async<R2, E2, void>): Async<R & R2, E | E2, void>;
 declare function fromArray<A>(values: readonly A[]): ZStream<unknown, never, A>;
 declare function collectStream<R, E, A>(stream: ZStream<R, E, A>): ZIO<R, E, A[]>;
-declare function streamFromReadableStream<E>(body: ReadableStream<Uint8Array> | null | undefined, normalizeError: Normalize<E>): ZStream<unknown, E, Uint8Array>;
+type ReadableStreamOptions = {
+    signal?: AbortSignal;
+    onRelease?: () => void;
+};
+declare function streamFromReadableStream<E>(body: ReadableStream<Uint8Array> | null | undefined, normalizeError: Normalize<E>, options?: ReadableStreamOptions): ZStream<unknown, E, Uint8Array>;
 
-export { type Concat as C, type Emit as E, type Flatten as F, type Managed as M, type Normalize as N, type Scoped as S, type ZStream as Z, type Empty as a, type FromPull as b, type Merge as c, assertNever as d, collectStream as e, concatStream as f, emitStream as g, emptyStream as h, flattenStream as i, foreachStream as j, fromArray as k, fromPull as l, managedStream as m, mapStream as n, merge as o, mergeStream as p, unwrapScoped as q, rangeStream as r, streamFromReadableStream as s, uncons as u, widenOpt as w, zip as z };
+export { type Concat as C, type Emit as E, type Flatten as F, type Managed as M, type Normalize as N, type ReadableStreamOptions as R, type Scoped as S, type ZStream as Z, type Empty as a, type FromArray as b, type FromPull as c, type Merge as d, assertNever as e, collectStream as f, concatStream as g, emitStream as h, emptyStream as i, flattenStream as j, foreachStream as k, fromArray as l, fromPull as m, managedStream as n, mapStream as o, merge as p, mergeStream as q, rangeStream as r, streamFromReadableStream as s, unwrapScoped as t, uncons as u, widenOpt as w, zip as z };

package/dist/tracing-DNT9jEbr.d.ts

@@ -0,0 +1,106 @@
+import { A as Async } from './effect-CMOQKX8y.js';
+
+type CircuitBreakerState = "closed" | "open" | "half-open";
+type CircuitBreakerError = {
+    readonly _tag: "CircuitBreakerOpen";
+    readonly openSince: number;
+    readonly failures: number;
+};
+type CircuitBreakerConfig = {
+    /** Number of consecutive failures before opening the circuit. Default: 5 */
+    readonly failureThreshold?: number;
+    /** Time in ms to wait before transitioning from OPEN to HALF_OPEN. Default: 30000 */
+    readonly resetTimeoutMs?: number;
+    /** Number of successes in HALF_OPEN needed to close the circuit. Default: 1 */
+    readonly successThreshold?: number;
+    /** Custom predicate: should this error count as a failure? Default: all errors count. */
+    readonly isFailure?: (error: unknown) => boolean;
+    /** Called on state transitions (for observability). */
+    readonly onStateChange?: (from: CircuitBreakerState, to: CircuitBreakerState) => void;
+};
+type CircuitBreakerStats = {
+    readonly state: CircuitBreakerState;
+    readonly failures: number;
+    readonly successes: number;
+    readonly totalRequests: number;
+    readonly totalFailures: number;
+    readonly totalSuccesses: number;
+    readonly totalRejected: number;
+    readonly lastFailureTime: number | null;
+    readonly lastSuccessTime: number | null;
+};
+type CircuitBreaker = {
+    /** Current state of the circuit breaker. */
+    readonly state: () => CircuitBreakerState;
+    /** Run an effect through the circuit breaker. */
+    readonly protect: <R, E, A>(effect: Async<R, E, A>) => Async<R, E | CircuitBreakerError, A>;
+    /** Get current stats. */
+    readonly stats: () => CircuitBreakerStats;
+    /** Manually reset to closed state. */
+    readonly reset: () => void;
+};
+/**
+ * Creates a circuit breaker.
+ *
+ * ```ts
+ * const breaker = makeCircuitBreaker({ failureThreshold: 3, resetTimeoutMs: 10000 });
+ *
+ * // Protect an effect:
+ * const result = await run(breaker.protect(callExternalService()));
+ * // Throws CircuitBreakerOpen if circuit is open
+ * ```
+ */
+declare function makeCircuitBreaker(config?: CircuitBreakerConfig): CircuitBreaker;
+
+type SpanContext = {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId?: string;
+};
+type SpanStatus = "ok" | "error" | "unset";
+type Span = {
+    readonly name: string;
+    readonly context: SpanContext;
+    readonly startTime: number;
+    endTime?: number;
+    status: SpanStatus;
+    readonly attributes: Record<string, string | number | boolean>;
+    readonly events: SpanEvent[];
+};
+type SpanEvent = {
+    readonly name: string;
+    readonly time: number;
+    readonly attributes?: Record<string, string | number | boolean>;
+};
+type TracerConfig = {
+    /** Service name for span metadata. */
+    readonly serviceName: string;
+    /** Called when a span ends (for export). */
+    readonly onSpanEnd?: (span: Span) => void;
+    /** Sampling rate (0.0 to 1.0). Default: 1.0 (sample everything). */
+    readonly sampleRate?: number;
+};
+type Tracer = {
+    /** Wrap an effect in a span. */
+    readonly span: <R, E, A>(name: string, effect: Async<R, E, A>, attributes?: Record<string, string | number | boolean>) => Async<R, E, A>;
+    /** Get all completed spans (for testing). */
+    readonly spans: () => readonly Span[];
+    /** Clear collected spans. */
+    readonly clear: () => void;
+};
+/**
+ * Creates a tracer that wraps effects in spans.
+ *
+ * ```ts
+ * const tracer = makeTracer({ serviceName: "my-app" });
+ *
+ * const result = await run(
+ *   tracer.span("fetchUser", fetchUser(id), { userId: id })
+ * );
+ *
+ * console.log(tracer.spans()); // all completed spans
+ * ```
+ */
+declare function makeTracer(config: TracerConfig): Tracer;
+
+export { type CircuitBreaker as C, type Span as S, type Tracer as T, type CircuitBreakerConfig as a, type CircuitBreakerError as b, type CircuitBreakerState as c, type CircuitBreakerStats as d, type SpanContext as e, type SpanEvent as f, type SpanStatus as g, type TracerConfig as h, makeTracer as i, makeCircuitBreaker as m };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brass-runtime",
-  "version": "1.13.8",
+  "version": "1.15.0",
   "description": "Effect runtime utilities for TypeScript",
   "license": "MIT",
   "author": "Augusto Vivaldelli",
@@ -18,6 +18,11 @@
       "import": "./dist/http/index.mjs",
       "require": "./dist/http/index.cjs"
     },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.mjs",
+      "require": "./dist/core/index.cjs"
+    },
     "./agent": {
       "types": "./dist/agent/index.d.ts",
       "import": "./dist/agent/index.mjs",
@@ -55,7 +60,9 @@
     "clean": "rimraf dist wasm/pkg",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "COVERAGE_GATE=baseline vitest run --coverage",
+    "test:coverage:report": "COVERAGE_GATE=off vitest run --coverage",
+    "test:coverage:100": "COVERAGE_GATE=100 vitest run --coverage",
     "test:types": "tsc -p tsconfig.json --noEmit",
     "check": "npm run test:types && npm run test && npm run test:coverage",
     "check:full": "npm run clean && npm run build && npm run test",
@@ -84,7 +91,8 @@
     "agent:vscode:reinstall:global": "npm run agent:vscode:uninstall:global && npm run agent:vscode:install:global",
     "benchmark": "tsx src/benchmarks/runner.ts",
     "benchmark:json": "tsx src/benchmarks/runner.ts --json",
-    "test:coverage:html": "vitest run --coverage --reporter=default",
+    "context": "node scripts/context-pack.mjs",
+    "test:coverage:html": "COVERAGE_GATE=off vitest run --coverage --reporter=default",
     "build:wasm": "cd crates/brass-runtime-wasm-engine && wasm-pack build --target nodejs --out-dir ../../wasm/pkg",
     "build:ts": "tsup",
     "validate:cjs": "node scripts/validate-cjs.mjs"

package/wasm/pkg/brass_runtime_wasm_engine.d.ts

@@ -15,6 +15,22 @@ export class BrassWasmChunkBuffer {
     take_chunk(): Array<any>;
 }
 
+export class BrassWasmFiberReadyQueue {
+    free(): void;
+    [Symbol.dispose](): void;
+    begin_flush(): number;
+    clear(): void;
+    end_flush(ran: number): number;
+    enqueue_fiber(fiber_id: number, tag: string): number;
+    enqueue_fiber_lane(fiber_id: number, lane_id: number): number;
+    intern_lane(key: string): number;
+    len(): number;
+    metric_u64(id: number): number;
+    constructor(flush_budget: number, micro_threshold: number, lane_capacity: number, lane_budget: number, max_lanes: number);
+    shift_fiber(): number;
+    stats_json(): string;
+}
+
 export class BrassWasmFiberRegistry {
     free(): void;
     [Symbol.dispose](): void;
@@ -33,6 +49,37 @@ export class BrassWasmFiberRegistry {
     wake_queue_len(): number;
 }
 
+export class BrassWasmHttpPermitPool {
+    free(): void;
+    [Symbol.dispose](): void;
+    acquire(subject_id: number, key_id: number, now_ms: bigint): number;
+    advance_time(now_ms: bigint): number;
+    cancel(permit_id: number): boolean;
+    intern_key(key: string): number;
+    last_permit_id(): number;
+    memory(): any;
+    metric_u64(id: number): number;
+    metrics_snapshot_len(): number;
+    metrics_snapshot_ptr(): number;
+    constructor(concurrency: number, max_queue: number, queue_timeout_ms: bigint);
+    next_deadline_ms(): number;
+    permit_events_len(): number;
+    release(key_id: number, now_ms: bigint): number;
+}
+
+export class BrassWasmRetryPlanner {
+    free(): void;
+    [Symbol.dispose](): void;
+    drop_state(retry_id: number): boolean;
+    memory(): any;
+    metric_u64(id: number): number;
+    metrics_snapshot_len(): number;
+    metrics_snapshot_ptr(): number;
+    constructor();
+    next_delay_ms(retry_id: number, now_ms: number, retryable: boolean, retry_after_ms: number): number;
+    start(now_ms: number, max_retries: number, base_delay_ms: number, max_delay_ms: number, max_elapsed_ms: number, seed: bigint): number;
+}
+
 export class BrassWasmRingBuffer {
     free(): void;
     [Symbol.dispose](): void;
@@ -48,45 +95,77 @@ export class BrassWasmRingBuffer {
 export class BrassWasmSchedulerStateMachine {
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Enter flushing. Returns the number of tasks this flush may run.
-     */
     begin_flush(): number;
     capacity(): number;
     clear(): void;
-    /**
-     * Finish a flush. Returns the scheduling policy for the next flush:
-     * - 0 => schedule a micro flush
-     * - 1 => schedule a macro flush
-     * - 2 => no more work
-     */
     end_flush(ran: number): number;
+    enqueue(task_ref: number, tag: string): number;
     /**
-     * Enqueue a task ref and return the scheduling policy:
-     * - 0 => schedule a micro flush
-     * - 1 => schedule a macro flush
-     * - 2 => no new flush needed
-     * - 3 => queue full / task dropped
+     * Enqueue multiple tasks in a single boundary crossing.
+     * Returns a Uint32Array of policies (one per task):
+     * - 0 = SCHEDULER_POLICY_MICRO
+     * - 1 = SCHEDULER_POLICY_MACRO
+     * - 2 = SCHEDULER_POLICY_NONE (already scheduled)
+     * - 3 = SCHEDULER_POLICY_DROPPED
      */
-    enqueue(task_ref: number): number;
+    enqueue_batch(task_refs: Uint32Array, tags: Array<any>): Uint32Array;
+    enqueue_lane(task_ref: number, lane_id: number): number;
+    intern_lane(key: string): number;
     is_flushing(): boolean;
     is_scheduled(): boolean;
+    lane_len(lane_id: number): number;
     len(): number;
-    constructor(initial_capacity: number, max_capacity: number, flush_budget: number, micro_threshold: number);
+    metric_u64(id: number): number;
+    constructor(_initial_capacity: number, max_capacity: number, flush_budget: number, micro_threshold: number, lane_capacity: number, lane_budget: number, max_lanes: number);
     shift(): number;
     stats_json(): string;
 }
 
+export class BrassWasmTimerWheel {
+    free(): void;
+    [Symbol.dispose](): void;
+    advance_time(now_ms: bigint): number;
+    cancel(timer_id: number): boolean;
+    expired_len(): number;
+    memory(): any;
+    metric_u64(id: number): number;
+    metrics_snapshot_len(): number;
+    metrics_snapshot_ptr(): number;
+    constructor(tick_ms: bigint, bucket_count: number);
+    next_deadline_ms(): number;
+    schedule_deadline(subject_id: number, kind: number, deadline_ms: bigint): number;
+}
+
 export class BrassWasmVm {
     free(): void;
     [Symbol.dispose](): void;
     create_fiber(program_json: string): number;
+    create_fiber_bin(program_words: Uint32Array): number;
+    create_fiber_from_program_words(word_len: number): number;
+    drive_batch_bin(fiber_id: number, budget: number): Uint32Array;
+    drive_batch_ptr(fiber_id: number, budget: number): number;
     drop_fiber(fiber_id: number): void;
+    event_batch_len(): number;
     interrupt(fiber_id: number, reason_ref: number): string;
+    interrupt_bin(fiber_id: number, reason_ref: number, budget: number): Uint32Array;
+    interrupt_ptr(fiber_id: number, reason_ref: number, budget: number): number;
+    memory(): any;
+    metric_u64(id: number): number;
+    metrics_snapshot_len(): number;
+    metrics_snapshot_ptr(): number;
     constructor();
     poll(fiber_id: number): string;
+    poll_bin(fiber_id: number): Uint32Array;
+    prepare_patch_words(word_len: number): number;
+    prepare_program_words(word_len: number): number;
     provide_effect(fiber_id: number, root: number, nodes_json: string): string;
+    provide_effect_bin(fiber_id: number, root: number, nodes_words: Uint32Array, budget: number): Uint32Array;
+    provide_effect_from_words(fiber_id: number, root: number, word_len: number, budget: number): number;
     provide_error(fiber_id: number, error_ref: number): string;
+    provide_error_bin(fiber_id: number, error_ref: number, budget: number): Uint32Array;
+    provide_error_ptr(fiber_id: number, error_ref: number, budget: number): number;
     provide_value(fiber_id: number, value_ref: number): string;
+    provide_value_bin(fiber_id: number, value_ref: number, budget: number): Uint32Array;
+    provide_value_ptr(fiber_id: number, value_ref: number, budget: number): number;
     stats_json(): string;
 }