brass-runtime 1.15.0 → 1.16.0

package/dist/chunk-TDVMADDN.js

@@ -0,0 +1,343 @@
+// src/schema/index.ts
+var SchemaValidationException = class extends Error {
+  issues;
+  constructor(issues) {
+    super(formatIssues(issues));
+    this.name = "SchemaValidationException";
+    this.issues = issues;
+  }
+};
+var ConfigValidationError = class extends Error {
+  _tag = "ConfigValidationError";
+  configName;
+  issues;
+  constructor(configName, issues) {
+    super(`${configName} failed validation: ${formatIssues(issues)}`);
+    this.name = "ConfigValidationError";
+    this.configName = configName;
+    this.issues = issues;
+  }
+};
+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: 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, name ?? kind, result.data, message ?? `Failed refinement for ${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,
+              expected ?? `transform(${name ?? kind})`,
+              result.data,
+              error instanceof Error ? error.message : String(error)
+            )
+          ]);
+        }
+      },
+      expected ?? name
+    )
+  };
+  return self;
+}
+function stringSchema(options = {}) {
+  return makeSchema("string", false, (input, path) => {
+    if (typeof input !== "string") return fail([makeSchemaIssue(path, 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: 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 {
+      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 = options.finite ?? true;
+  return makeSchema("number", false, (input, path) => {
+    if (typeof input !== "number" || Number.isNaN(input)) return fail([makeSchemaIssue(path, 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: options.name ?? "integer"
+  });
+}
+function positiveSchema(options = {}) {
+  const min = Math.max(options.min ?? 0, 0);
+  return numberSchema({
+    ...options,
+    min,
+    name: 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, 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 = options.unknownKeys ?? "strip";
+  return makeSchema("object", false, (input, path) => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return fail([makeSchemaIssue(path, 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], 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) => 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(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);
+}
+
+export {
+  SchemaValidationException,
+  ConfigValidationError,
+  makeSchemaIssue,
+  formatIssues,
+  schema,
+  s,
+  Schema,
+  isSchema,
+  validateValue,
+  parseConfig
+};

package/dist/chunk-TVN5I4U6.cjs

@@ -0,0 +1,193 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkWQ5QNU5Rcjs = require('./chunk-WQ5QNU5R.cjs');
+
+
+
+
+
+
+
+var _chunkDJQ7OMMBcjs = require('./chunk-DJQ7OMMB.cjs');
+
+// src/core/runtime/scope.ts
+var nextScopeId = 1;
+function awaitAll(fibers) {
+  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+    let remaining = fibers.length;
+    if (remaining === 0) {
+      cb({ _tag: "Success", value: void 0 });
+      return;
+    }
+    for (const f of fibers) {
+      f.join(() => {
+        remaining -= 1;
+        if (remaining === 0) cb({ _tag: "Success", value: void 0 });
+      });
+    }
+  });
+}
+var Scope = (_class = class _Scope {
+  constructor(runtime, parentScopeId) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.runtime = runtime;
+    this.parentScopeId = parentScopeId;
+    this.id = nextScopeId++;
+    const inferredParent = _nullishCoalesce(this.parentScopeId, () => ( _optionalChain([_chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, ), 'optionalAccess', _ => _.scopeId])));
+    if (this.runtime.hasActiveHooks()) {
+      this.runtime.emit({
+        type: "scope.open",
+        scopeId: this.id,
+        parentScopeId: inferredParent
+      });
+    }
+  }
+  
+  
+  
+  __init() {this.closed = false}
+  __init2() {this.children = /* @__PURE__ */ new Set()}
+  __init3() {this.subScopes = /* @__PURE__ */ new Set()}
+  __init4() {this.finalizers = []}
+  /** registra un finalizer (LIFO) */
+  addFinalizer(f) {
+    if (this.closed) {
+      throw new Error("Trying to add finalizer to closed scope");
+    }
+    this.finalizers.push(f);
+  }
+  /** crea un sub scope (mismo runtime) */
+  subScope() {
+    if (this.closed) throw new Error("Scope closed");
+    const s = new _Scope(this.runtime, this.id);
+    this.subScopes.add(s);
+    return s;
+  }
+  /** ✅ fork en este scope */
+  fork(eff) {
+    if (this.closed) throw new Error("Scope closed");
+    const f = this.runtime.fork(eff, this.id);
+    this.children.add(f);
+    f.join(() => this.children.delete(f));
+    return f;
+  }
+  /** close fire-and-forget (no bloquea) */
+  close(exit = { _tag: "Success", value: void 0 }) {
+    this.runtime.fork(this.closeAsync(exit));
+  }
+  /** Emit the scope.close event if hooks are active. */
+  emitCloseEvent(exit) {
+    if (this.runtime.hasActiveHooks()) {
+      const status = exit._tag === "Success" ? "success" : exit.cause._tag === "Interrupt" ? "interrupted" : "failure";
+      this.runtime.emit({
+        type: "scope.close",
+        scopeId: this.id,
+        status,
+        error: exit._tag === "Failure" && exit.cause._tag === "Fail" ? exit.cause.error : void 0
+      });
+    }
+  }
+  /**
+   * Build an effect that executes finalizers in LIFO order.
+   *
+   * Optimization over the original: instead of wrapping every finalizer in
+   * `asyncFold(fin(exit), () => unit(), () => unit())` which creates 3 effect
+   * nodes per finalizer (Fold + 2 Succeed), we use a single Sync thunk per
+   * finalizer that catches errors inline.  When the finalizer returns a
+   * Succeed effect (like `unit()`), the Sync thunk completes without creating
+   * additional effect nodes.
+   */
+  buildFinalizerEffect(exit) {
+    const fins = this.finalizers;
+    if (fins.length === 0) return _chunkDJQ7OMMBcjs.unit.call(void 0, );
+    let chain = _chunkDJQ7OMMBcjs.unit.call(void 0, );
+    for (let i = fins.length - 1; i >= 0; i--) {
+      const fin = fins[i];
+      chain = _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, chain, () => {
+        let result;
+        try {
+          result = fin(exit);
+        } catch (e) {
+          return _chunkDJQ7OMMBcjs.unit.call(void 0, );
+        }
+        if (result._tag === "Succeed") {
+          return _chunkDJQ7OMMBcjs.unit.call(void 0, );
+        }
+        return _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+          result,
+          () => _chunkDJQ7OMMBcjs.unit.call(void 0, ),
+          () => _chunkDJQ7OMMBcjs.unit.call(void 0, )
+        );
+      });
+    }
+    return chain;
+  }
+  closeAsync(exit = { _tag: "Success", value: void 0 }, opts = { awaitChildren: true }) {
+    return _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+      _chunkDJQ7OMMBcjs.unit.call(void 0, ),
+      () => _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (env, cb) => {
+        if (this.closed) {
+          cb({ _tag: "Success", value: void 0 });
+          return;
+        }
+        this.closed = true;
+        const children = Array.from(this.children);
+        const subScopes = Array.from(this.subScopes);
+        for (const child of children) {
+          child.interrupt();
+        }
+        const closeSubs = subScopes.reduceRight(
+          (acc, s) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, acc, () => s.closeAsync(exit, opts)),
+          _chunkDJQ7OMMBcjs.unit.call(void 0, )
+        );
+        const runFinalizers = this.buildFinalizerEffect(exit);
+        const needsAwait = opts.awaitChildren && children.length > 0;
+        const awaitChildrenEff = needsAwait ? awaitAll(children) : _chunkDJQ7OMMBcjs.unit.call(void 0, );
+        const hasSubScopes = subScopes.length > 0;
+        const hasNoFinalizers = this.finalizers.length === 0;
+        if (!hasSubScopes && !needsAwait && hasNoFinalizers) {
+          this.emitCloseEvent(exit);
+          cb({ _tag: "Success", value: void 0 });
+          return;
+        }
+        const all = _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, closeSubs, () => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, awaitChildrenEff, () => runFinalizers));
+        this.runtime.fork(all).join(() => {
+          this.emitCloseEvent(exit);
+          cb({ _tag: "Success", value: void 0 });
+        });
+      })
+    );
+  }
+}, _class);
+function withScopeAsync(runtime, f) {
+  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+    const scope = new Scope(runtime);
+    let done = false;
+    const completeAfterClose = (exit) => {
+      runtime.fork(scope.closeAsync(exit)).join(() => {
+        if (done) return;
+        done = true;
+        cb(exit);
+      });
+    };
+    const fiber = runtime.fork(f(scope));
+    fiber.join(completeAfterClose);
+    return () => {
+      if (done) return;
+      fiber.interrupt();
+      runtime.fork(scope.closeAsync(_chunkDJQ7OMMBcjs.Exit.failCause(_chunkDJQ7OMMBcjs.Cause.interrupt())));
+    };
+  });
+}
+function withScope(runtime, f) {
+  return withScopeAsync(runtime, (scope) => {
+    const out = f(scope);
+    if (out && typeof out === "object" && "_tag" in out) return out;
+    return _chunkDJQ7OMMBcjs.unit.call(void 0, );
+  });
+}
+
+
+
+
+
+exports.Scope = Scope; exports.withScopeAsync = withScopeAsync; exports.withScope = withScope;