brass-runtime 1.15.0 → 1.16.0

package/dist/chunk-ROJC3NBJ.js

@@ -0,0 +1,104 @@
+import {
+  unsafeGetCurrentRuntime
+} from "./chunk-7LVI2GIN.js";
+import {
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncSucceed
+} from "./chunk-PNVFW245.js";
+
+// src/core/runtime/combinators.ts
+function sleep(ms) {
+  return asyncEffect((_env, cb) => {
+    const delay = Math.max(0, Math.floor(ms));
+    const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
+    return () => clearTimeout(id);
+  });
+}
+function timeout(effect, ms) {
+  return asyncEffect((env, cb) => {
+    let done = false;
+    let timerId;
+    let effectRunning = true;
+    timerId = setTimeout(() => {
+      if (done) return;
+      done = true;
+      effectRunning = false;
+      cb({
+        _tag: "Failure",
+        cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
+      });
+    }, Math.max(0, Math.floor(ms)));
+    const runtime = unsafeGetCurrentRuntime();
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timerId);
+      cb(exit);
+    });
+    return () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timerId);
+      fiber.interrupt();
+    };
+  });
+}
+function retry(effect, policy) {
+  const shouldRetry = policy.shouldRetry ?? (() => true);
+  const jitter = policy.jitter ?? "full";
+  const maxElapsedMs = policy.maxElapsedMs;
+  const computeDelay = (attempt) => {
+    const exp = policy.baseDelayMs * Math.pow(2, attempt);
+    const capped = Math.min(exp, policy.maxDelayMs);
+    if (jitter === "none") return capped;
+    return Math.floor(Math.random() * capped);
+  };
+  const loop = (attempt, startedAt) => asyncFold(
+    effect,
+    (error) => {
+      if (attempt >= policy.maxRetries) return asyncFail(error);
+      if (!shouldRetry(error, attempt)) return asyncFail(error);
+      if (maxElapsedMs !== void 0) {
+        const elapsed = performance.now() - startedAt;
+        if (elapsed >= maxElapsedMs) return asyncFail(error);
+      }
+      const delay = computeDelay(attempt);
+      return asyncFlatMap(sleep(delay), () => loop(attempt + 1, startedAt));
+    },
+    (value) => asyncSucceed(value)
+  );
+  return asyncFlatMap(
+    { _tag: "Sync", thunk: () => performance.now() },
+    (startedAt) => loop(0, startedAt)
+  );
+}
+function retryN(effect, n) {
+  return retry(effect, {
+    maxRetries: n,
+    baseDelayMs: 0,
+    maxDelayMs: 0,
+    jitter: "none"
+  });
+}
+function retryWithBackoff(effect, opts = {}) {
+  return retry(effect, {
+    maxRetries: opts.maxRetries ?? 3,
+    baseDelayMs: opts.baseDelayMs ?? 100,
+    maxDelayMs: opts.maxDelayMs ?? 1e4,
+    maxElapsedMs: opts.maxElapsedMs,
+    shouldRetry: opts.shouldRetry,
+    jitter: "full"
+  });
+}
+
+export {
+  sleep,
+  timeout,
+  retry,
+  retryN,
+  retryWithBackoff
+};

package/dist/chunk-SPUEME2B.cjs

