@orieljs/framework 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1036 @@
+import {
+  Application,
+  ClassRegistry,
+  ConfigRepository,
+  Container,
+  ExceptionCallbacks,
+  HttpKernel,
+  MiddlewareCallbacks,
+  RoutingPaths
+} from "./chunk-P64C7IEP.js";
+
+// ../Container/dist/index.js
+import { AsyncLocalStorage } from "async_hooks";
+function describe(abstract) {
+  return typeof abstract === "function" ? abstract.name || "<anonymous class>" : abstract.description;
+}
+var BindingResolutionError = class extends Error {
+  kind = "BindingResolution";
+  name = "BindingResolutionError";
+};
+var CircularDependencyError = class extends Error {
+  constructor(chain) {
+    super(`Circular dependency detected: ${chain.join(" -> ")}`);
+    this.chain = chain;
+  }
+  chain;
+  kind = "CircularDependency";
+  name = "CircularDependencyError";
+};
+var ContainerNotAvailableError = class extends Error {
+  kind = "ContainerNotAvailable";
+  name = "ContainerNotAvailableError";
+  constructor(what) {
+    super(
+      `Cannot resolve [${what}]: no container is available. inject(), helpers and facades only work while the application is running (inside a request, job, command, provider or app.run()). Don't call them at module top level.`
+    );
+  }
+};
+var ALS_KEY = /* @__PURE__ */ Symbol.for("oriel:container.als");
+var GLOBAL_KEY = /* @__PURE__ */ Symbol.for("oriel:container.instance");
+var BUILDING_KEY = /* @__PURE__ */ Symbol.for("oriel:container.building");
+var g = globalThis;
+var storage = g[ALS_KEY] ??= new AsyncLocalStorage();
+var building = g[BUILDING_KEY] ??= {
+  keys: [],
+  names: [],
+  containers: []
+};
+function currentContainer() {
+  return building.containers.at(-1) ?? storage.getStore() ?? g[GLOBAL_KEY];
+}
+function inject(abstract) {
+  const container = currentContainer();
+  if (!container) throw new ContainerNotAvailableError(describe(abstract));
+  return container.make(abstract);
+}
+var globals = globalThis;
+var keyOf = (abstract) => typeof abstract === "function" ? abstract : abstract.id;
+var isClass = (fn) => typeof fn === "function" && /^class[\s{]/.test(Function.prototype.toString.call(fn));
+var Container2 = class _Container {
+  static getInstance() {
+    return globals[GLOBAL_KEY];
+  }
+  static setInstance(container) {
+    globals[GLOBAL_KEY] = container;
+  }
+  shared;
+  root;
+  parent;
+  local = /* @__PURE__ */ new Map();
+  constructor(parent) {
+    this.parent = parent;
+    this.root = parent?.root ?? this;
+    this.shared = parent?.shared ?? { bindings: /* @__PURE__ */ new Map(), extenders: /* @__PURE__ */ new Map(), resolving: /* @__PURE__ */ new Map(), resolved: /* @__PURE__ */ new Set() };
+    this.local.set(keyOf(Container), this);
+    this.local.set(_Container, this);
+  }
+  bind(abstract, concrete) {
+    this.#assertRoot("bind");
+    this.#addBinding(abstract, concrete, "transient");
+  }
+  singleton(abstract, concrete) {
+    this.#assertRoot("singleton");
+    this.#addBinding(abstract, concrete, "singleton");
+  }
+  scoped(abstract, concrete) {
+    this.#assertRoot("scoped");
+    this.#addBinding(abstract, concrete, "scoped");
+  }
+  instance(abstract, instance) {
+    const key = keyOf(abstract);
+    this.local.set(key, instance);
+    if (this === this.root) this.shared.resolved.add(key);
+    return instance;
+  }
+  make(abstract) {
+    const key = keyOf(abstract);
+    const owner = this.#owning(key);
+    if (owner) return owner.local.get(key);
+    const binding = this.shared.bindings.get(key) ?? this.#implicitBinding(abstract);
+    if (binding.lifetime === "scoped" && this === this.root) {
+      throw new BindingResolutionError(
+        `Scoped binding [${describe(abstract)}] was resolved outside a scope. Resolve it inside app.createScope().run(...), and don't inject scoped services into singletons.`
+      );
+    }
+    const builder = binding.lifetime === "singleton" ? this.root : this;
+    const instance = builder.build(abstract, key, binding);
+    if (binding.lifetime === "singleton") this.root.local.set(key, instance);
+    if (binding.lifetime === "scoped") this.local.set(key, instance);
+    return instance;
+  }
+  bound(abstract) {
+    const key = keyOf(abstract);
+    return this.shared.bindings.has(key) || this.#owning(key) !== void 0;
+  }
+  resolved(abstract) {
+    const key = keyOf(abstract);
+    return this.shared.resolved.has(key) || this.#owning(key) !== void 0;
+  }
+  extend(abstract, extender) {
+    this.#assertRoot("extend");
+    const key = keyOf(abstract);
+    const list = this.shared.extenders.get(key) ?? [];
+    list.push(extender);
+    this.shared.extenders.set(key, list);
+    if (this.local.has(key)) this.local.set(key, extender(this.local.get(key), this));
+  }
+  resolving(abstract, callback) {
+    this.#assertRoot("resolving");
+    const key = keyOf(abstract);
+    const list = this.shared.resolving.get(key) ?? [];
+    list.push(callback);
+    this.shared.resolving.set(key, list);
+  }
+  forgetInstance(abstract) {
+    this.local.delete(keyOf(abstract));
+  }
+  /** Scopes are always plain Containers (never subclasses such as Application). */
+  createScope() {
+    return new _Container(this);
+  }
+  run(fn) {
+    return storage.run(this, fn);
+  }
+  /** The nearest container in this -> parent scopes -> root that holds an instance for the key. */
+  #owning(key) {
+    if (this.local.has(key)) return this;
+    return this.parent === void 0 ? void 0 : this.parent.#owning(key);
+  }
+  /** Bindings, extenders and callbacks are app-wide state: a request scope must never write them. */
+  #assertRoot(method) {
+    if (this !== this.root) {
+      throw new Error(
+        `Cannot register bindings on a request scope (${method}). Register them on the application in a service provider; use instance() for per-request values.`
+      );
+    }
+  }
+  #addBinding(abstract, concrete, lifetime) {
+    const key = keyOf(abstract);
+    let factory;
+    if (concrete === void 0) {
+      if (typeof abstract !== "function") throw new TypeError(`bind(${describe(abstract)}) needs a concrete: tokens can't be constructed`);
+      factory = () => new abstract();
+    } else if (isClass(concrete)) {
+      factory = () => new concrete();
+    } else {
+      factory = concrete;
+    }
+    this.shared.bindings.set(key, { lifetime, factory });
+    this.local.delete(key);
+  }
+  #implicitBinding(abstract) {
+    if (typeof abstract === "function") {
+      return { lifetime: "transient", factory: () => new abstract() };
+    }
+    throw new BindingResolutionError(
+      `Target [${abstract.description}] is not bound. Is its service provider registered in bootstrap/providers.ts?`
+    );
+  }
+  build(abstract, key, binding) {
+    const stackIndex = building.keys.indexOf(key);
+    if (stackIndex !== -1) {
+      const chain = [...building.names.slice(stackIndex), describe(abstract)];
+      throw new CircularDependencyError(chain);
+    }
+    building.keys.push(key);
+    building.names.push(describe(abstract));
+    building.containers.push(this);
+    try {
+      let instance = binding.factory(this);
+      for (const extender of this.shared.extenders.get(key) ?? []) instance = extender(instance, this);
+      for (const callback of this.shared.resolving.get(key) ?? []) callback(instance, this);
+      this.shared.resolved.add(key);
+      return instance;
+    } finally {
+      building.keys.pop();
+      building.names.pop();
+      building.containers.pop();
+    }
+  }
+};
+
+// ../Collections/dist/index.js
+function compare(left, operator, right) {
+  switch (operator) {
+    case "=":
+    case "==":
+      return left == right;
+    case "===":
+      return left === right;
+    case "!=":
+    case "<>":
+      return left != right;
+    case "!==":
+      return left !== right;
+    case "<":
+      return left < right;
+    case "<=":
+      return left <= right;
+    case ">":
+      return left > right;
+    case ">=":
+      return left >= right;
+  }
+}
+function ascending(a, b) {
+  const aNil = a === null || a === void 0;
+  const bNil = b === null || b === void 0;
+  if (aNil || bNil) return aNil === bNil ? 0 : aNil ? 1 : -1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+  return String(a).localeCompare(String(b));
+}
+var read = (item, getter) => typeof getter === "function" ? getter(item) : item?.[getter];
+var isArrayable = (v) => typeof v === "object" && v !== null && typeof v.toArray === "function";
+var numbers = (items, getter) => items.map((item) => getter === void 0 ? item : read(item, getter)).filter((v) => typeof v === "number" && !Number.isNaN(v));
+var Collection = class _Collection {
+  items;
+  constructor(items = []) {
+    this.items = [...items];
+  }
+  static make(items = []) {
+    return new _Collection(items);
+  }
+  /** Laravel semantics: callback receives 1..n. */
+  static times(count, callback) {
+    return new _Collection(Array.from({ length: Math.max(0, count) }, (_, i) => callback(i + 1)));
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  all() {
+    return [...this.items];
+  }
+  count() {
+    return this.items.length;
+  }
+  isEmpty() {
+    return this.items.length === 0;
+  }
+  isNotEmpty() {
+    return this.items.length > 0;
+  }
+  toArray() {
+    return this.items.map((i) => isArrayable(i) ? i.toArray() : i);
+  }
+  toJSON() {
+    return this.all();
+  }
+  toJson() {
+    return JSON.stringify(this);
+  }
+  map(callback) {
+    return new _Collection(this.items.map(callback));
+  }
+  flatMap(callback) {
+    return new _Collection(
+      this.items.flatMap((item, i) => {
+        const out = callback(item, i);
+        return out instanceof _Collection ? out.all() : out;
+      })
+    );
+  }
+  filter(callback) {
+    return new _Collection(this.items.filter(callback ?? ((item) => Boolean(item))));
+  }
+  reject(callback) {
+    return new _Collection(this.items.filter((item, i) => !callback(item, i)));
+  }
+  /** Return false from the callback to stop. */
+  each(callback) {
+    for (let i = 0; i < this.items.length; i++) if (callback(this.items[i], i) === false) break;
+    return this;
+  }
+  reduce(callback, initial) {
+    return this.items.reduce(callback, initial);
+  }
+  first(callback, defaultValue) {
+    if (!callback) return this.items[0];
+    const index = this.items.findIndex(callback);
+    return index === -1 ? defaultValue : this.items[index];
+  }
+  last(callback, defaultValue) {
+    if (!callback) return this.items.at(-1);
+    const index = this.items.findLastIndex(callback);
+    return index === -1 ? defaultValue : this.items[index];
+  }
+  where(key, operatorOrValue, value2) {
+    const [op, expected] = arguments.length === 2 ? ["=", operatorOrValue] : [operatorOrValue, value2];
+    return this.filter((item) => compare(read(item, key), op, expected));
+  }
+  firstWhere(key, operatorOrValue, value2) {
+    const [op, expected] = arguments.length === 2 ? ["=", operatorOrValue] : [operatorOrValue, value2];
+    return this.items.find((item) => compare(read(item, key), op, expected));
+  }
+  whereIn(key, values) {
+    const set = new Set(values);
+    return this.filter((item) => set.has(read(item, key)));
+  }
+  whereNotIn(key, values) {
+    const set = new Set(values);
+    return this.filter((item) => !set.has(read(item, key)));
+  }
+  pluck(key) {
+    return this.map((item) => read(item, key));
+  }
+  keyBy(key) {
+    return Object.fromEntries(this.items.map((item) => [String(read(item, key)), item]));
+  }
+  groupBy(key) {
+    const groups = {};
+    for (const item of this.items) (groups[String(read(item, key))] ??= new _Collection()).push(item);
+    return groups;
+  }
+  mapWithKeys(callback) {
+    return Object.fromEntries(this.items.map(callback));
+  }
+  sortBy(key, direction = "asc") {
+    const sign = direction === "asc" ? 1 : -1;
+    return new _Collection(
+      this.items.map((item, index) => ({ item, index, value: read(item, key) })).sort((a, b) => {
+        const aNil = a.value === null || a.value === void 0;
+        const bNil = b.value === null || b.value === void 0;
+        if (aNil || bNil) return aNil === bNil ? a.index - b.index : aNil ? 1 : -1;
+        return sign * ascending(a.value, b.value) || a.index - b.index;
+      }).map((x) => x.item)
+    );
+  }
+  sortByDesc(key) {
+    return this.sortBy(key, "desc");
+  }
+  sum(key) {
+    return numbers(this.items, key).reduce((a, b) => a + b, 0);
+  }
+  avg(key) {
+    const values = numbers(this.items, key);
+    return values.length ? values.reduce((a, b) => a + b, 0) / values.length : void 0;
+  }
+  min(key) {
+    const values = numbers(this.items, key);
+    return values.length ? Math.min(...values) : void 0;
+  }
+  max(key) {
+    const values = numbers(this.items, key);
+    return values.length ? Math.max(...values) : void 0;
+  }
+  unique(key) {
+    const seen = /* @__PURE__ */ new Set();
+    return this.filter((item) => {
+      const v = key === void 0 ? item : read(item, key);
+      if (seen.has(v)) return false;
+      seen.add(v);
+      return true;
+    });
+  }
+  chunk(size) {
+    if (size <= 0) return new _Collection();
+    const chunks = [];
+    for (let i = 0; i < this.items.length; i += size) chunks.push(new _Collection(this.items.slice(i, i + size)));
+    return new _Collection(chunks);
+  }
+  /** Negative count takes from the end. */
+  take(count) {
+    return new _Collection(count < 0 ? this.items.slice(count) : this.items.slice(0, count));
+  }
+  skip(count) {
+    return new _Collection(this.items.slice(count));
+  }
+  slice(offset, length) {
+    return new _Collection(this.items.slice(offset, length === void 0 ? void 0 : offset + length));
+  }
+  values() {
+    return new _Collection(this.items);
+  }
+  contains(keyOrValue, value2) {
+    if (arguments.length === 2) return this.items.some((item) => read(item, keyOrValue) === value2);
+    if (typeof keyOrValue === "function") return this.items.some(keyOrValue);
+    return this.items.includes(keyOrValue);
+  }
+  /** Mutates, like Laravel. */
+  push(...values) {
+    this.items.push(...values);
+    return this;
+  }
+  concat(values) {
+    return new _Collection([...this.items, ...values]);
+  }
+  partition(callback) {
+    return [this.filter(callback), this.reject(callback)];
+  }
+  implode(keyOrGlue, glue) {
+    if (glue === void 0) return this.items.join(keyOrGlue);
+    return this.items.map((item) => read(item, keyOrGlue)).join(glue);
+  }
+  when(condition, callback) {
+    return condition ? callback(this) : this;
+  }
+  pipe(callback) {
+    return callback(this);
+  }
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+};
+function collect(items = []) {
+  return new Collection(items);
+}
+var LazyCollection = class _LazyCollection {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  static make(source) {
+    return new _LazyCollection(source);
+  }
+  async *[Symbol.asyncIterator]() {
+    yield* this.source();
+  }
+  map(callback) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      let i = 0;
+      for await (const item of self) yield await callback(item, i++);
+    });
+  }
+  filter(callback) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      let i = 0;
+      for await (const item of self) if (await callback(item, i++)) yield item;
+    });
+  }
+  take(count) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      if (count <= 0) return;
+      let taken = 0;
+      for await (const item of self) {
+        yield item;
+        if (++taken >= count) return;
+      }
+    });
+  }
+  chunk(size) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      if (size <= 0) return;
+      let buffer = [];
+      for await (const item of self) {
+        buffer.push(item);
+        if (buffer.length === size) {
+          yield new Collection(buffer);
+          buffer = [];
+        }
+      }
+      if (buffer.length) yield new Collection(buffer);
+    });
+  }
+  /** Return false from the callback to stop. */
+  async each(callback) {
+    let i = 0;
+    for await (const item of this) if (await callback(item, i++) === false) return;
+  }
+  async first(callback) {
+    for await (const item of this) if (!callback || await callback(item)) return item;
+    return void 0;
+  }
+  async count() {
+    let n = 0;
+    for await (const item of this) {
+      void item;
+      n++;
+    }
+    return n;
+  }
+  async collect() {
+    const items = [];
+    for await (const item of this) items.push(item);
+    return new Collection(items);
+  }
+};
+
+// ../Support/dist/index.js
+import { randomBytes, randomUUID } from "crypto";
+import pluralize from "pluralize";
+import { setTimeout as sleep } from "timers/promises";
+var words = (value2) => value2.replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z\d]+/).filter(Boolean);
+var ALPHANUM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var anyOf = (needles) => (Array.isArray(needles) ? needles : [needles]).filter((n) => n !== "");
+var Str = {
+  ucfirst: (v) => v.charAt(0).toUpperCase() + v.slice(1),
+  lcfirst: (v) => v.charAt(0).toLowerCase() + v.slice(1),
+  studly: (v) => words(v).map((w) => Str.ucfirst(w.toLowerCase())).join(""),
+  camel: (v) => Str.lcfirst(Str.studly(v)),
+  snake: (v, delimiter = "_") => words(v).map((w) => w.toLowerCase()).join(delimiter),
+  kebab: (v) => Str.snake(v, "-"),
+  title: (v) => v.toLowerCase().replace(/(^|\s)\S/g, (m) => m.toUpperCase()),
+  slug: (v, separator = "-") => v.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z\d]+/g, separator).replace(new RegExp(`^${escapeRegex(separator)}+|${escapeRegex(separator)}+$`, "g"), ""),
+  plural: (v, count = 2) => pluralize(v, count),
+  singular: (v) => pluralize.singular(v),
+  random: (length = 16) => {
+    let out = "";
+    while (out.length < length) {
+      for (const byte of randomBytes(length)) {
+        if (byte < 248 && out.length < length) out += ALPHANUM[byte % 62];
+      }
+    }
+    return out;
+  },
+  uuid: () => randomUUID(),
+  /** Wildcard match: `*` matches anything; everything else is literal. */
+  is: (pattern, value2) => pattern === value2 || new RegExp(`^${pattern.split("*").map(escapeRegex).join(".*")}$`, "s").test(value2),
+  startsWith: (v, needles) => anyOf(needles).some((n) => v.startsWith(n)),
+  endsWith: (v, needles) => anyOf(needles).some((n) => v.endsWith(n)),
+  contains: (v, needles) => anyOf(needles).some((n) => v.includes(n)),
+  after: (v, search) => search === "" || !v.includes(search) ? v : v.slice(v.indexOf(search) + search.length),
+  afterLast: (v, search) => search === "" || !v.includes(search) ? v : v.slice(v.lastIndexOf(search) + search.length),
+  before: (v, search) => search === "" || !v.includes(search) ? v : v.slice(0, v.indexOf(search)),
+  beforeLast: (v, search) => search === "" || !v.includes(search) ? v : v.slice(0, v.lastIndexOf(search)),
+  between: (v, from, to) => Str.beforeLast(Str.after(v, from), to),
+  limit: (v, limit = 100, end = "...") => v.length <= limit ? v : v.slice(0, limit).trimEnd() + end,
+  start: (v, prefix) => v.startsWith(prefix) ? v : prefix + v,
+  finish: (v, cap) => v.endsWith(cap) ? v : v + cap
+};
+var FORBIDDEN = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var isWalkable = (v) => typeof v === "object" && v !== null;
+var segments = (key) => key.split(".");
+var Arr = {
+  get(target, key, defaultValue) {
+    if (key === void 0 || key === "") return target;
+    let current = target;
+    for (const segment of segments(key)) {
+      if (!isWalkable(current) || !Object.hasOwn(current, segment)) return defaultValue;
+      current = current[segment];
+    }
+    return current;
+  },
+  has(target, key) {
+    const missing = /* @__PURE__ */ Symbol("missing");
+    return Arr.get(target, key, missing) !== missing;
+  },
+  set(target, key, value2) {
+    const parts = segments(key);
+    if (parts.some((p) => FORBIDDEN.has(p))) throw new Error(`Refusing to set unsafe key "${key}"`);
+    let current = target;
+    parts.slice(0, -1).forEach((segment) => {
+      if (!isWalkable(current[segment])) current[segment] = {};
+      current = current[segment];
+    });
+    current[parts.at(-1)] = value2;
+    return target;
+  },
+  forget(target, key) {
+    const parts = segments(key);
+    const parent = parts.length === 1 ? target : Arr.get(target, parts.slice(0, -1).join("."));
+    if (isWalkable(parent)) delete parent[parts.at(-1)];
+  },
+  dot(target, prefix = "") {
+    const out = {};
+    for (const [k, v] of Object.entries(target)) {
+      const path = prefix + k;
+      if (isWalkable(v) && Object.keys(v).length > 0) Object.assign(out, Arr.dot(v, `${path}.`));
+      else out[path] = v;
+    }
+    return out;
+  },
+  undot(flat) {
+    const out = {};
+    for (const [k, v] of Object.entries(flat)) Arr.set(out, k, v);
+    return out;
+  },
+  only(target, keys) {
+    return Object.fromEntries(keys.filter((k) => Object.hasOwn(target, k)).map((k) => [k, target[k]]));
+  },
+  except(target, keys) {
+    const skip = new Set(keys);
+    return Object.fromEntries(Object.entries(target).filter(([k]) => !skip.has(k)));
+  },
+  wrap(value2) {
+    if (value2 === null || value2 === void 0) return [];
+    return Array.isArray(value2) ? value2 : [value2];
+  },
+  first(items, predicate, defaultValue) {
+    const index = predicate ? items.findIndex(predicate) : items.length > 0 ? 0 : -1;
+    return index === -1 ? defaultValue : items[index];
+  },
+  last(items, predicate, defaultValue) {
+    const index = predicate ? items.findLastIndex(predicate) : items.length - 1;
+    return index === -1 ? defaultValue : items[index];
+  }
+};
+var ServiceProvider = class {
+  constructor(app2) {
+    this.app = app2;
+  }
+  app;
+  register() {
+  }
+  boot() {
+  }
+  /** Package defaults under `key`; values the app already set win (shallow merge, like Laravel). */
+  mergeConfigFrom(defaults, key) {
+    const config2 = this.app.make(ConfigRepository);
+    config2.set(key, { ...defaults, ...config2.get(key, {}) });
+  }
+};
+function facade(abstract, extras) {
+  const container = () => {
+    const c = currentContainer();
+    if (!c) throw new ContainerNotAvailableError(describe(abstract));
+    return c;
+  };
+  const statics = {
+    getFacadeRoot: () => container().make(abstract),
+    swap: (instance) => void container().instance(abstract, instance)
+  };
+  const proxy = new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "symbol" || prop === "then") return void 0;
+      if (extras && Object.hasOwn(extras, prop)) {
+        const extra = extras[prop];
+        return typeof extra === "function" ? extra.bind(proxy) : extra;
+      }
+      if (Object.hasOwn(statics, prop)) return statics[prop];
+      const root = statics.getFacadeRoot();
+      const value2 = Reflect.get(root, prop, root);
+      return typeof value2 === "function" ? value2.bind(root) : value2;
+    }
+  });
+  return proxy;
+}
+var ClassRegistry2 = class {
+  byName = /* @__PURE__ */ new Map();
+  byClass = /* @__PURE__ */ new Map();
+  register(cls, name = cls.name) {
+    const existingName = this.byClass.get(cls);
+    if (existingName !== void 0) return existingName;
+    if (!name) throw new Error('Anonymous classes need an explicit name: registry.register(cls, "Some.Name")');
+    const existing = this.byName.get(name);
+    if (existing && existing !== cls) {
+      throw new Error(`"${name}" is already registered to a different class. Pass an explicit name: register(cls, "Module.${name}")`);
+    }
+    this.byName.set(name, cls);
+    this.byClass.set(cls, name);
+    return name;
+  }
+  nameOf(cls) {
+    return this.byClass.get(cls);
+  }
+  resolve(name) {
+    const cls = this.byName.get(name);
+    if (!cls) throw new Error(`No class registered as "${name}". Is it registered by its service provider?`);
+    return cls;
+  }
+  has(name) {
+    return this.byName.has(name);
+  }
+};
+var SCOPE_METHODS = /* @__PURE__ */ new Set(["make", "instance", "bound", "resolved", "forgetInstance", "createScope", "run"]);
+var scopedViews = /* @__PURE__ */ new WeakMap();
+function viewFrom(scope, application) {
+  let view = scopedViews.get(scope);
+  if (view === void 0) {
+    view = new Proxy(application, {
+      get(target, property) {
+        const source = SCOPE_METHODS.has(property) ? scope : target;
+        const member = Reflect.get(source, property, source);
+        return typeof member === "function" ? member.bind(source) : member;
+      }
+    });
+    scopedViews.set(scope, view);
+  }
+  return view;
+}
+function app(abstract) {
+  if (abstract !== void 0) return inject(abstract);
+  const application = inject(Application);
+  const current = currentContainer();
+  return current === void 0 || current === application ? application : viewFrom(current, application);
+}
+function config(keyOrValues, defaultValue) {
+  const repository = inject(ConfigRepository);
+  if (keyOrValues === void 0) return repository;
+  if (typeof keyOrValues === "string") return repository.get(keyOrValues, defaultValue);
+  repository.set(keyOrValues);
+  return void 0;
+}
+var now = () => /* @__PURE__ */ new Date();
+var value = (v) => typeof v === "function" ? v() : v;
+function tap(target, callback) {
+  callback(target);
+  return target;
+}
+async function retry(times, fn, sleepMs = 0, when) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      if (attempt >= times || when && !when(error)) throw error;
+      const ms = typeof sleepMs === "function" ? sleepMs(attempt) : sleepMs;
+      if (ms > 0) await sleep(ms);
+    }
+  }
+}
+
+// ../Config/dist/index.js
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { parse } from "dotenv";
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { join as join2 } from "path";
+import { pathToFileURL } from "url";
+var Repository = class {
+  constructor(items = {}) {
+    this.items = items;
+  }
+  items;
+  has(key) {
+    return Arr.has(this.items, key);
+  }
+  get(key, defaultValue) {
+    return Arr.get(this.items, key, defaultValue);
+  }
+  set(keyOrValues, value2) {
+    const entries = typeof keyOrValues === "string" ? [[keyOrValues, value2]] : Object.entries(keyOrValues);
+    for (const [k, v] of entries) Arr.set(this.items, k, v);
+  }
+  push(key, value2) {
+    const current = this.get(key, []);
+    this.set(key, [...Array.isArray(current) ? current : [current], value2]);
+  }
+  all() {
+    return this.items;
+  }
+};
+var CASTS = {
+  "true": true,
+  "(true)": true,
+  "false": false,
+  "(false)": false,
+  "null": null,
+  "(null)": null,
+  "empty": "",
+  "(empty)": ""
+};
+function env(key, defaultValue) {
+  const raw = process.env[key];
+  if (raw === void 0) return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  const lower = raw.toLowerCase();
+  if (Object.hasOwn(CASTS, lower)) return CASTS[lower];
+  const quoted = /^(["'])(.*)\1$/s.exec(raw);
+  return quoted ? quoted[2] : raw;
+}
+function loadEnvironment(basePath) {
+  const appEnv = process.env.APP_ENV;
+  const specific = appEnv ? join(basePath, `.env.${appEnv}`) : void 0;
+  const file = specific && existsSync(specific) ? specific : join(basePath, ".env");
+  if (!existsSync(file)) return void 0;
+  for (const [key, value2] of Object.entries(parse(readFileSync(file)))) {
+    if (process.env[key] === void 0) process.env[key] = value2;
+  }
+  return file;
+}
+var CONFIG_FILE = /^(?!.*\.d\.ts$)([A-Za-z0-9_-]+)\.(ts|js|mjs)$/;
+async function loadConfiguration(configPath) {
+  if (!existsSync2(configPath)) return {};
+  const files = readdirSync(configPath).filter((f) => CONFIG_FILE.test(f)).sort();
+  const config2 = {};
+  for (const file of files) {
+    const name = CONFIG_FILE.exec(file)[1];
+    const mod = await import(pathToFileURL(join2(configPath, file)).href);
+    config2[name] = mod.default ?? {};
+  }
+  return config2;
+}
+
+// ../Foundation/dist/index.js
+import { join as join22 } from "path";
+import { isAbsolute, join as join3 } from "path";
+var ApplicationBuilder = class {
+  constructor(app2) {
+    this.app = app2;
+  }
+  app;
+  providers = [];
+  middleware = [];
+  exceptions = [];
+  routing;
+  withProviders(providers = []) {
+    this.providers.push(...providers);
+    return this;
+  }
+  withRouting(options) {
+    const abs = (p) => p === void 0 ? void 0 : isAbsolute(p) ? p : join3(this.app.basePath(), p);
+    const paths = { apiPrefix: options.apiPrefix ?? "api" };
+    if (options.web !== void 0) paths.web = abs(options.web);
+    if (options.api !== void 0) paths.api = abs(options.api);
+    if (options.console !== void 0) paths.console = abs(options.console);
+    if (options.health !== void 0) paths.health = options.health;
+    this.routing = paths;
+    return this;
+  }
+  withMiddleware(callback) {
+    this.middleware.push(callback);
+    return this;
+  }
+  withExceptions(callback) {
+    this.exceptions.push(callback);
+    return this;
+  }
+  booting(callback) {
+    this.app.booting(callback);
+    return this;
+  }
+  booted(callback) {
+    this.app.booted(callback);
+    return this;
+  }
+  async create() {
+    loadEnvironment(this.app.basePath());
+    this.app.instance(ConfigRepository, new Repository(await loadConfiguration(this.app.configPath())));
+    if (this.routing) this.app.instance(RoutingPaths, this.routing);
+    this.app.instance(MiddlewareCallbacks, this.middleware);
+    this.app.instance(ExceptionCallbacks, this.exceptions);
+    for (const provider of this.providers) await this.app.register(provider);
+    return this.app;
+  }
+};
+var ProviderBootError = class extends Error {
+  constructor(provider, cause) {
+    super(`Service provider [${provider}] failed to boot: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.provider = provider;
+  }
+  provider;
+  name = "ProviderBootError";
+};
+var ProviderRegisterError = class extends Error {
+  constructor(provider, cause) {
+    super(`Service provider [${provider}] failed to register: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.provider = provider;
+  }
+  provider;
+  name = "ProviderRegisterError";
+};
+var Application2 = class _Application extends Container2 {
+  constructor(base) {
+    super();
+    this.base = base;
+    Container2.setInstance(this);
+    this.instance(Application, this);
+    this.instance(_Application, this);
+    this.singleton(ClassRegistry, ClassRegistry2);
+  }
+  base;
+  version = "0.0.0";
+  providers = [];
+  bootingCallbacks = [];
+  bootedCallbacks = [];
+  terminatingCallbacks = [];
+  bootPromise;
+  hasBooted = false;
+  inConsole = false;
+  /** Entry point used by bootstrap/app.ts. */
+  static configure(options) {
+    return new ApplicationBuilder(new _Application(options.basePath));
+  }
+  basePath(path = "") {
+    return join22(this.base, path);
+  }
+  appPath(path = "") {
+    return this.basePath(join22("app", path));
+  }
+  bootstrapPath(path = "") {
+    return this.basePath(join22("bootstrap", path));
+  }
+  configPath(path = "") {
+    return this.basePath(join22("config", path));
+  }
+  databasePath(path = "") {
+    return this.basePath(join22("database", path));
+  }
+  publicPath(path = "") {
+    return this.basePath(join22("public", path));
+  }
+  resourcePath(path = "") {
+    return this.basePath(join22("resources", path));
+  }
+  storagePath(path = "") {
+    return this.basePath(join22("storage", path));
+  }
+  environment(...environments) {
+    const fallback = process.env.APP_ENV ?? "production";
+    const current = this.bound(ConfigRepository) ? String(this.make(ConfigRepository).get("app.env", fallback)) : fallback;
+    return environments.length === 0 ? current : environments.some((pattern) => Str.is(pattern, current));
+  }
+  isProduction() {
+    return this.environment("production");
+  }
+  isLocal() {
+    return this.environment("local");
+  }
+  runningUnitTests() {
+    return this.environment("testing");
+  }
+  runningInConsole() {
+    return this.inConsole;
+  }
+  setRunningInConsole(value2 = true) {
+    this.inConsole = value2;
+  }
+  async register(provider) {
+    const cls = typeof provider === "function" ? provider : provider.constructor;
+    const existing = this.providers.find((p) => p.constructor === cls);
+    if (existing) return existing;
+    const instance = typeof provider === "function" ? new provider(this) : provider;
+    try {
+      instance.register?.();
+    } catch (error) {
+      throw new ProviderRegisterError(instance.constructor.name, error);
+    }
+    this.providers.push(instance);
+    if (this.hasBooted) await this.bootProvider(instance);
+    return instance;
+  }
+  getProviders() {
+    return [...this.providers];
+  }
+  boot() {
+    return this.bootPromise ??= this.runBoot();
+  }
+  isBooted() {
+    return this.hasBooted;
+  }
+  booting(callback) {
+    this.bootingCallbacks.push(callback);
+  }
+  /** If already booted, the callback runs immediately (a rejection surfaces as an unhandled rejection). */
+  booted(callback) {
+    this.bootedCallbacks.push(callback);
+    if (this.hasBooted) void callback(this);
+  }
+  terminating(callback) {
+    this.terminatingCallbacks.push(callback);
+  }
+  async handle(request) {
+    await this.boot();
+    const scope = this.createScope();
+    return scope.run(() => scope.make(HttpKernel).handle(request));
+  }
+  async terminate() {
+    for (const callback of this.terminatingCallbacks) await callback();
+  }
+  async runBoot() {
+    for (const callback of this.bootingCallbacks) await callback(this);
+    for (let i = 0; i < this.providers.length; i++) await this.bootProvider(this.providers[i]);
+    this.hasBooted = true;
+    for (const callback of this.bootedCallbacks) await callback(this);
+  }
+  async bootProvider(provider) {
+    try {
+      await provider.boot?.();
+    } catch (error) {
+      throw new ProviderBootError(provider.constructor.name, error);
+    }
+  }
+};
+var ClosureKernel = class {
+  routes = /* @__PURE__ */ new Map();
+  on(method, path, handler) {
+    this.routes.set(`${method.toUpperCase()} ${path}`, handler);
+    return this;
+  }
+  async handle(request) {
+    const handler = this.routes.get(`${request.method} ${new URL(request.url).pathname}`);
+    if (!handler) return new Response("Not Found", { status: 404, headers: { "content-type": "text/plain; charset=utf-8" } });
+    return toResponse(await handler(request));
+  }
+};
+function toResponse(output) {
+  if (output instanceof Response) return output;
+  if (output === void 0 || output === null) return new Response(null, { status: 204 });
+  if (typeof output === "string") return new Response(output, { headers: { "content-type": "text/html; charset=utf-8" } });
+  return Response.json(output);
+}
+export {
+  Application2 as Application,
+  ApplicationBuilder,
+  Arr,
+  BindingResolutionError,
+  CircularDependencyError,
+  ClassRegistry2 as ClassRegistry,
+  ClosureKernel,
+  Collection,
+  Container2 as Container,
+  ContainerNotAvailableError,
+  LazyCollection,
+  ProviderBootError,
+  ProviderRegisterError,
+  Repository,
+  ServiceProvider,
+  Str,
+  app,
+  collect,
+  config,
+  currentContainer,
+  env,
+  facade,
+  inject,
+  now,
+  retry,
+  tap,
+  value
+};
+//# sourceMappingURL=index.js.map