brass-runtime 1.17.0 → 1.18.0

package/dist/{chunk-6IXXWIUM.js → chunk-IBRHSH5H.js}

@@ -1,15 +1,20 @@
 import {
+  Scope,
   liveClock,
   runtimeClockFromEnv,
   unsafeGetCurrentRuntime
-} from "./chunk-FH2X7BVP.js";
+} from "./chunk-XSAHV5HQ.js";
 import {
   Async,
+  Cause,
+  Exit,
   asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
-  asyncSucceed
+  asyncSucceed,
+  asyncSync,
+  unit
 } from "./chunk-UB4B6OFY.js";
 
 // src/core/runtime/combinators.ts
@@ -102,6 +107,174 @@ function retryWithBackoff(effect, opts = {}) {
   });
 }
 
+// src/core/runtime/resource.ts
+function bracket(acquire, use, release) {
+  return asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const scope = new Scope(runtime);
+    const acquireFiber = scope.fork(acquire);
+    acquireFiber.join((acquireExit) => {
+      if (acquireExit._tag === "Failure") {
+        scope.close(acquireExit);
+        cb(acquireExit);
+        return;
+      }
+      const resource2 = acquireExit.value;
+      const useFiber = scope.fork(use(resource2));
+      useFiber.join((useExit) => {
+        const releaseEffect = safeRelease(release, resource2, useExit);
+        const releaseFiber = runtime.fork(releaseEffect);
+        releaseFiber.join(() => {
+          scope.close(useExit);
+          cb(useExit);
+        });
+      });
+    });
+    return () => {
+      scope.close(Exit.failCause(Cause.interrupt()));
+    };
+  });
+}
+function safeRelease(release, resource2, exit) {
+  return asyncFold(
+    (() => {
+      try {
+        return release(resource2, exit);
+      } catch {
+        return unit();
+      }
+    })(),
+    () => unit(),
+    () => unit()
+  );
+}
+function ensuring(effect, finalizer) {
+  return asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      const fin = asyncFold(
+        (() => {
+          try {
+            return finalizer(exit);
+          } catch {
+            return unit();
+          }
+        })(),
+        () => unit(),
+        () => unit()
+      );
+      runtime.fork(fin).join(() => {
+        cb(exit);
+      });
+    });
+    return () => {
+      fiber.interrupt();
+    };
+  });
+}
+function resource(acquire, release) {
+  return makeResourceFromUse((body) => bracket(acquire, body, release));
+}
+var makeResource = resource;
+function resourceSucceed(value) {
+  return makeResourceFromUse((body) => body(value));
+}
+function resourceFromManaged(m) {
+  return makeResourceFromUse((body) => useManaged(m, body));
+}
+function useResource(res, body) {
+  return res.use(body);
+}
+function resourceAll(resources) {
+  const build = (index) => {
+    if (index >= resources.length) return resourceSucceed([]);
+    return resources[index].flatMap(
+      (head) => build(index + 1).map((tail) => [head, ...tail])
+    );
+  };
+  return build(0).map((values) => values);
+}
+var Resource = Object.freeze({
+  make: resource,
+  succeed: resourceSucceed,
+  fromManaged: resourceFromManaged,
+  all: resourceAll,
+  use: useResource
+});
+function makeResourceFromUse(use) {
+  const self = {
+    _tag: "Resource",
+    use,
+    map: (f) => makeResourceFromUse((body) => self.use((a) => body(f(a)))),
+    flatMap: (f) => makeResourceFromUse((body) => self.use((a) => f(a).use(body))),
+    zip: (that) => self.flatMap((a) => that.map((b) => [a, b]))
+  };
+  return self;
+}
+function managed(acquire, release) {
+  return {
+    _tag: "Managed",
+    acquire,
+    release: (resource2, exit) => release(resource2, exit)
+  };
+}
+function useManaged(m, body) {
+  return bracket(m.acquire, body, m.release);
+}
+function managedAll(manageds) {
+  const acquire = asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const resources = [];
+    let i = 0;
+    const acquireNext = () => {
+      if (i >= manageds.length) {
+        cb({ _tag: "Success", value: resources });
+        return;
+      }
+      const m = manageds[i];
+      const fiber = runtime.fork(m.acquire);
+      fiber.join((exit) => {
+        if (exit._tag === "Failure") {
+          releaseAcquired(runtime, manageds, resources, exit).then(() => {
+            cb(exit);
+          });
+          return;
+        }
+        resources.push(exit.value);
+        i++;
+        acquireNext();
+      });
+    };
+    acquireNext();
+  });
+  const release = (resources, exit) => {
+    return asyncEffect((_env, cb) => {
+      const runtime = unsafeGetCurrentRuntime();
+      releaseAcquired(runtime, manageds, resources, exit).then(() => {
+        cb({ _tag: "Success", value: void 0 });
+      });
+    });
+  };
+  return { _tag: "Managed", acquire, release };
+}
+async function releaseAcquired(runtime, manageds, resources, exit) {
+  for (let i = resources.length - 1; i >= 0; i--) {
+    try {
+      const m = manageds[i];
+      await new Promise((resolve) => {
+        const releaseEff = asyncFold(
+          m.release(resources[i], exit),
+          () => unit(),
+          () => unit()
+        );
+        runtime.fork(releaseEff).join(() => resolve());
+      });
+    } catch {
+    }
+  }
+}
+
 // src/core/runtime/schedule.ts
 function recurs(n) {
   return {
@@ -636,12 +809,359 @@ var Schedule = Object.freeze({
   poll: repeatWithSchedule
 });
 
+// src/core/runtime/layer.ts
+var MissingLayerServiceError = class extends Error {
+  _tag = "MissingLayerService";
+  serviceName;
+  constructor(serviceName) {
+    super(`Missing layer service '${serviceName}'. Add a layer that provides this ServiceTag or pass a LayerContext containing it.`);
+    this.name = "MissingLayerServiceError";
+    this.serviceName = serviceName;
+  }
+};
+function formatLayerError(error) {
+  if (error instanceof MissingLayerServiceError) return error.message;
+  if (isObjectRecord(error) && error._tag === "MissingLayerService" && typeof error.serviceName === "string") {
+    return `Missing layer service '${error.serviceName}'. Add the provider layer before using the service.`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function makeServiceTag(name) {
+  return {
+    _tag: "ServiceTag",
+    key: Symbol(name),
+    name
+  };
+}
+var serviceTag = makeServiceTag;
+var defineService = makeServiceTag;
+var LayerContext = class _LayerContext {
+  services;
+  constructor(entries) {
+    if (entries instanceof Map) {
+      this.services = new Map(entries);
+      return;
+    }
+    this.services = /* @__PURE__ */ new Map();
+    if (!entries) return;
+    for (const [tag, service] of entries) this.services.set(tag.key, service);
+  }
+  static empty() {
+    return new _LayerContext();
+  }
+  get(tag) {
+    return this.services.get(tag.key);
+  }
+  unsafeGet(tag) {
+    if (!this.services.has(tag.key)) {
+      throw new MissingLayerServiceError(tag.name);
+    }
+    return this.services.get(tag.key);
+  }
+  has(tag) {
+    return this.services.has(tag.key);
+  }
+  add(tag, service) {
+    const next = new Map(this.services);
+    next.set(tag.key, service);
+    return new _LayerContext(next);
+  }
+  merge(other) {
+    const next = new Map(this.services);
+    for (const [key, service] of other.services) next.set(key, service);
+    return new _LayerContext(next);
+  }
+  size() {
+    return this.services.size;
+  }
+};
+function makeLayerScope() {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const finalizers = [];
+  let closed = false;
+  const scope = {
+    get: (l, deps) => {
+      if (closed) return asyncFail(new Error("LayerScope is closed"));
+      if (cache.has(l)) return asyncSucceed(cache.get(l));
+      const built = l.buildScoped ? l.buildScoped(deps, scope) : asyncFlatMap(
+        l.build(deps),
+        ({ service, release }) => asyncFlatMap(scope.addFinalizer(release), () => asyncSucceed(service))
+      );
+      return asyncFlatMap(
+        built,
+        (service) => asyncSync(() => {
+          cache.set(l, service);
+          return service;
+        })
+      );
+    },
+    close: () => {
+      if (closed) return unit();
+      closed = true;
+      return releaseAll(finalizers);
+    },
+    size: () => finalizers.length,
+    addFinalizer: (release) => asyncSync(() => {
+      if (!closed) finalizers.push(release);
+    })
+  };
+  return scope;
+}
+function releaseAll(finalizers) {
+  const next = finalizers.pop();
+  if (!next) return unit();
+  return asyncFold(
+    next(),
+    () => releaseAll(finalizers),
+    () => releaseAll(finalizers)
+  );
+}
+function mergeServices(a, b) {
+  if (a instanceof LayerContext && b instanceof LayerContext) {
+    return a.merge(b);
+  }
+  if (isObjectRecord(a) && isObjectRecord(b)) {
+    return { ...a, ...b };
+  }
+  return Object.assign({}, a, b);
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function layer(acquire, release) {
+  return {
+    _tag: "Layer",
+    build: (_deps) => asyncFlatMap(acquire(), (service) => asyncSucceed({
+      service,
+      release: release ? () => release(service) : () => unit()
+    }))
+  };
+}
+function layerValue(tag, value) {
+  return layerEffect(tag, () => asyncSucceed(value));
+}
+var makeTestLayer = layerValue;
+function makeTestLayers(...providers) {
+  return {
+    _tag: "Layer",
+    build: (deps = LayerContext.empty()) => asyncSucceed({
+      service: providers.reduce(
+        (context, [tag, service]) => context.add(tag, service),
+        deps
+      ),
+      release: () => unit()
+    })
+  };
+}
+function layerEffect(tag, acquire, release) {
+  return {
+    _tag: "Layer",
+    build: (deps = LayerContext.empty()) => asyncFlatMap(acquire(deps), (service) => asyncSucceed({
+      service: deps.add(tag, service),
+      release: release ? () => release(service) : () => unit()
+    }))
+  };
+}
+var layerFromContext = layerEffect;
+var defineLayer = layerEffect;
+function getService(tag) {
+  return asyncSync((context) => context.unsafeGet(tag));
+}
+function getServices(tags) {
+  return asyncSync((context) => readServices(context, tags));
+}
+function useService(tag, use) {
+  return (context) => {
+    let service;
+    try {
+      service = context.unsafeGet(tag);
+    } catch (error) {
+      return asyncFail(error);
+    }
+    return use(service);
+  };
+}
+function useServices(tags, use) {
+  return (context) => {
+    let services;
+    try {
+      services = readServices(context, tags);
+    } catch (error) {
+      return asyncFail(error);
+    }
+    return use(services);
+  };
+}
+function readServices(context, tags) {
+  const services = {};
+  for (const key of Object.keys(tags)) {
+    services[key] = context.unsafeGet(tags[key]);
+  }
+  return services;
+}
+function layerFrom() {
+  return (acquire, release) => ({
+    _tag: "Layer",
+    build: (deps) => asyncFlatMap(acquire(deps), (service) => asyncSucceed({
+      service,
+      release: release ? () => release(service) : () => unit()
+    }))
+  });
+}
+function layerSucceed(value) {
+  return {
+    _tag: "Layer",
+    build: () => asyncSucceed({ service: value, release: () => unit() })
+  };
+}
+function layerFail(error) {
+  return {
+    _tag: "Layer",
+    build: () => asyncFail(error)
+  };
+}
+function compose(from, to) {
+  return {
+    _tag: "Layer",
+    buildScoped: (deps, scope) => asyncFlatMap(
+      scope.get(from, deps),
+      (mid) => scope.get(to, mid)
+    ),
+    build: (deps) => asyncFlatMap(
+      from.build(deps),
+      ({ service: mid, release: releaseMid }) => asyncFold(
+        to.build(mid),
+        (error) => asyncFlatMap(releaseMid(), () => asyncFail(error)),
+        ({ service: out, release: releaseOut }) => asyncSucceed({
+          service: out,
+          release: () => asyncFlatMap(releaseOut(), () => releaseMid())
+        })
+      )
+    )
+  };
+}
+function composeAll(...layers) {
+  return layers.slice(1).reduce(
+    (acc, next) => compose(acc, next),
+    layers[0]
+  );
+}
+function merge(left, right) {
+  return {
+    _tag: "Layer",
+    buildScoped: (deps, scope) => asyncFlatMap(
+      scope.get(left, deps),
+      (a) => asyncFlatMap(
+        scope.get(right, deps),
+        (b) => asyncSucceed(mergeServices(a, b))
+      )
+    ),
+    build: (deps) => asyncFlatMap(
+      left.build(deps),
+      ({ service: a, release: releaseA }) => asyncFold(
+        right.build(deps),
+        (error) => asyncFlatMap(releaseA(), () => asyncFail(error)),
+        ({ service: b, release: releaseB }) => asyncSucceed({
+          service: mergeServices(a, b),
+          release: () => asyncFlatMap(releaseB(), () => releaseA())
+        })
+      )
+    )
+  };
+}
+function mergeAll(...layers) {
+  return layers.slice(1).reduce(
+    (acc, next) => merge(acc, next),
+    layers[0]
+  );
+}
+function mapLayer(l, f) {
+  return {
+    _tag: "Layer",
+    buildScoped: (deps, scope) => asyncFlatMap(
+      scope.get(l, deps),
+      (service) => asyncSucceed(f(service))
+    ),
+    build: (deps) => asyncFlatMap(
+      l.build(deps),
+      ({ service, release }) => asyncSucceed({ service: f(service), release })
+    )
+  };
+}
+function buildLayer(l, deps) {
+  const scope = makeLayerScope();
+  return asyncFold(
+    scope.get(l, deps),
+    (error) => asyncFlatMap(scope.close(), () => asyncFail(error)),
+    (service) => asyncSucceed({
+      service,
+      scope,
+      close: scope.close,
+      use: (body) => body(service)
+    })
+  );
+}
+function provideLayer(l, use, deps) {
+  return asyncFlatMap(
+    buildLayer(l, deps ?? {}),
+    ({ service, close }) => ensuring(
+      use(service),
+      () => close()
+    )
+  );
+}
+function provideLayerContext(l, use, deps = LayerContext.empty()) {
+  return provideLayer(l, use, deps);
+}
+var provide = provideLayer;
+var provideContext = provideLayerContext;
+var Layer = Object.freeze({
+  make: layer,
+  from: layerFrom,
+  succeed: layerSucceed,
+  fail: layerFail,
+  value: layerValue,
+  test: makeTestLayer,
+  tests: makeTestLayers,
+  effect: layerEffect,
+  define: defineLayer,
+  fromContext: layerFromContext,
+  compose,
+  composeAll,
+  merge,
+  all: mergeAll,
+  mergeAll,
+  map: mapLayer,
+  provide: provideLayer,
+  provideContext: provideLayerContext,
+  build: buildLayer,
+  scope: makeLayerScope,
+  context: LayerContext.empty,
+  tag: makeServiceTag,
+  service: getService,
+  services: getServices,
+  use: useService,
+  useAll: useServices
+});
+
 export {
   sleep,
   timeout,
   retry,
   retryN,
   retryWithBackoff,
+  bracket,
+  ensuring,
+  resource,
+  makeResource,
+  resourceSucceed,
+  resourceFromManaged,
+  useResource,
+  resourceAll,
+  Resource,
+  managed,
+  useManaged,
+  managedAll,
   recurs,
   forever,
   never,
@@ -679,5 +1199,37 @@ export {
   repeatWithSchedule,
   repeat,
   poll,
-  Schedule
+  Schedule,
+  MissingLayerServiceError,
+  formatLayerError,
+  makeServiceTag,
+  serviceTag,
+  defineService,
+  LayerContext,
+  makeLayerScope,
+  layer,
+  layerValue,
+  makeTestLayer,
+  makeTestLayers,
+  layerEffect,
+  layerFromContext,
+  defineLayer,
+  getService,
+  getServices,
+  useService,
+  useServices,
+  layerFrom,
+  layerSucceed,
+  layerFail,
+  compose,
+  composeAll,
+  merge,
+  mergeAll,
+  mapLayer,
+  buildLayer,
+  provideLayer,
+  provideLayerContext,
+  provide,
+  provideContext,
+  Layer
 };