@@ -0,0 +1,343 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;// src/schema/index.ts
+var SchemaValidationException = class extends Error {
+  
+  constructor(issues) {
+    super(formatIssues(issues));
+    this.name = "SchemaValidationException";
+    this.issues = issues;
+  }
+};
+var ConfigValidationError = (_class = class extends Error {
+  __init() {this._tag = "ConfigValidationError"}
+  
+  
+  constructor(configName, issues) {
+    super(`${configName} failed validation: ${formatIssues(issues)}`);_class.prototype.__init.call(this);;
+    this.name = "ConfigValidationError";
+    this.configName = configName;
+    this.issues = issues;
+  }
+}, _class);
+var ok = (data) => ({ success: true, data });
+var fail = (issues) => ({ success: false, issues });
+var receivedKind = (value) => {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number" && Number.isNaN(value)) return "NaN";
+  return typeof value;
+};
+var pathLabel = (path) => path.length === 0 ? "$" : path.reduce((acc, part) => typeof part === "number" ? `${acc}[${part}]` : `${acc}.${part}`, "$");
+var makeSchemaIssue = (path, expected, received, message) => ({
+  path,
+  expected,
+  received: receivedKind(received),
+  message: _nullishCoalesce(message, () => ( `Expected ${expected} at ${pathLabel(path)}, received ${receivedKind(received)}`))
+});
+function formatIssues(issues) {
+  if (issues.length === 0) return "Validation failed";
+  const preview = issues.slice(0, 3).map((issue) => `${pathLabel(issue.path)}: ${issue.message}`).join("; ");
+  return issues.length > 3 ? `${preview}; +${issues.length - 3} more` : preview;
+}
+function makeSchema(kind, isOptional, parser, name) {
+  const self = {
+    _tag: "Schema",
+    kind,
+    name,
+    isOptional,
+    _parse: parser,
+    safeParse: (input) => parser(input, []),
+    parse: (input) => {
+      const result = parser(input, []);
+      if (result.success) return result.data;
+      throw new SchemaValidationException(result.issues);
+    },
+    optional: () => makeSchema(
+      `${kind}.optional`,
+      true,
+      (input, path) => input === void 0 ? ok(void 0) : parser(input, path),
+      name
+    ),
+    nullable: () => makeSchema(
+      `${kind}.nullable`,
+      isOptional,
+      (input, path) => input === null ? ok(null) : parser(input, path),
+      name
+    ),
+    array: () => arraySchema(self),
+    refine: (predicate, message) => makeSchema(
+      `${kind}.refine`,
+      isOptional,
+      (input, path) => {
+        const result = parser(input, path);
+        if (!result.success) return result;
+        return predicate(result.data) ? result : fail([makeSchemaIssue(path, _nullishCoalesce(name, () => ( kind)), result.data, _nullishCoalesce(message, () => ( `Failed refinement for ${_nullishCoalesce(name, () => ( kind))}`)))]);
+      },
+      name
+    ),
+    transform: (fn, expected) => makeSchema(
+      `${kind}.transform`,
+      false,
+      (input, path) => {
+        const result = parser(input, path);
+        if (!result.success) return result;
+        try {
+          return ok(fn(result.data));
+        } catch (error) {
+          return fail([
+            makeSchemaIssue(
+              path,
+              _nullishCoalesce(expected, () => ( `transform(${_nullishCoalesce(name, () => ( kind))})`)),
+              result.data,
+              error instanceof Error ? error.message : String(error)
+            )
+          ]);
+        }
+      },
+      _nullishCoalesce(expected, () => ( name))
+    )
+  };
+  return self;
+}
+function stringSchema(options = {}) {
+  return makeSchema("string", false, (input, path) => {
+    if (typeof input !== "string") return fail([makeSchemaIssue(path, _nullishCoalesce(options.name, () => ( "string")), input)]);
+    if (options.minLength !== void 0 && input.length < options.minLength) {
+      return fail([makeSchemaIssue(path, `string length >= ${options.minLength}`, input, `Expected at least ${options.minLength} characters`)]);
+    }
+    if (options.maxLength !== void 0 && input.length > options.maxLength) {
+      return fail([makeSchemaIssue(path, `string length <= ${options.maxLength}`, input, `Expected at most ${options.maxLength} characters`)]);
+    }
+    if (options.pattern && !options.pattern.test(input)) {
+      return fail([makeSchemaIssue(path, `string matching ${String(options.pattern)}`, input)]);
+    }
+    return ok(input);
+  }, options.name);
+}
+function nonEmptyStringSchema(options = {}) {
+  return stringSchema({
+    ...options,
+    minLength: 1,
+    name: _nullishCoalesce(options.name, () => ( "non-empty string"))
+  });
+}
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:\d{2})?)?$/;
+function emailSchema() {
+  return stringSchema({ pattern: EMAIL_PATTERN, name: "email" });
+}
+function uuidSchema() {
+  return stringSchema({ pattern: UUID_PATTERN, name: "uuid" });
+}
+function urlSchema() {
+  return stringSchema({ name: "url" }).refine((value) => {
+    try {
+      new URL(value);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }, "Expected valid URL");
+}
+function dateIsoSchema() {
+  return stringSchema({ pattern: ISO_DATE_PATTERN, name: "ISO date" }).refine((value) => Number.isFinite(Date.parse(value)), "Expected valid ISO date string");
+}
+function numberSchema(options = {}) {
+  const finite = _nullishCoalesce(options.finite, () => ( true));
+  return makeSchema("number", false, (input, path) => {
+    if (typeof input !== "number" || Number.isNaN(input)) return fail([makeSchemaIssue(path, _nullishCoalesce(options.name, () => ( "number")), input)]);
+    if (finite && !Number.isFinite(input)) return fail([makeSchemaIssue(path, "finite number", input)]);
+    if (options.int && !Number.isInteger(input)) return fail([makeSchemaIssue(path, "integer", input)]);
+    if (options.min !== void 0 && input < options.min) return fail([makeSchemaIssue(path, `number >= ${options.min}`, input)]);
+    if (options.max !== void 0 && input > options.max) return fail([makeSchemaIssue(path, `number <= ${options.max}`, input)]);
+    return ok(input);
+  }, options.name);
+}
+function intSchema(options = {}) {
+  return numberSchema({
+    ...options,
+    int: true,
+    name: _nullishCoalesce(options.name, () => ( "integer"))
+  });
+}
+function positiveSchema(options = {}) {
+  const min = Math.max(_nullishCoalesce(options.min, () => ( 0)), 0);
+  return numberSchema({
+    ...options,
+    min,
+    name: _nullishCoalesce(options.name, () => ( "positive number"))
+  }).refine((value) => value > 0, "Expected positive number");
+}
+function booleanSchema(name) {
+  return makeSchema(
+    "boolean",
+    false,
+    (input, path) => typeof input === "boolean" ? ok(input) : fail([makeSchemaIssue(path, _nullishCoalesce(name, () => ( "boolean")), input)]),
+    name
+  );
+}
+function unknownSchema() {
+  return makeSchema("unknown", false, (input) => ok(input));
+}
+function anySchema() {
+  return makeSchema("any", false, (input) => ok(input));
+}
+function literalSchema(value) {
+  return makeSchema(
+    `literal(${JSON.stringify(value)})`,
+    false,
+    (input, path) => Object.is(input, value) ? ok(value) : fail([makeSchemaIssue(path, JSON.stringify(value), input)])
+  );
+}
+function enumSchema(values) {
+  const allowed = new Set(values);
+  const expected = values.map((value) => JSON.stringify(value)).join(" | ");
+  return makeSchema(
+    `enum(${expected})`,
+    false,
+    (input, path) => (typeof input === "string" || typeof input === "number") && allowed.has(input) ? ok(input) : fail([makeSchemaIssue(path, expected, input)])
+  );
+}
+function arraySchema(item) {
+  return makeSchema("array", false, (input, path) => {
+    if (!Array.isArray(input)) return fail([makeSchemaIssue(path, "array", input)]);
+    const out = [];
+    const issues = [];
+    input.forEach((value, index) => {
+      const result = item._parse(value, [...path, index]);
+      if (result.success) {
+        out.push(result.data);
+      } else {
+        issues.push(...result.issues);
+      }
+    });
+    return issues.length > 0 ? fail(issues) : ok(out);
+  });
+}
+function objectSchema(shape, options = {}) {
+  const unknownKeys = _nullishCoalesce(options.unknownKeys, () => ( "strip"));
+  return makeSchema("object", false, (input, path) => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return fail([makeSchemaIssue(path, _nullishCoalesce(options.name, () => ( "object")), input)]);
+    }
+    const source = input;
+    const out = unknownKeys === "passthrough" ? { ...source } : {};
+    const issues = [];
+    const knownKeys = new Set(Object.keys(shape));
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      if (!(key in source)) {
+        if (!fieldSchema.isOptional) {
+          issues.push(makeSchemaIssue([...path, key], _nullishCoalesce(fieldSchema.name, () => ( fieldSchema.kind)), void 0, "Required field is missing"));
+        }
+        continue;
+      }
+      const result = fieldSchema._parse(source[key], [...path, key]);
+      if (result.success) {
+        out[key] = result.data;
+      } else {
+        issues.push(...result.issues);
+      }
+    }
+    if (unknownKeys === "strict") {
+      for (const key of Object.keys(source)) {
+        if (!knownKeys.has(key)) {
+          issues.push(makeSchemaIssue([...path, key], "known key", source[key], "Unknown key is not allowed"));
+        }
+      }
+    }
+    return issues.length > 0 ? fail(issues) : ok(out);
+  }, options.name);
+}
+function recordSchema(valueSchema) {
+  return makeSchema("record", false, (input, path) => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return fail([makeSchemaIssue(path, "record", input)]);
+    }
+    const out = {};
+    const issues = [];
+    for (const [key, value] of Object.entries(input)) {
+      const result = valueSchema._parse(value, [...path, key]);
+      if (result.success) {
+        out[key] = result.data;
+      } else {
+        issues.push(...result.issues);
+      }
+    }
+    return issues.length > 0 ? fail(issues) : ok(out);
+  });
+}
+function unionSchema(members) {
+  const expected = members.map((member) => _nullishCoalesce(member.name, () => ( member.kind))).join(" | ");
+  return makeSchema("union", false, (input, path) => {
+    const branchIssues = [];
+    for (const member of members) {
+      const result = member._parse(input, path);
+      if (result.success) return ok(result.data);
+      branchIssues.push(result.issues);
+    }
+    const mostSpecific = branchIssues.flatMap((issues) => issues).filter((issue) => issue.path.length > path.length).sort((a, b) => b.path.length - a.path.length);
+    if (mostSpecific.length > 0) return fail(mostSpecific);
+    return fail([makeSchemaIssue(path, expected, input)]);
+  });
+}
+function customSchema(guard, expected, message) {
+  return makeSchema(
+    expected,
+    false,
+    (input, path) => guard(input) ? ok(input) : fail([makeSchemaIssue(path, expected, input, message)]),
+    expected
+  );
+}
+var schema = Object.freeze({
+  string: stringSchema,
+  nonEmptyString: nonEmptyStringSchema,
+  email: emailSchema,
+  url: urlSchema,
+  uuid: uuidSchema,
+  dateIso: dateIsoSchema,
+  number: numberSchema,
+  int: intSchema,
+  positive: positiveSchema,
+  boolean: booleanSchema,
+  literal: literalSchema,
+  enum: enumSchema,
+  array: arraySchema,
+  object: objectSchema,
+  record: recordSchema,
+  union: unionSchema,
+  optional: (inner) => inner.optional(),
+  nullable: (inner) => inner.nullable(),
+  unknown: unknownSchema,
+  any: anySchema,
+  custom: customSchema
+});
+var s = schema;
+var Schema = schema;
+function isSchema(value) {
+  return typeof value === "object" && value !== null && value._tag === "Schema" && typeof value.safeParse === "function" && typeof value._parse === "function";
+}
+function validateValue(data, validator) {
+  if (isSchema(validator)) return validator.safeParse(data);
+  const result = validator(data);
+  if (result.success) return ok(result.data);
+  return fail(_nullishCoalesce(result.issues, () => ( [makeSchemaIssue([], "valid JSON shape", data, result.error)])));
+}
+function parseConfig(configName, validator, value) {
+  const result = validateValue(value, validator);
+  if (result.success) return result.data;
+  throw new ConfigValidationError(configName, result.issues);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+exports.SchemaValidationException = SchemaValidationException; exports.ConfigValidationError = ConfigValidationError; exports.makeSchemaIssue = makeSchemaIssue; exports.formatIssues = formatIssues; exports.schema = schema; exports.s = s; exports.Schema = Schema; exports.isSchema = isSchema; exports.validateValue = validateValue; exports.parseConfig = parseConfig;