brass-runtime 1.17.0 → 1.18.1

package/dist/{chunk-AGR5B2BC.cjs → chunk-5RZ7YITF.cjs}

@@ -1,8 +1,13 @@
-"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; }
+"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 _chunk2JHJ4YHScjs = require('./chunk-2JHJ4YHS.cjs');
+
 
 
 
-var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
 
 
 
@@ -15,14 +20,14 @@ var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
 // src/core/runtime/combinators.ts
 function sleep(ms) {
   return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-    const clock = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, env);
+    const clock = _chunk2JHJ4YHScjs.runtimeClockFromEnv.call(void 0, env);
     const id = clock.setTimeout(() => cb({ _tag: "Success", value: void 0 }), ms);
     return () => clock.clearTimeout(id);
   });
 }
 function timeout(effect, ms) {
   return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-    const clock = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, env);
+    const clock = _chunk2JHJ4YHScjs.runtimeClockFromEnv.call(void 0, env);
     let done = false;
     let timerId;
     let fiber;
@@ -35,7 +40,7 @@ function timeout(effect, ms) {
         cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
       });
     }, ms);
-    const runtime = _chunkGLE2WY7Zcjs.unsafeGetCurrentRuntime.call(void 0, );
+    const runtime = _chunk2JHJ4YHScjs.unsafeGetCurrentRuntime.call(void 0, );
     fiber = runtime.fork(effect);
     fiber.join((exit) => {
       if (done) return;
@@ -77,7 +82,7 @@ function retry(effect, policy) {
   );
   return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
     { _tag: "Sync", thunk: (env) => {
-      const clock = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, env);
+      const clock = _chunk2JHJ4YHScjs.runtimeClockFromEnv.call(void 0, env);
       return { clock, startedAt: clock.now() };
     } },
     ({ clock, startedAt }) => loop(0, startedAt, clock)
@@ -102,6 +107,174 @@ function retryWithBackoff(effect, opts = {}) {
   });
 }
 
