brass-runtime 1.15.0 → 1.16.0

package/dist/schedule-Fque9Abz.d.ts

@@ -0,0 +1,70 @@
+import { A as Async } from './effect-CGNl5Rqp.js';
+
+type ScheduleDecision = {
+    readonly continue: boolean;
+    readonly delayMs: number;
+};
+type ScheduleJitterOptions = {
+    /** 1 means full jitter in [0, delay], 0.2 means +/-20% around delay. */
+    readonly factor?: number;
+    /** Deterministic hook for tests. Defaults to Math.random. */
+    readonly random?: () => number;
+};
+/**
+ * A Schedule<I, O> takes an input I (typically the error or output of an effect)
+ * and decides whether to continue and with what delay.
+ */
+type Schedule<I, O> = {
+    readonly _tag: "Schedule";
+    /** Initial state */
+    readonly initial: () => any;
+    /** Given current state and input, produce a decision and next state */
+    readonly step: (state: any, input: I) => [ScheduleDecision, any, O];
+};
+/** Retry/repeat up to N times with no delay. */
+declare function recurs(n: number): Schedule<unknown, number>;
+/** Fixed delay between each retry/repeat. */
+declare function fixed(delayMs: number): Schedule<unknown, number>;
+/** Exponential backoff: delay doubles each time, capped at maxDelayMs. */
+declare function exponential(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Fibonacci backoff: base, base, 2*base, 3*base, 5*base, capped at maxDelayMs. */
+declare function fibonacci(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Exponential backoff with full jitter (random in [0, delay]). */
+declare function jittered(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Stop after a total elapsed time. */
+declare function elapsed(maxMs: number): Schedule<unknown, number>;
+/** Only continue while a predicate holds on the input. */
+declare function whileInput<I>(pred: (input: I) => boolean): Schedule<I, I>;
+/** Limit a schedule to N repetitions. */
+declare function take<I, O>(schedule: Schedule<I, O>, n: number): Schedule<I, O>;
+/** Transform schedule output while preserving decisions and state. */
+declare function map<I, O, O2>(schedule: Schedule<I, O>, f: (output: O) => O2): Schedule<I, O2>;
+/** Transform schedule input before it reaches the wrapped schedule. */
+declare function contramap<I0, I, O>(schedule: Schedule<I, O>, f: (input: I0) => I): Schedule<I0, O>;
+/** Add jitter to any schedule's delay. */
+declare function jitteredSchedule<I, O>(schedule: Schedule<I, O>, options?: number | ScheduleJitterOptions): Schedule<I, O>;
+declare const jitter: typeof jitteredSchedule;
+/**
+ * Reset a schedule's internal state after a rolling time window.
+ * Useful for retry/polling policies that should forgive old bursts.
+ */
+declare function windowed<I, O>(schedule: Schedule<I, O>, windowMs: number, clock?: () => number): Schedule<I, O>;
+/** Compose two schedules: use the first, then switch to the second. */
+declare function andThen<I, O1, O2>(first: Schedule<I, O1>, second: Schedule<I, O2>): Schedule<I, O1 | O2>;
+/** Run both schedules and continue while BOTH say continue. Use max delay. */
+declare function intersect<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
+/** Run both schedules and continue while EITHER says continue. Use min delay. */
+declare function union<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
+/**
+ * Retry an effect according to a schedule.
+ * The schedule receives the error as input on each failure.
+ */
+declare function retryWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<E, O>): Async<R, E, A>;
+/**
+ * Repeat an effect according to a schedule.
+ * The schedule receives the success value as input on each iteration.
+ * Returns the last successful value.
+ */
+declare function repeatWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<A, O>): Async<R, E, A>;
+
+export { type Schedule as S, type ScheduleDecision as a, andThen as b, contramap as c, exponential as d, elapsed as e, fibonacci as f, fixed as g, jittered as h, intersect as i, jitter as j, jitteredSchedule as k, repeatWithSchedule as l, map as m, retryWithSchedule as n, windowed as o, recurs as r, take as t, union as u, whileInput as w };

package/dist/schema/index.cjs

@@ -0,0 +1,25 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkSPUEME2Bcjs = require('../chunk-SPUEME2B.cjs');
+require('../chunk-OBGZSXTJ.cjs');
+
+
+
+
+
+
+
+
+
+
+
+exports.ConfigValidationError = _chunkSPUEME2Bcjs.ConfigValidationError; exports.Schema = _chunkSPUEME2Bcjs.Schema; exports.SchemaValidationException = _chunkSPUEME2Bcjs.SchemaValidationException; exports.formatIssues = _chunkSPUEME2Bcjs.formatIssues; exports.isSchema = _chunkSPUEME2Bcjs.isSchema; exports.makeSchemaIssue = _chunkSPUEME2Bcjs.makeSchemaIssue; exports.parseConfig = _chunkSPUEME2Bcjs.parseConfig; exports.s = _chunkSPUEME2Bcjs.s; exports.schema = _chunkSPUEME2Bcjs.schema; exports.validateValue = _chunkSPUEME2Bcjs.validateValue;

package/dist/schema/index.d.ts

@@ -0,0 +1,177 @@
+type SchemaPathPart = string | number;
+type SchemaIssue = {
+    readonly path: readonly SchemaPathPart[];
+    readonly expected: string;
+    readonly received: string;
+    readonly message: string;
+};
+type SchemaResult<A> = {
+    readonly success: true;
+    readonly data: A;
+} | {
+    readonly success: false;
+    readonly issues: readonly SchemaIssue[];
+};
+type AnySchema = Schema<any, any>;
+type InferSchema<S> = S extends Schema<infer A, any> ? A : never;
+type SchemaShape = Record<string, AnySchema>;
+type OptionalKeys<Shape extends SchemaShape> = {
+    [K in keyof Shape]: Shape[K] extends Schema<any, true> ? K : never;
+}[keyof Shape];
+type RequiredKeys<Shape extends SchemaShape> = Exclude<keyof Shape, OptionalKeys<Shape>>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type InferObject<Shape extends SchemaShape> = Simplify<{
+    [K in RequiredKeys<Shape>]: InferSchema<Shape[K]>;
+} & {
+    [K in OptionalKeys<Shape>]?: Exclude<InferSchema<Shape[K]>, undefined>;
+}>;
+type JsonValidatorResult<A> = {
+    readonly success: true;
+    readonly data: A;
+} | {
+    readonly success: false;
+    readonly error: string;
+    readonly issues?: readonly SchemaIssue[];
+};
+type JsonValidator<A> = (data: unknown) => JsonValidatorResult<A>;
+type JsonSchemaLike<A> = Schema<A, any> | JsonValidator<A>;
+type AnyJsonSchemaLike = JsonSchemaLike<any>;
+type InferJsonSchema<V> = V extends Schema<infer A, any> ? A : V extends JsonValidator<infer A> ? A : never;
+type StringSchemaOptions = {
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: RegExp;
+    readonly name?: string;
+};
+type NumberSchemaOptions = {
+    readonly min?: number;
+    readonly max?: number;
+    readonly int?: boolean;
+    readonly finite?: boolean;
+    readonly name?: string;
+};
+type ObjectSchemaOptions = {
+    readonly unknownKeys?: "strip" | "passthrough" | "strict";
+    readonly name?: string;
+};
+declare class SchemaValidationException extends Error {
+    readonly issues: readonly SchemaIssue[];
+    constructor(issues: readonly SchemaIssue[]);
+}
+declare class ConfigValidationError extends Error {
+    readonly _tag = "ConfigValidationError";
+    readonly configName: string;
+    readonly issues: readonly SchemaIssue[];
+    constructor(configName: string, issues: readonly SchemaIssue[]);
+}
+declare const makeSchemaIssue: (path: readonly SchemaPathPart[], expected: string, received: unknown, message?: string) => SchemaIssue;
+declare function formatIssues(issues: readonly SchemaIssue[]): string;
+declare function stringSchema(options?: StringSchemaOptions): Schema<string>;
+declare function nonEmptyStringSchema(options?: Omit<StringSchemaOptions, "minLength">): Schema<string>;
+declare function emailSchema(): Schema<string>;
+declare function uuidSchema(): Schema<string>;
+declare function urlSchema(): Schema<string>;
+declare function dateIsoSchema(): Schema<string>;
+declare function numberSchema(options?: NumberSchemaOptions): Schema<number>;
+declare function intSchema(options?: Omit<NumberSchemaOptions, "int">): Schema<number>;
+declare function positiveSchema(options?: NumberSchemaOptions): Schema<number>;
+declare function booleanSchema(name?: string): Schema<boolean>;
+declare function unknownSchema(): Schema<unknown>;
+declare function anySchema(): Schema<any>;
+declare function literalSchema<const Value extends string | number | boolean | null>(value: Value): Schema<Value>;
+declare function enumSchema<const Values extends readonly [string | number, ...(string | number)[]]>(values: Values): Schema<Values[number]>;
+declare function arraySchema<S extends AnySchema>(item: S): Schema<Array<InferSchema<S>>>;
+declare function objectSchema<Shape extends SchemaShape>(shape: Shape, options?: ObjectSchemaOptions): Schema<InferObject<Shape>>;
+declare function recordSchema<S extends AnySchema>(valueSchema: S): Schema<Record<string, InferSchema<S>>>;
+declare function unionSchema<const Members extends readonly [AnySchema, AnySchema, ...AnySchema[]]>(members: Members): Schema<InferSchema<Members[number]>>;
+declare function customSchema<A>(guard: (input: unknown) => input is A, expected: string, message?: string): Schema<A>;
+declare const schema: Readonly<{
+    string: typeof stringSchema;
+    nonEmptyString: typeof nonEmptyStringSchema;
+    email: typeof emailSchema;
+    url: typeof urlSchema;
+    uuid: typeof uuidSchema;
+    dateIso: typeof dateIsoSchema;
+    number: typeof numberSchema;
+    int: typeof intSchema;
+    positive: typeof positiveSchema;
+    boolean: typeof booleanSchema;
+    literal: typeof literalSchema;
+    enum: typeof enumSchema;
+    array: typeof arraySchema;
+    object: typeof objectSchema;
+    record: typeof recordSchema;
+    union: typeof unionSchema;
+    optional: <S extends AnySchema>(inner: S) => Schema<InferSchema<S> | undefined, true>;
+    nullable: <S extends AnySchema>(inner: S) => Schema<InferSchema<S> | null, S["isOptional"]>;
+    unknown: typeof unknownSchema;
+    any: typeof anySchema;
+    custom: typeof customSchema;
+}>;
+declare const s: Readonly<{
+    string: typeof stringSchema;
+    nonEmptyString: typeof nonEmptyStringSchema;
+    email: typeof emailSchema;
+    url: typeof urlSchema;
+    uuid: typeof uuidSchema;
+    dateIso: typeof dateIsoSchema;
+    number: typeof numberSchema;
+    int: typeof intSchema;
+    positive: typeof positiveSchema;
+    boolean: typeof booleanSchema;
+    literal: typeof literalSchema;
+    enum: typeof enumSchema;
+    array: typeof arraySchema;
+    object: typeof objectSchema;
+    record: typeof recordSchema;
+    union: typeof unionSchema;
+    optional: <S extends AnySchema>(inner: S) => Schema<InferSchema<S> | undefined, true>;
+    nullable: <S extends AnySchema>(inner: S) => Schema<InferSchema<S> | null, S["isOptional"]>;
+    unknown: typeof unknownSchema;
+    any: typeof anySchema;
+    custom: typeof customSchema;
+}>;
+type Schema<A, Optional extends boolean = false> = {
+    readonly _tag: "Schema";
+    readonly kind: string;
+    readonly name?: string;
+    readonly isOptional: Optional;
+    readonly _parse: (input: unknown, path: readonly SchemaPathPart[]) => SchemaResult<A>;
+    readonly safeParse: (input: unknown) => SchemaResult<A>;
+    readonly parse: (input: unknown) => A;
+    readonly optional: () => Schema<A | undefined, true>;
+    readonly nullable: () => Schema<A | null, Optional>;
+    readonly array: () => Schema<A[], false>;
+    readonly refine: (predicate: (value: A) => boolean, message?: string) => Schema<A, Optional>;
+    readonly transform: <B>(fn: (value: A) => B, expected?: string) => Schema<B, false>;
+};
+declare const Schema: Readonly<{
+    string: typeof stringSchema;
+    nonEmptyString: typeof nonEmptyStringSchema;
+    email: typeof emailSchema;
+    url: typeof urlSchema;
+    uuid: typeof uuidSchema;
+    dateIso: typeof dateIsoSchema;
+    number: typeof numberSchema;
+    int: typeof intSchema;
+    positive: typeof positiveSchema;
+    boolean: typeof booleanSchema;
+    literal: typeof literalSchema;
+    enum: typeof enumSchema;
+    array: typeof arraySchema;
+    object: typeof objectSchema;
+    record: typeof recordSchema;
+    union: typeof unionSchema;
+    optional: <S extends AnySchema>(inner: S) => Schema<InferSchema<S> | undefined, true>;
+    nullable: <S extends AnySchema>(inner: S) => Schema<InferSchema<S> | null, S["isOptional"]>;
+    unknown: typeof unknownSchema;
+    any: typeof anySchema;
+    custom: typeof customSchema;
+}>;
+declare function isSchema(value: unknown): value is AnySchema;
+declare function validateValue<A>(data: unknown, validator: JsonSchemaLike<A>): SchemaResult<A>;
+declare function parseConfig<A>(configName: string, validator: JsonSchemaLike<A>, value: unknown): A;
+
+export { type AnyJsonSchemaLike, type AnySchema, ConfigValidationError, type InferJsonSchema, type InferObject, type InferSchema, type JsonSchemaLike, type JsonValidator, type JsonValidatorResult, type NumberSchemaOptions, type ObjectSchemaOptions, Schema, type SchemaIssue, type SchemaPathPart, type SchemaResult, type SchemaShape, SchemaValidationException, type StringSchemaOptions, formatIssues, isSchema, makeSchemaIssue, parseConfig, s, schema, validateValue };

package/dist/schema/index.js

@@ -0,0 +1,25 @@
+import {
+  ConfigValidationError,
+  Schema,
+  SchemaValidationException,
+  formatIssues,
+  isSchema,
+  makeSchemaIssue,
+  parseConfig,
+  s,
+  schema,
+  validateValue
+} from "../chunk-TDVMADDN.js";
+import "../chunk-3RG5ZIWI.js";
+export {
+  ConfigValidationError,
+  Schema,
+  SchemaValidationException,
+  formatIssues,
+  isSchema,
+  makeSchemaIssue,
+  parseConfig,
+  s,
+  schema,
+  validateValue
+};

package/dist/schema/index.mjs

@@ -0,0 +1,25 @@
+import {
+  ConfigValidationError,
+  Schema,
+  SchemaValidationException,
+  formatIssues,
+  isSchema,
+  makeSchemaIssue,
+  parseConfig,
+  s,
+  schema,
+  validateValue
+} from "../chunk-U5KWK3PX.mjs";
+import "../chunk-Y6FXYEAI.mjs";
+export {
+  ConfigValidationError,
+  Schema,
+  SchemaValidationException,
+  formatIssues,
+  isSchema,
+  makeSchemaIssue,
+  parseConfig,
+  s,
+  schema,
+  validateValue
+};