@palbase/backend 25.1.0 → 27.1.0

package/dist/chunk-BQN723PL.js

@@ -0,0 +1,930 @@
+import {
+  qualifiedTableKey,
+  withRetry
+} from "./chunk-OZKSM3JW.js";
+import {
+  TxPlanBuilder,
+  runTxPlan
+} from "./chunk-JVZQCC77.js";
+import {
+  __name
+} from "./chunk-VXPNPVAG.js";
+
+// src/runtime.ts
+import { AsyncLocalStorage } from "async_hooks";
+var __requestALS = new AsyncLocalStorage();
+var runtime = null;
+function __setRuntime(services) {
+  runtime = services;
+}
+__name(__setRuntime, "__setRuntime");
+function __runWithRuntime(services, fn) {
+  return __requestALS.run({
+    runtime: services
+  }, fn);
+}
+__name(__runWithRuntime, "__runWithRuntime");
+function __getRuntime() {
+  const scoped = __requestALS.getStore();
+  if (scoped) return scoped.runtime;
+  if (runtime === null) {
+    throw new Error("Palbase services accessed outside a request scope. The Database/Documents/\u2026 singletons are only available inside an endpoint handler (or after the runtime has called __runWithRuntime / __setRuntime).");
+  }
+  return runtime;
+}
+__name(__getRuntime, "__getRuntime");
+var LIFECYCLE = /* @__PURE__ */ Symbol.for("palbase.backend.lifecycleHooks");
+function declaredLifecycle() {
+  const g = globalThis;
+  return g[LIFECYCLE] ??= {
+    start: [],
+    shutdown: []
+  };
+}
+__name(declaredLifecycle, "declaredLifecycle");
+function onStart(name, hook) {
+  declaredLifecycle().start.push({
+    name,
+    run: hook
+  });
+}
+__name(onStart, "onStart");
+function onShutdown(name, hook) {
+  declaredLifecycle().shutdown.push({
+    name,
+    run: hook
+  });
+}
+__name(onShutdown, "onShutdown");
+function reason(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+__name(reason, "reason");
+async function drain(hooks) {
+  for (const h of [
+    ...hooks
+  ].reverse()) {
+    try {
+      await h.run();
+    } catch (err) {
+      console.error(`[palbase] shutdown hook "${h.name}" failed: ${reason(err)}`, err);
+    }
+  }
+}
+__name(drain, "drain");
+async function __runStartHooks() {
+  const slot3 = declaredLifecycle();
+  const start = slot3.start.splice(0);
+  const shutdown = slot3.shutdown.splice(0);
+  for (const h of start) {
+    try {
+      await h.run();
+    } catch (err) {
+      await drain(shutdown);
+      throw new Error(`[palbase] start hook "${h.name}" failed: ${reason(err)}`, {
+        cause: err
+      });
+    }
+  }
+  let drained = false;
+  return async () => {
+    if (drained) return;
+    drained = true;
+    await drain(shutdown);
+  };
+}
+__name(__runStartHooks, "__runStartHooks");
+function __resetLifecycleHooks() {
+  const g = globalThis;
+  delete g[LIFECYCLE];
+}
+__name(__resetLifecycleHooks, "__resetLifecycleHooks");
+function makeServiceProxy(key) {
+  const handler = {
+    get(_target, prop, receiver) {
+      const client = __getRuntime()[key];
+      const value = Reflect.get(client, prop, receiver);
+      return typeof value === "function" ? value.bind(client) : value;
+    }
+  };
+  return new Proxy({}, handler);
+}
+__name(makeServiceProxy, "makeServiceProxy");
+function makeTableProxy(ops, prefix) {
+  return new Proxy({}, {
+    get(_t, prop) {
+      if (typeof prop !== "string") return void 0;
+      const name = `${prefix}${prop}`;
+      return {
+        insert: /* @__PURE__ */ __name((data) => ops().insert(name, data), "insert"),
+        update: /* @__PURE__ */ __name((q) => ops().update(name, q.where.id, q.set), "update"),
+        delete: /* @__PURE__ */ __name((id) => ops().delete(name, id), "delete"),
+        findById: /* @__PURE__ */ __name((id) => ops().findById(name, id), "findById"),
+        findMany: /* @__PURE__ */ __name((q) => {
+          const { where, ...opts } = q ?? {};
+          return ops().findMany(name, where, opts);
+        }, "findMany"),
+        put: /* @__PURE__ */ __name((q) => ops().put(name, q.data, {
+          onConflict: q.onConflict
+        }), "put"),
+        // THREE VERBS THE TYPE PROMISED AND THIS PROXY DID NOT EMIT.
+        //
+        // `EnvTypedTableBase` declares `updateMany`, `deleteMany` and `count`
+        // (typed-db.ts) and the ops layer implements all three — only this
+        // proxy, which is what a handler actually touches, left them out. So
+        // the type said the verb exists, autocomplete offered it, and the call
+        // answered `undefined is not a function`.
+        //
+        // Older than this run, but the run rewrote this proxy for
+        // `Database.schema(name).tables.*` and would have carried the gap onto
+        // the new surface too.
+        updateMany: /* @__PURE__ */ __name((q) => ops().updateMany(name, q.where, q.set), "updateMany"),
+        deleteMany: /* @__PURE__ */ __name((q) => ops().deleteMany(name, q.where), "deleteMany"),
+        count: /* @__PURE__ */ __name((q) => ops().count(name, q?.where), "count"),
+        search: /* @__PURE__ */ __name((params) => ops().search(name, params), "search"),
+        similar: /* @__PURE__ */ __name((id, params) => ops().similar(name, id, params), "similar"),
+        recommend: /* @__PURE__ */ __name((params) => ops().recommend(name, params), "recommend"),
+        facets: /* @__PURE__ */ __name((params) => ops().facets(name, params), "facets"),
+        supersede: /* @__PURE__ */ __name((id, row) => ops().supersede(name, id, row), "supersede"),
+        claim: /* @__PURE__ */ __name((unique, extra) => ops().claim(name, unique, extra), "claim")
+      };
+    }
+  });
+}
+__name(makeTableProxy, "makeTableProxy");
+var rawDatabase = makeServiceProxy("Database");
+function makeTypedSurface(raw) {
+  const reco = raw;
+  const ops = {
+    $query: /* @__PURE__ */ __name((sql, params) => raw.query(sql, params), "$query"),
+    $insert: /* @__PURE__ */ __name((table, data) => raw.insert(table, data), "$insert"),
+    $update: /* @__PURE__ */ __name((table, id, data) => raw.update(table, id, data), "$update"),
+    $delete: /* @__PURE__ */ __name((table, id) => raw.delete(table, id), "$delete"),
+    $findById: /* @__PURE__ */ __name((table, id) => raw.findById(table, id), "$findById"),
+    $findMany: /* @__PURE__ */ __name((table, query, opts) => raw.findMany(table, query, opts), "$findMany"),
+    $put: /* @__PURE__ */ __name((table, data, opts) => raw.put(table, data, opts), "$put"),
+    $updateMany: /* @__PURE__ */ __name((table, where, set) => raw.updateMany(table, where, set), "$updateMany"),
+    $deleteMany: /* @__PURE__ */ __name((table, where) => raw.deleteMany(table, where), "$deleteMany"),
+    $count: /* @__PURE__ */ __name((table, where) => raw.count(table, where), "$count"),
+    $search: /* @__PURE__ */ __name((table, params) => raw.search(table, params), "$search"),
+    $similar: /* @__PURE__ */ __name((table, id, params) => reco.similar(table, id, params), "$similar"),
+    $recommend: /* @__PURE__ */ __name((table, params) => reco.recommend(table, params), "$recommend"),
+    $facets: /* @__PURE__ */ __name((table, params) => reco.facets(table, params), "$facets"),
+    $claim: /* @__PURE__ */ __name((table, unique, extra) => reco.claim(table, unique, extra), "$claim"),
+    $lockRows: /* @__PURE__ */ __name((table, ids) => reco.lockRows(table, ids), "$lockRows"),
+    $advisoryXactLock: /* @__PURE__ */ __name((key) => reco.advisoryXactLock(key), "$advisoryXactLock"),
+    $supersede: /* @__PURE__ */ __name((table, id, row) => raw.supersede(table, id, row), "$supersede")
+  };
+  const base = Object.assign(ops, {
+    // Both surfaces get it: a savepoint on the service transaction is as useful
+    // as one on the request's, and each is bound to its own connection.
+    $attempt: /* @__PURE__ */ __name((fn) => raw.attempt(fn), "$attempt"),
+    $transaction(fn, opts) {
+      return withRetry(() => {
+        const builder = new TxPlanBuilder();
+        return runTxPlan(raw, makeTxPlanHandle(builder), builder, fn);
+      }, opts ?? {});
+    }
+  });
+  return new Proxy(base, {
+    get(target, prop, receiver) {
+      if (prop === "tables") return makeTableProxy(() => reco, "");
+      if (typeof prop === "string" && !prop.startsWith("$") && !(prop in target)) {
+        return makeTableProxy(() => reco, qualifiedTableKey(prop, ""));
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+__name(makeTypedSurface, "makeTypedSurface");
+function makeTxTablesAccessor(builder, prefix = "") {
+  const tablesProxy = new Proxy({}, {
+    get(_t, prop) {
+      if (typeof prop !== "string") return void 0;
+      return builder.table(prefix + prop);
+    }
+  });
+  return tablesProxy;
+}
+__name(makeTxTablesAccessor, "makeTxTablesAccessor");
+function makeTxPlanHandle(builder) {
+  const publicTables = makeTxTablesAccessor(builder);
+  return new Proxy({}, {
+    get(_t, prop) {
+      if (typeof prop !== "string") return void 0;
+      if (prop === "tables") return publicTables;
+      return makeTxTablesAccessor(builder, qualifiedTableKey(prop, ""));
+    }
+  });
+}
+__name(makeTxPlanHandle, "makeTxPlanHandle");
+var Database = Object.assign(makeTypedSurface(rawDatabase), {
+  /**
+  * Lazily resolve the runtime's service-role sibling on each call. We do NOT
+  * cache it: `rawDatabase.asService()` reads the CURRENT request scope through
+  * the runtime proxy, and the per-request runtime injects a service client
+  * bound to that request's identity headers — caching would leak one request's
+  * sibling into another concurrent request.
+  */
+  $asService() {
+    return makeTypedSurface(rawDatabase.asService());
+  }
+});
+var Documents = makeServiceProxy("Documents");
+function makeBucketsAccessor(storage) {
+  return new Proxy({}, {
+    get(_t, prop) {
+      if (typeof prop !== "string") return void 0;
+      return storage().bucket(prop);
+    }
+  });
+}
+__name(makeBucketsAccessor, "makeBucketsAccessor");
+var rawStorage = makeServiceProxy("Storage");
+var Storage = Object.assign({
+  // FORWARDED explicitly, not assigned onto the service proxy.
+  //
+  // `Object.assign(rawStorage, {buckets})` writes onto the proxy's TARGET, and
+  // the proxy's only trap is `get`, which forwards every read to the module
+  // client — so the property landed somewhere nothing reads and
+  // `Storage.buckets.docs` was `undefined` in a deployed handler. It
+  // typechecked, every test passed, and the live call answered
+  // "TypeError: undefined is not an object". `Database` never had the bug
+  // because it builds a plain surface the same way this now does.
+  bucket: /* @__PURE__ */ __name((name) => rawStorage.bucket(name), "bucket")
+}, {
+  buckets: makeBucketsAccessor(() => rawStorage)
+});
+var Cache = makeServiceProxy("Cache");
+var Secrets = makeServiceProxy("Secrets");
+var Log = makeServiceProxy("Log");
+var Notifications = makeServiceProxy("Notifications");
+var rawFlags = makeServiceProxy("Flags");
+var Flags = Object.assign({
+  isEnabled(flagName, context) {
+    return rawFlags.isEnabled(flagName, context);
+  },
+  getVariant(flagName, context) {
+    return rawFlags.getVariant(flagName, context);
+  },
+  getAll(context) {
+    return rawFlags.getAll(context);
+  },
+  /**
+   * Resolve a flag's value, with an optional fallback.
+   *
+   * FORWARDED as of 2026-08-15. This surface is written out by hand, method
+   * by method, and `get` was missing from it — so the client implemented it,
+   * thirty assertions covered it, and `Flags.get("x")` was `undefined` in a
+   * deployed handler. Exactly the shape of the `Storage.buckets` defect found
+   * the same day: a hand-maintained forwarding list is a list somebody has to
+   * remember to update.
+   */
+  get(flagName, defaultOrContext, maybeContext) {
+    return rawFlags.get(flagName, defaultOrContext, maybeContext);
+  },
+  setOverride(key, value) {
+    return rawFlags.setOverride(key, value);
+  }
+}, {
+  /**
+   * Lazily resolve the runtime's cross-user sibling on each call. We do NOT
+   * cache it: `rawFlags.asService()` reads the CURRENT request scope through
+   * the runtime proxy, so caching would leak one request's sibling into
+   * another concurrent request. Mirrors `Database.asService()`.
+   */
+  asService() {
+    return rawFlags.asService();
+  }
+});
+var Realtime = makeServiceProxy("Realtime");
+
+// src/db/env-gen.ts
+function baseTsType(def) {
+  switch (def.type) {
+    case "uuid":
+    case "text":
+    case "timestamp":
+      return "string";
+    case "integer":
+      return "number";
+    // Both are exact-precision in Postgres and lossy as a JSON number, so the
+    // database proxy serializes them as strings — measured: 9007199254740993
+    // used to arrive as ...992 and 41.00821234567890123 as 41.0082123456789.
+    // numeric had no case at all and fell through to `unknown`, which typed
+    // every numeric column out of existence.
+    case "bigint":
+    case "numeric":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "jsonb":
+      return "unknown";
+    // FR-008: the authoring type of a pgvector column. The default `unknown`
+    // branch below STAYS — an unknown wire type is refused on the Go side
+    // (FR-005), never papered over here.
+    case "vector":
+      return "number[]";
+    case "enum": {
+      const values = def.enumValues ?? [];
+      if (values.length === 0) return "string";
+      return values.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    default:
+      return "unknown";
+  }
+}
+__name(baseTsType, "baseTsType");
+function rowType(def) {
+  const base = baseTsType(def);
+  return def.nullable ? `${base} | null` : base;
+}
+__name(rowType, "rowType");
+function optionalOnInsert(def) {
+  return def.nullable === true || def.defaultRandom === true || def.defaultNow === true || def.defaultValue !== void 0;
+}
+__name(optionalOnInsert, "optionalOnInsert");
+function forwardName(column) {
+  return column.endsWith("_id") ? column.slice(0, -3) : column;
+}
+__name(forwardName, "forwardName");
+function describeOrigin(o) {
+  return o.direction === "forward" ? `the foreign key "${o.table}.${o.column}"` : `the reverse of "${o.table}.${o.column}"`;
+}
+__name(describeOrigin, "describeOrigin");
+function renameCall(o) {
+  if (o.direction === "reverse") return `references(() => \u2026, { reverseAs: "\u2026" })`;
+  if (o.def.owns === true) {
+    return `ownedByUser() takes no { as } \u2014 if "${o.column}" only POINTS at a user, declare it userRef({ onDelete: \u2026 }) instead`;
+  }
+  const target = o.def.references?.table;
+  if (target === "auth.users") return `userRef({ onDelete: \u2026, as: "\u2026" })`;
+  if (target === "auth.installations") return `installationRef({ onDelete: \u2026, as: "\u2026" })`;
+  if (o.def.selfRefColumn !== void 0) return `selfReferences("\u2026", { as: "\u2026" })`;
+  return `references(() => \u2026, { as: "\u2026" })`;
+}
+__name(renameCall, "renameCall");
+function buildRelations(schemas) {
+  const out = /* @__PURE__ */ new Map();
+  const taken = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    for (const t of Object.values(schema.tables)) {
+      const key = qualifiedTableKey(schema.name, t.name);
+      out.set(key, []);
+      taken.set(key, /* @__PURE__ */ new Map());
+    }
+  }
+  const claim = /* @__PURE__ */ __name((tableKey, name, origin, edge) => {
+    const names = taken.get(tableKey);
+    if (names === void 0) return;
+    const held = names.get(name);
+    if (held !== void 0) {
+      if (held.def.owns === true && origin.def.owns === true) {
+        throw new Error(`table "${tableKey}" declares TWO owner columns (${held.column}, ${origin.column}) \u2014 a table has at most ONE ownedByUser(). If the other column only POINTS at a user, declare it userRef({ onDelete: \u2026 }) instead.`);
+      }
+      const heldFix = renameCall(held);
+      const originFix = renameCall(origin);
+      const remedy = heldFix === originFix ? `rename one of them: ${heldFix}` : `rename one of them \u2014 "${held.table}.${held.column}": ${heldFix}; "${origin.table}.${origin.column}": ${originFix}`;
+      throw new Error(`table "${tableKey}": ${describeOrigin(held)} and ${describeOrigin(origin)} both resolve to the relation name "${name}" \u2014 ${remedy}.`);
+    }
+    names.set(name, origin);
+    out.get(tableKey)?.push(edge);
+  }, "claim");
+  for (const schema of schemas) {
+    for (const table of Object.values(schema.tables)) {
+      const childKey = qualifiedTableKey(schema.name, table.name);
+      if (!out.has(childKey)) continue;
+      for (const [col, builder] of Object.entries(table.columns)) {
+        const def = builder._def;
+        if (def.references === void 0) continue;
+        const targetKey = def.references.table;
+        const name = def.owns === true ? "owner" : def.refAs ?? forwardName(col);
+        claim(childKey, name, {
+          table: table.name,
+          column: col,
+          direction: "forward",
+          def
+        }, {
+          name,
+          to: targetKey,
+          kind: "one",
+          via: col
+        });
+        if (!out.has(targetKey) || targetKey === childKey) continue;
+        const reverse = def.reverseAs ?? table.name;
+        claim(targetKey, reverse, {
+          table: table.name,
+          column: col,
+          direction: "reverse",
+          def
+        }, {
+          name: reverse,
+          to: childKey,
+          kind: "many",
+          via: col
+        });
+      }
+    }
+  }
+  return out;
+}
+__name(buildRelations, "buildRelations");
+function tableBlock(table, relations, indent) {
+  const cols = Object.entries(table.columns);
+  const rowLines = cols.map(([col, builder]) => {
+    return `${indent}    ${col}: ${rowType(builder._def)};`;
+  });
+  const insertLines = cols.map(([col, builder]) => {
+    const def = builder._def;
+    const opt = optionalOnInsert(def) ? "?" : "";
+    return `${indent}    ${col}${opt}: ${rowType(def)};`;
+  });
+  const relEntries = relations.map((r) => `${r.name}: { to: ${JSON.stringify(r.to)}; kind: ${JSON.stringify(r.kind)}; via: ${JSON.stringify(r.via)} }`).join("; ");
+  return [
+    `${indent}${table.name}: {`,
+    `${indent}  row: {`,
+    ...rowLines,
+    `${indent}  };`,
+    `${indent}  insert: {`,
+    ...insertLines,
+    `${indent}  };`,
+    `${indent}  relations: {${relEntries === "" ? "" : ` ${relEntries} `}};`,
+    // searchable: vector kolonu YA DA search beyanı → EnvTypedTable'da search()
+    // üyesini açan yapısal bayrak (FR-013). Yokken satır hiç üretilmez ki
+    // mevcut şemaların d.ts'i bayt-aynı kalsın.
+    ...cols.some(([, b]) => b._def.type === "vector") || table.search !== void 0 ? [
+      `${indent}  searchable: true;`
+    ] : [],
+    // appendOnly (FR-031): EnvTypedTable'ın altı yazma üyesini KALDIRAN yapısal
+    // bayrak. `searchable` ile aynı desen ve aynı OMIT disiplini — bayrak yokken
+    // satır hiç üretilmez ki mevcut şemaların d.ts'i bayt-aynı kalsın.
+    ...table.appendOnly === true ? [
+      `${indent}  appendOnly: true;`
+    ] : [],
+    `${indent}};`
+  ].join("\n");
+}
+__name(tableBlock, "tableBlock");
+function makeEnvDts(schemas) {
+  const relations = buildRelations(schemas);
+  const publicSchema = schemas.find((s) => s.name === "public");
+  const others = schemas.filter((s) => s.name !== "public");
+  const publicBlocks = Object.keys(publicSchema?.tables ?? {}).map((name) => tableBlock(publicSchema.tables[name], relations.get(name) ?? [], "    "));
+  const body = publicBlocks.length > 0 ? `
+${publicBlocks.join("\n")}
+  ` : "";
+  const schemaBlocks = others.map((schema) => {
+    const inner = Object.keys(schema.tables).map((name) => tableBlock(schema.tables[name], relations.get(qualifiedTableKey(schema.name, name)) ?? [], "      "));
+    return `    ${schema.name}: {
+${inner.join("\n")}
+    };`;
+  });
+  const schemasBody = schemaBlocks.length > 0 ? `
+${schemaBlocks.join("\n")}
+  ` : "";
+  return `// AUTO-GENERATED by @palbase/backend \u2014 DO NOT EDIT.
+// Regenerated from db/*.ts by \`palbase build\` and by every deploy.
+// Augments the @palbase/backend/env \`Tables\` interface so \`Database.public.*\`
+// is typed with no import and no generic. Schemas other than \`public\` land
+// under \`Schemas\`, reached with \`Database.schema("<name>").tables.*\`.
+
+declare module "@palbase/backend/env" {
+  interface Tables {${body}}
+  interface Schemas {${schemasBody}}
+}
+
+export {};
+`;
+}
+__name(makeEnvDts, "makeEnvDts");
+
+// src/decorators/injectable.ts
+var DI_INJECTABLES = /* @__PURE__ */ Symbol.for("palbase.backend.diInjectables");
+var INJECTABLE = /* @__PURE__ */ Symbol.for("palbase.backend.injectable");
+var isInjectable = /* @__PURE__ */ __name((c) => c?.[INJECTABLE] === true, "isInjectable");
+function slot() {
+  const g = globalThis;
+  return g[DI_INJECTABLES] ??= [];
+}
+__name(slot, "slot");
+function Injectable() {
+  return (target) => {
+    target[INJECTABLE] = true;
+    slot().push(target);
+  };
+}
+__name(Injectable, "Injectable");
+function __claimInjectables() {
+  return slot().splice(0);
+}
+__name(__claimInjectables, "__claimInjectables");
+
+// src/decorators/kinds.ts
+var JOB = /* @__PURE__ */ Symbol.for("palbase.backend.jobMeta");
+var WEBHOOK = /* @__PURE__ */ Symbol.for("palbase.backend.webhookMeta");
+var HOOK_BLOCKING = /* @__PURE__ */ Symbol.for("palbase.backend.hookBlocking");
+var HOOK_LISTENERS = /* @__PURE__ */ Symbol.for("palbase.backend.webhookEvents");
+var ROOM = /* @__PURE__ */ Symbol.for("palbase.backend.room");
+var CONTROLLER = /* @__PURE__ */ Symbol.for("palbase.backend.controllerMeta");
+var has = /* @__PURE__ */ __name((c, s) => c[s] !== void 0, "has");
+var isEntryPointClass = /* @__PURE__ */ __name((c) => has(c, JOB) || has(c, WEBHOOK) || has(c, ROOM) || has(c, CONTROLLER) || has(c, HOOK_BLOCKING) || has(c, HOOK_LISTENERS), "isEntryPointClass");
+var owned = /* @__PURE__ */ __name((container) => [
+  ...container.owned
+], "owned");
+var jobsOf = /* @__PURE__ */ __name((container) => owned(container).filter((c) => has(c, JOB)), "jobsOf");
+var webhooksOf = /* @__PURE__ */ __name((container) => owned(container).filter((c) => has(c, WEBHOOK)), "webhooksOf");
+var hooksOf = /* @__PURE__ */ __name((container) => owned(container).filter((c) => !has(c, WEBHOOK) && !has(c, CONTROLLER) && (has(c, HOOK_BLOCKING) || has(c, HOOK_LISTENERS))), "hooksOf");
+var roomsOf = /* @__PURE__ */ __name((container) => owned(container).filter((c) => has(c, ROOM)), "roomsOf");
+var controllersOf = /* @__PURE__ */ __name((container) => owned(container).filter((c) => has(c, CONTROLLER)), "controllersOf");
+
+// src/decorators/module.ts
+var DI_MODULES = /* @__PURE__ */ Symbol.for("palbase.backend.diModules");
+function slot2() {
+  const g = globalThis;
+  return g[DI_MODULES] ??= [];
+}
+__name(slot2, "slot");
+function Module(def) {
+  return (target) => {
+    slot2().push({
+      mod: target,
+      def
+    });
+  };
+}
+__name(Module, "Module");
+function __claimModules() {
+  return slot2().splice(0);
+}
+__name(__claimModules, "__claimModules");
+
+// src/container.ts
+import "reflect-metadata";
+var DiError = class extends Error {
+  static {
+    __name(this, "DiError");
+  }
+  kind;
+  path;
+  at;
+  fixes;
+  constructor(kind, path, at, detail, fixes) {
+    super(`
+Kind:  ${kind}
+Path:  ${path.length > 0 ? path.join(" -> ") : "(none)"}
+At:    ${at}
+${detail}
+
+Potential solutions:
+${fixes.map((f) => `  - ${f}`).join("\n")}
+`), this.kind = kind, this.path = path, this.at = at, this.fixes = fixes;
+    this.name = "DiError";
+  }
+};
+var nameOf = /* @__PURE__ */ __name((c) => c?.name ?? String(c), "nameOf");
+var UNRESOLVABLE = /* @__PURE__ */ new Set([
+  Object,
+  Function,
+  String,
+  Number,
+  Boolean,
+  Array,
+  Symbol,
+  Promise,
+  Date,
+  void 0,
+  null
+]);
+var DATA = /* @__PURE__ */ new Set([
+  String,
+  Number,
+  Boolean,
+  Date,
+  Symbol
+]);
+function declaresDependencies(ctor) {
+  const arity = ctor?.length ?? 0;
+  if (arity === 0) return true;
+  const meta = Reflect.getMetadata("design:paramtypes", ctor);
+  return meta !== void 0 && meta.length === arity;
+}
+__name(declaresDependencies, "declaresDependencies");
+function buildContainer() {
+  const entries = __claimModules();
+  const declared = __claimInjectables();
+  if (entries.length === 0) {
+    throw new DiError("unowned class", [], "project", "no module was declared \u2014 every project declares at least one @Module.", [
+      "create `<domain>.module.ts` with @Module({ controllers: [...], providers: [...] })",
+      "`palbase init` scaffolds one for you"
+    ]);
+  }
+  const declaredModules = new Set(entries.map((e) => e.mod));
+  const owner = /* @__PURE__ */ new Map();
+  for (const { mod, def } of entries) {
+    const m = nameOf(mod);
+    for (const c of [
+      ...def.providers ?? [],
+      ...def.controllers ?? []
+    ]) {
+      const prev = owner.get(c);
+      if (prev !== void 0) {
+        throw new DiError("duplicate ownership", [
+          nameOf(c)
+        ], `${prev} & ${m}`, `${nameOf(c)} is listed by two modules, so which one owns it has two answers.`, [
+          `remove ${nameOf(c)} from ${prev}`,
+          `or remove it from ${m}`,
+          `if both modules need it, keep ONE owner and export it, then import that module`
+        ]);
+      }
+      owner.set(c, m);
+    }
+  }
+  {
+    for (const { mod, def } of entries) {
+      for (const p of def.providers ?? []) {
+        if (isInjectable(p) || isEntryPointClass(p)) continue;
+        if (!declaresDependencies(p)) continue;
+        throw new DiError("undeclared provider", [
+          nameOf(mod),
+          nameOf(p)
+        ], `${nameOf(mod)}.providers`, `${nameOf(p)} is listed in ${nameOf(mod)}.providers but carries no decorator, so the container cannot know it is constructible or what its constructor asks for.`, [
+          `mark ${nameOf(p)} \`@Injectable()\` if it is a concrete class`,
+          `if ${nameOf(p)} is an \`abstract class\`, list the class that \`extends\` it instead \u2014 name the abstraction as the DEPENDENCY and the container resolves it`
+        ]);
+      }
+    }
+  }
+  {
+    const orphans = declared.filter((c) => !owner.has(c));
+    if (orphans.length > 0) {
+      const names = orphans.map(nameOf);
+      throw new DiError("unowned class", names, "module declarations", `${names.join(", ")} ${orphans.length === 1 ? "is" : "are"} marked @Injectable() but listed in no module's providers, so nothing can reach ${orphans.length === 1 ? "it" : "them"}.`, [
+        `add ${names.length === 1 ? names[0] : "each of them"} to a module's \`providers\``,
+        "or delete the class \u2014 one no module lists is never built"
+      ]);
+    }
+  }
+  const exported = /* @__PURE__ */ new Map();
+  const importsOf = /* @__PURE__ */ new Map();
+  for (const { mod, def } of entries) {
+    const m = nameOf(mod);
+    for (const e of def.exports ?? []) {
+      if (owner.get(e) !== m) {
+        const holder = owner.get(e);
+        throw new DiError("unknown export", [
+          m
+        ], `${m}.exports`, holder === void 0 ? `${m} exports ${nameOf(e)}, but no module owns it.` : `${m} exports ${nameOf(e)}, but ${holder} owns it \u2014 a module cannot re-export another's class.`, holder === void 0 ? [
+          `add ${nameOf(e)} to ${m}.providers`,
+          `or remove it from ${m}.exports`
+        ] : [
+          `remove ${nameOf(e)} from ${m}.exports`,
+          `and have ${holder} export it instead, then add ${holder} to the importing module's imports`
+        ]);
+      }
+    }
+    for (const i of def.imports ?? []) {
+      if (i === mod) {
+        throw new DiError("unknown import", [
+          m
+        ], `${m}.imports`, `${m} imports itself, which grants nothing it does not already have.`, [
+          `remove ${m} from its own imports`,
+          "or name the module you meant instead"
+        ]);
+      }
+      if (!declaredModules.has(i)) {
+        throw new DiError("unknown import", [
+          m
+        ], `${m}.imports`, `${m} imports ${nameOf(i)}, which is not a module.`, [
+          `add @Module({ ... }) to ${nameOf(i)}`,
+          `or remove ${nameOf(i)} from ${m}.imports \u2014 to reach a class, import the module that OWNS it`
+        ]);
+      }
+    }
+    exported.set(m, new Set(def.exports ?? []));
+    importsOf.set(m, new Set((def.imports ?? []).map(nameOf)));
+  }
+  const deps = /* @__PURE__ */ new Map();
+  const implementorsOf = /* @__PURE__ */ __name((t) => [
+    ...owner.keys()
+  ].filter((c) => c !== t && Object.prototype.isPrototypeOf.call(t, c)), "implementorsOf");
+  const withArity = [
+    ...owner.keys()
+  ].filter((c) => c.length > 0);
+  const missingMeta = withArity.filter((c) => Reflect.getMetadata("design:paramtypes", c) === void 0);
+  if (withArity.length >= 2 && missingMeta.length === withArity.length) {
+    throw new DiError("metadata missing", withArity.map(nameOf), "the whole build", `no class carries constructor metadata \u2014 every one of the ${withArity.length} class(es) that asks for a dependency is missing it, so this is the build, not the classes.`, [
+      "set `emitDecoratorMetadata: true` in the project's tsconfig.json",
+      "and import `reflect-metadata` before any decorated class evaluates \u2014 without it the emitted helper is a silent no-op",
+      "if the build is fine, then none of these classes carries @Injectable()"
+    ]);
+  }
+  for (const [cls, m] of owner) {
+    const arity = cls.length;
+    if (arity === 0) {
+      deps.set(cls, []);
+      continue;
+    }
+    if (!declaresDependencies(cls)) {
+      const meta2 = Reflect.getMetadata("design:paramtypes", cls);
+      throw new DiError("metadata missing", [
+        nameOf(cls)
+      ], `${nameOf(cls)} constructor`, `${nameOf(cls)} declares ${arity} parameter(s) but carries ${meta2 === void 0 ? "no" : String(meta2.length)} metadata entries, so every parameter would arrive as undefined.`, [
+        `add @Injectable() to ${nameOf(cls)} \u2014 metadata is emitted for DECORATED classes only`,
+        "or the build ran without emitDecoratorMetadata: check tsconfig.json"
+      ]);
+    }
+    const meta = Reflect.getMetadata("design:paramtypes", cls);
+    const list = [];
+    meta.forEach((t, i) => {
+      const at = `${nameOf(cls)} constructor, parameter ${i}`;
+      if (typeof t !== "function" || UNRESOLVABLE.has(t)) {
+        throw new DiError("unresolvable dependency", [
+          nameOf(cls)
+        ], at, `parameter ${i} has no runtime class \u2014 an interface, a type alias, a union, or a data type. The container has nothing to construct.`, DATA.has(t) ? [
+          "an injectable's constructor takes dependencies, not data",
+          "move the value to a method argument instead",
+          "or make this a plain value class (no @Injectable, in no module) and `new` it yourself"
+        ] : [
+          "depend on a concrete class or an abstract class",
+          "a TypeScript interface does not exist at runtime \u2014 there is nothing to inject"
+        ]);
+      }
+      const dep = t;
+      {
+        let dm = owner.get(dep);
+        if (dm === void 0) {
+          const impls = implementorsOf(dep);
+          if (impls.length === 1) {
+            const impl = impls[0];
+            list.push(impl);
+            dm = owner.get(impl);
+            if (dm !== m) {
+              if (!importsOf.get(m)?.has(dm)) {
+                throw new DiError("missing import", [
+                  nameOf(cls),
+                  nameOf(impl)
+                ], at, `${nameOf(impl)} implements ${nameOf(dep)} and is owned by ${dm}, which ${m} does not import.`, [
+                  `add ${dm} to ${m}.imports`
+                ]);
+              }
+              if (!exported.get(dm)?.has(impl)) {
+                throw new DiError("private dependency", [
+                  nameOf(cls),
+                  nameOf(impl)
+                ], at, `${nameOf(impl)} implements ${nameOf(dep)} but is internal to ${dm}.`, [
+                  `add ${nameOf(impl)} to ${dm}.exports (and say why)`
+                ]);
+              }
+            }
+            return;
+          }
+          if (impls.length > 1) {
+            const names = impls.map(nameOf).sort();
+            throw new DiError("duplicate ownership", [
+              nameOf(cls),
+              nameOf(dep)
+            ], at, `${names.join(" and ")} both extend ${nameOf(dep)}, so which one ${nameOf(cls)} should receive has two answers.`, [
+              `keep ONE class extending ${nameOf(dep)} in this graph`,
+              `or depend on ${names[0]} or ${names[1]} directly, by name`
+            ]);
+          }
+          throw new DiError("unowned class", [
+            nameOf(cls),
+            nameOf(dep)
+          ], at, `${nameOf(dep)} belongs to no module, and nothing in this graph extends it \u2014 so there is nothing to construct. (An abstract class cannot be built: \`abstract\` is a type-level claim, and \`new\` on one returns an object missing every abstract member.)`, [
+            `add ${nameOf(dep)} to a module's providers if it is concrete`,
+            `or add a class that \`extends ${nameOf(dep)}\` to a module's providers`
+          ]);
+        }
+        if (dm !== m) {
+          if (!importsOf.get(m)?.has(dm)) {
+            throw new DiError("missing import", [
+              nameOf(cls),
+              nameOf(dep)
+            ], at, `${nameOf(dep)} is owned by ${dm}, which ${m} does not import.`, [
+              `add ${dm} to ${m}.imports`
+            ]);
+          }
+          if (!exported.get(dm)?.has(dep)) {
+            throw new DiError("private dependency", [
+              nameOf(cls),
+              nameOf(dep)
+            ], at, `${nameOf(dep)} is internal to ${dm} \u2014 it is not exported.`, [
+              `use one of ${dm}'s exported classes`,
+              `or add ${nameOf(dep)} to ${dm}.exports (and say why it should be public)`
+            ]);
+          }
+        }
+      }
+      list.push(dep);
+    });
+    deps.set(cls, list);
+  }
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  const walk = /* @__PURE__ */ __name((c) => {
+    if (state.get(c) === 1) {
+      const cyc = [
+        ...stack.slice(stack.indexOf(c)),
+        c
+      ].map(nameOf);
+      throw new DiError("dependency cycle", cyc, `${cyc[0]} constructor`, `the dependency graph contains a cycle: ${cyc.join(" -> ")}.`, [
+        "extract the shared part into a third class both can depend on",
+        "or invert one direction \u2014 have the callee raise an event the caller listens for"
+      ]);
+    }
+    if (state.get(c) === 2) return;
+    state.set(c, 1);
+    stack.push(c);
+    for (const d of deps.get(c) ?? []) walk(d);
+    stack.pop();
+    state.set(c, 2);
+  }, "walk");
+  for (const c of owner.keys()) walk(c);
+  const cache = /* @__PURE__ */ new Map();
+  const make = /* @__PURE__ */ __name((c) => {
+    if (!owner.has(c)) {
+      throw new DiError("unowned class", [
+        nameOf(c)
+      ], "container.get", `${nameOf(c)} belongs to no module, so this container never validated it and will not build it.`, [
+        `add ${nameOf(c)} to a module's providers`,
+        "or, if it is a plain value class, construct it yourself with `new`"
+      ]);
+    }
+    const hit = cache.get(c);
+    if (hit !== void 0) return hit;
+    const args = (deps.get(c) ?? []).map(make);
+    const inst = new c(...args);
+    cache.set(c, inst);
+    return inst;
+  }, "make");
+  return {
+    get: /* @__PURE__ */ __name((t) => make(t), "get"),
+    owned: new Set(owner.keys()),
+    pressure: computePressure(entries)
+  };
+}
+__name(buildContainer, "buildContainer");
+function computePressure(entries) {
+  const total = entries.length;
+  const count = /* @__PURE__ */ new Map();
+  for (const { def } of entries) {
+    for (const i of def.imports ?? []) {
+      const n = nameOf(i);
+      count.set(n, (count.get(n) ?? 0) + 1);
+    }
+  }
+  return [
+    ...count
+  ].map(([module, c]) => ({
+    module,
+    pct: Math.round(c / (total - 1) * 100),
+    of: total - 1
+  })).sort((a, b) => b.pct - a.pct);
+}
+__name(computePressure, "computePressure");
+function assertNoOrphanEntryPoints(registered, owned2) {
+  const orphans = registered.filter((c) => !owned2.has(c));
+  if (orphans.length === 0) return;
+  const names = orphans.map((c) => c.name ?? "<anonymous>");
+  throw new DiError("unowned class", names, "module declarations", `${names.join(", ")} ${orphans.length === 1 ? "is" : "are"} decorated as an entry point but listed in no module, so nothing decides whether it should be served.`, [
+    "add it to a module's `controllers` (for @Controller) or `providers` (for @Room/@Job/@Hook/@Webhook)",
+    "an entry point no module lists is never mounted and never reaches the OpenAPI document"
+  ]);
+}
+__name(assertNoOrphanEntryPoints, "assertNoOrphanEntryPoints");
+
+export {
+  __requestALS,
+  __setRuntime,
+  __runWithRuntime,
+  __getRuntime,
+  onStart,
+  onShutdown,
+  __runStartHooks,
+  __resetLifecycleHooks,
+  Database,
+  Documents,
+  Storage,
+  Cache,
+  Secrets,
+  Log,
+  Notifications,
+  Flags,
+  Realtime,
+  buildRelations,
+  makeEnvDts,
+  Injectable,
+  __claimInjectables,
+  jobsOf,
+  webhooksOf,
+  hooksOf,
+  roomsOf,
+  controllersOf,
+  Module,
+  __claimModules,
+  DiError,
+  buildContainer,
+  assertNoOrphanEntryPoints
+};
+//# sourceMappingURL=chunk-BQN723PL.js.map