+// src/core/runtime/resource.ts
+function bracket(acquire, use, release) {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunk2JHJ4YHScjs.unsafeGetCurrentRuntime.call(void 0, );
+    const scope = new (0, _chunk2JHJ4YHScjs.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(_chunkMVGUEJ5Zcjs.Exit.failCause(_chunkMVGUEJ5Zcjs.Cause.interrupt()));
+    };
+  });
+}
+function safeRelease(release, resource2, exit) {
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    (() => {
+      try {
+        return release(resource2, exit);
+      } catch (e) {
+        return _chunkMVGUEJ5Zcjs.unit.call(void 0, );
+      }
+    })(),
+    () => _chunkMVGUEJ5Zcjs.unit.call(void 0, ),
+    () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+  );
+}
+function ensuring(effect, finalizer) {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunk2JHJ4YHScjs.unsafeGetCurrentRuntime.call(void 0, );
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      const fin = _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+        (() => {
+          try {
+            return finalizer(exit);
+          } catch (e2) {
+            return _chunkMVGUEJ5Zcjs.unit.call(void 0, );
+          }
+        })(),
+        () => _chunkMVGUEJ5Zcjs.unit.call(void 0, ),
+        () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+      );
+      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 = _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunk2JHJ4YHScjs.unsafeGetCurrentRuntime.call(void 0, );
+    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 _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
+      const runtime = _chunk2JHJ4YHScjs.unsafeGetCurrentRuntime.call(void 0, );
+      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 = _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+          m.release(resources[i], exit),
+          () => _chunkMVGUEJ5Zcjs.unit.call(void 0, ),
+          () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+        );
+        runtime.fork(releaseEff).join(() => resolve());
+      });
+    } catch (e3) {
+    }
+  }
+}
+
 // src/core/runtime/schedule.ts
 function recurs(n) {
   return {
@@ -420,7 +593,7 @@ function union(left, right) {
   };
 }
 function makeScheduleDriver(schedule, options = {}) {
-  const clock = _nullishCoalesce(options.clock, () => ( _chunkGLE2WY7Zcjs.liveClock));
+  const clock = _nullishCoalesce(options.clock, () => ( _chunk2JHJ4YHScjs.liveClock));
   let startedAtMs = _nullishCoalesce(options.startedAtMs, () => ( clock.now()));
   let attempt = 0;
   let lastDecision;
@@ -488,7 +661,7 @@ function runSchedule(schedule, inputs, options = {}) {
 function driverFromRuntime(schedule, options = {}) {
   return _chunkMVGUEJ5Zcjs.Async.sync((env) => makeScheduleDriver(schedule, {
     ...options,
-    clock: _nullishCoalesce(options.clock, () => ( _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, env)))
+    clock: _nullishCoalesce(options.clock, () => ( _chunk2JHJ4YHScjs.runtimeClockFromEnv.call(void 0, env)))
   }));
 }
 function retryWithSchedule(effect, schedule, options = {}) {
@@ -546,7 +719,7 @@ function normalizeCap(ms) {
   return normalizeDelay(ms);
 }
 function defaultClock() {
-  return _chunkGLE2WY7Zcjs.liveClock.now();
+  return _chunk2JHJ4YHScjs.liveClock.now();
 }
 function nowFromContext(context) {
   return _nullishCoalesce(_optionalChain([context, 'optionalAccess', _4 => _4.clock, 'access', _5 => _5.now, 'call', _6 => _6()]), () => ( defaultClock()));
@@ -578,7 +751,7 @@ function wallClockNow() {
 function safeObserve(observer, event) {
   try {
     observer(event);
-  } catch (e) {
+  } catch (e4) {
   }
 }
 function observeDriverDecision(event, options) {
@@ -596,7 +769,7 @@ function observeDriverDecision(event, options) {
       ...options.captureInput ? { input: event.input } : {},
       ...options.captureOutput ? { output: event.output } : {}
     }, _nullishCoalesce(options.emitContext, () => ( {})));
-  } catch (e2) {
+  } catch (e5) {
   }
 }
 var Schedule = Object.freeze({
@@ -636,6 +809,385 @@ var Schedule = Object.freeze({
   poll: repeatWithSchedule
 });
 
+// src/core/runtime/layer.ts
+var MissingLayerServiceError = (_class = class extends Error {
+  __init() {this._tag = "MissingLayerService"}
+  
+  constructor(serviceName) {
+    super(`Missing layer service '${serviceName}'. Add a layer that provides this ServiceTag or pass a LayerContext containing it.`);_class.prototype.__init.call(this);;
+    this.name = "MissingLayerServiceError";
+    this.serviceName = serviceName;
+  }
+}, _class);
+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 {
+  
+  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 _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, new Error("LayerScope is closed"));
+      if (cache.has(l)) return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, cache.get(l));
+      const built = l.buildScoped ? l.buildScoped(deps, scope) : _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        l.build(deps),
+        ({ service, release }) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, scope.addFinalizer(release), () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, service))
+      );
+      return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        built,
+        (service) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+          cache.set(l, service);
+          return service;
+        })
+      );
+    },
+    close: () => {
+      if (closed) return _chunkMVGUEJ5Zcjs.unit.call(void 0, );
+      closed = true;
+      return releaseAll(finalizers);
+    },
+    size: () => finalizers.length,
+    addFinalizer: (release) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+      if (!closed) finalizers.push(release);
+    })
+  };
+  return scope;
+}
+function releaseAll(finalizers) {
+  const next = finalizers.pop();
+  if (!next) return _chunkMVGUEJ5Zcjs.unit.call(void 0, );
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    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) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, acquire(), (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+      service,
+      release: release ? () => release(service) : () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+    }))
+  };
+}
+function layerValue(tag, value) {
+  return layerEffect(tag, () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value));
+}
+var makeTestLayer = layerValue;
+function makeTestLayers(...providers) {
+  return {
+    _tag: "Layer",
+    build: (deps = LayerContext.empty()) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+      service: providers.reduce(
+        (context, [tag, service]) => context.add(tag, service),
+        deps
+      ),
+      release: () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+    })
+  };
+}
+function layerEffect(tag, acquire, release) {
+  return {
+    _tag: "Layer",
+    build: (deps = LayerContext.empty()) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, acquire(deps), (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+      service: deps.add(tag, service),
+      release: release ? () => release(service) : () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+    }))
+  };
+}
+var layerFromContext = layerEffect;
+var defineLayer = layerEffect;
+function getService(tag) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, (context) => context.unsafeGet(tag));
+}
+function getServices(tags) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, (context) => readServices(context, tags));
+}
+function useService(tag, use) {
+  return (context) => {
+    let service;
+    try {
+      service = context.unsafeGet(tag);
+    } catch (error) {
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
+    }
+    return use(service);
+  };
+}
+function useServices(tags, use) {
+  return (context) => {
+    let services;
+    try {
+      services = readServices(context, tags);
+    } catch (error) {
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, 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) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, acquire(deps), (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+      service,
+      release: release ? () => release(service) : () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+    }))
+  });
+}
+function layerSucceed(value) {
+  return {
+    _tag: "Layer",
+    build: () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, { service: value, release: () => _chunkMVGUEJ5Zcjs.unit.call(void 0, ) })
+  };
+}
+function layerFail(error) {
+  return {
+    _tag: "Layer",
+    build: () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)
+  };
+}
+function compose(from, to) {
+  return {
+    _tag: "Layer",
+    buildScoped: (deps, scope) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      scope.get(from, deps),
+      (mid) => scope.get(to, mid)
+    ),
+    build: (deps) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      from.build(deps),
+      ({ service: mid, release: releaseMid }) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+        to.build(mid),
+        (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, releaseMid(), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+        ({ service: out, release: releaseOut }) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+          service: out,
+          release: () => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 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) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      scope.get(left, deps),
+      (a) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        scope.get(right, deps),
+        (b) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, mergeServices(a, b))
+      )
+    ),
+    build: (deps) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      left.build(deps),
+      ({ service: a, release: releaseA }) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+        right.build(deps),
+        (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, releaseA(), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+        ({ service: b, release: releaseB }) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+          service: mergeServices(a, b),
+          release: () => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 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) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      scope.get(l, deps),
+      (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, f(service))
+    ),
+    build: (deps) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      l.build(deps),
+      ({ service, release }) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, { service: f(service), release })
+    )
+  };
+}
+function buildLayer(l, deps) {
+  const scope = makeLayerScope();
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    scope.get(l, deps),
+    (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, scope.close(), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+    (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+      service,
+      scope,
+      close: scope.close,
+      use: (body) => body(service)
+    })
+  );
+}
+function provideLayer(l, use, deps) {
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+    buildLayer(l, _nullishCoalesce(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
+});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -680,4 +1232,4 @@ var Schedule = Object.freeze({
 
 
 
-exports.sleep = sleep; exports.timeout = timeout; exports.retry = retry; exports.retryN = retryN; exports.retryWithBackoff = retryWithBackoff; exports.recurs = recurs; exports.forever = forever; exports.never = never; exports.once = once; exports.fixed = fixed; exports.spaced = spaced; exports.exponential = exponential; exports.linear = linear; exports.fibonacci = fibonacci; exports.jittered = jittered; exports.elapsed = elapsed; exports.whileInput = whileInput; exports.untilInput = untilInput; exports.take = take; exports.map = map; exports.contramap = contramap; exports.jitteredSchedule = jitteredSchedule; exports.jitter = jitter; exports.windowed = windowed; exports.maxDelay = maxDelay; exports.maxElapsed = maxElapsed; exports.upTo = upTo; exports.whileOutput = whileOutput; exports.untilOutput = untilOutput; exports.named = named; exports.tapDecision = tapDecision; exports.andThen = andThen; exports.intersect = intersect; exports.union = union; exports.makeScheduleDriver = makeScheduleDriver; exports.scheduleDriver = scheduleDriver; exports.runSchedule = runSchedule; exports.retryWithSchedule = retryWithSchedule; exports.retry2 = retry2; exports.repeatWithSchedule = repeatWithSchedule; exports.repeat = repeat; exports.poll = poll; exports.Schedule = Schedule;
+exports.sleep = sleep; exports.timeout = timeout; exports.retry = retry; exports.retryN = retryN; exports.retryWithBackoff = retryWithBackoff; exports.bracket = bracket; exports.ensuring = ensuring; exports.resource = resource; exports.makeResource = makeResource; exports.resourceSucceed = resourceSucceed; exports.resourceFromManaged = resourceFromManaged; exports.useResource = useResource; exports.resourceAll = resourceAll; exports.Resource = Resource; exports.managed = managed; exports.useManaged = useManaged; exports.managedAll = managedAll; exports.recurs = recurs; exports.forever = forever; exports.never = never; exports.once = once; exports.fixed = fixed; exports.spaced = spaced; exports.exponential = exponential; exports.linear = linear; exports.fibonacci = fibonacci; exports.jittered = jittered; exports.elapsed = elapsed; exports.whileInput = whileInput; exports.untilInput = untilInput; exports.take = take; exports.map = map; exports.contramap = contramap; exports.jitteredSchedule = jitteredSchedule; exports.jitter = jitter; exports.windowed = windowed; exports.maxDelay = maxDelay; exports.maxElapsed = maxElapsed; exports.upTo = upTo; exports.whileOutput = whileOutput; exports.untilOutput = untilOutput; exports.named = named; exports.tapDecision = tapDecision; exports.andThen = andThen; exports.intersect = intersect; exports.union = union; exports.makeScheduleDriver = makeScheduleDriver; exports.scheduleDriver = scheduleDriver; exports.runSchedule = runSchedule; exports.retryWithSchedule = retryWithSchedule; exports.retry2 = retry2; exports.repeatWithSchedule = repeatWithSchedule; exports.repeat = repeat; exports.poll = poll; exports.Schedule = Schedule; exports.MissingLayerServiceError = MissingLayerServiceError; exports.formatLayerError = formatLayerError; exports.makeServiceTag = makeServiceTag; exports.serviceTag = serviceTag; exports.defineService = defineService; exports.LayerContext = LayerContext; exports.makeLayerScope = makeLayerScope; exports.layer = layer; exports.layerValue = layerValue; exports.makeTestLayer = makeTestLayer; exports.makeTestLayers = makeTestLayers; exports.layerEffect = layerEffect; exports.layerFromContext = layerFromContext; exports.defineLayer = defineLayer; exports.getService = getService; exports.getServices = getServices; exports.useService = useService; exports.useServices = useServices; exports.layerFrom = layerFrom; exports.layerSucceed = layerSucceed; exports.layerFail = layerFail; exports.compose = compose; exports.composeAll = composeAll; exports.merge = merge; exports.mergeAll = mergeAll; exports.mapLayer = mapLayer; exports.buildLayer = buildLayer; exports.provideLayer = provideLayer; exports.provideLayerContext = provideLayerContext; exports.provide = provide; exports.provideContext = provideContext; exports.Layer = Layer;