@palbase/backend 25.1.0 → 27.0.0

package/dist/index.js

@@ -1,18 +1,21 @@
 import {
   EXTENSION_DEPENDENCIES,
+  IndexBuilder,
   PALBASE_EXTENSIONS,
   PolicyBuilder,
+  PolicyExprRef,
   TABLE_META,
   bigint,
   boolean,
   defineSchema,
   defineTable,
   enumType,
+  exprCtx,
+  index,
   installationRef,
   integer,
   isPalbaseExtension,
   jsonb,
-  makeTypedDB,
   numeric,
   openai,
   ownedByUser,
@@ -23,50 +26,61 @@ import {
   userRef,
   uuid,
   vector
-} from "./chunk-G4R6BTLV.js";
+} from "./chunk-TS4U7NBD.js";
 import {
   defineError,
   getErrorRegistry
-} from "./chunk-YOY5DFQS.js";
+} from "./chunk-TWX6JTGJ.js";
 import {
   Cache,
   Database,
+  DiError,
   Documents,
   Flags,
+  Injectable,
   Log,
+  Module,
   Notifications,
   Realtime,
   Secrets,
   Storage,
+  __claimInjectables,
+  __claimModules,
   __getRuntime,
   __requestALS,
   __resetLifecycleHooks,
   __runStartHooks,
   __runWithRuntime,
   __setRuntime,
+  assertNoOrphanEntryPoints,
+  buildContainer,
+  controllersOf,
+  hooksOf,
+  jobsOf,
+  makeEnvDts,
   onShutdown,
-  onStart
-} from "./chunk-CRQKCRGF.js";
+  onStart,
+  roomsOf,
+  webhooksOf
+} from "./chunk-I3C4PFIW.js";
+import {
+  col,
+  makeTypedDB,
+  sqlFragment,
+  toSchemaJSON,
+  withRetry
+} from "./chunk-DRZFQRJI.js";
 import {
   TxPlanError,
   TxRefError,
   dec,
+  decrement,
   inc,
-  now,
-  qualifiedTableKey,
-  toSchemaJSON
-} from "./chunk-CJSKYY76.js";
+  increment,
+  now
+} from "./chunk-GYK6QYS4.js";
 import {
-  BadRequest,
-  Conflict,
   Controller,
-  Forbidden,
-  HttpError,
-  NotFound,
-  PalError,
-  TooManyRequests,
-  Unauthorized,
-  UniqueViolation,
   __resetDefaultAuth,
   __resetRegisteredControllers,
   assertZeroArgConstructor,
@@ -80,11 +94,30 @@ import {
   recordRoute,
   recordThrows,
   resolveEffectiveAuth
-} from "./chunk-35PNTIRN.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-VVMJEVQP.js";
+import {
+  BadRequest,
+  Conflict,
+  DeadlockDetected,
+  Forbidden,
+  HttpError,
+  NotFound,
+  PalError,
+  SerializationFailure,
+  TooManyRequests,
+  Unauthorized,
+  UniqueViolation,
+  isRetryable
+} from "./chunk-CGNN2PUH.js";
+import {
+  __name
+} from "./chunk-VXPNPVAG.js";
 
 // src/clients/http.ts
 var PalbaseModuleError = class extends Error {
+  static {
+    __name(this, "PalbaseModuleError");
+  }
   code;
   status;
   details;
@@ -103,7 +136,10 @@ function makeHttpClient(cfg) {
       ...options.headers ?? {}
     };
     if (cfg.apiKey) headers["apikey"] = cfg.apiKey;
-    const init = { method, headers };
+    const init = {
+      method,
+      headers
+    };
     if (options.body !== void 0) {
       if (typeof options.body === "string" || options.body instanceof Uint8Array) {
         init.body = options.body;
@@ -125,11 +161,7 @@ function makeHttpClient(cfg) {
     } catch (err) {
       return {
         data: null,
-        error: new PalbaseModuleError(
-          "network_error",
-          err instanceof Error ? err.message : "Network request failed",
-          0
-        ),
+        error: new PalbaseModuleError("network_error", err instanceof Error ? err.message : "Network request failed", 0),
         status: 0
       };
     }
@@ -152,10 +184,19 @@ function makeHttpClient(cfg) {
         status: response.status
       };
     }
-    return { data: parsed, error: null, status: response.status };
+    return {
+      data: parsed,
+      error: null,
+      status: response.status
+    };
   }
-  return { baseUrl: cfg.baseUrl, request };
+  __name(request, "request");
+  return {
+    baseUrl: cfg.baseUrl,
+    request
+  };
 }
+__name(makeHttpClient, "makeHttpClient");
 
 // src/clients/documents.ts
 var SEGMENT_RE = /^[A-Za-z0-9_-]+$/;
@@ -164,27 +205,43 @@ function validateSegment(segment, label) {
     throw new Error(`Invalid ${label}: "${segment}". Must match ${SEGMENT_RE.source}`);
   }
 }
+__name(validateSegment, "validateSegment");
 function buildDocumentRef(http, path) {
   return {
     path,
     async set(data) {
-      return http.request("PUT", `/v1/docs/${path}`, { body: data });
+      return http.request("PUT", `/v1/docs/${path}`, {
+        body: data
+      });
     },
     async get() {
       const response = await http.request("GET", `/v1/docs/${path}`);
-      if (response.error) return { data: null, error: response.error, status: response.status };
+      if (response.error) return {
+        data: null,
+        error: response.error,
+        status: response.status
+      };
       const raw2 = response.data ?? {};
       const exists = raw2.exists !== void 0 ? raw2.exists : Boolean(raw2.data || raw2.id);
       const segments = path.split("/");
       const id = raw2.id || segments[segments.length - 1] || "";
       return {
-        data: { id, exists, data: () => raw2.data, ref: { path } },
+        data: {
+          id,
+          exists,
+          data: /* @__PURE__ */ __name(() => raw2.data, "data"),
+          ref: {
+            path
+          }
+        },
         error: null,
         status: response.status
       };
     },
     async update(data) {
-      return http.request("PATCH", `/v1/docs/${path}`, { body: data });
+      return http.request("PATCH", `/v1/docs/${path}`, {
+        body: data
+      });
     },
     async delete() {
       return http.request("DELETE", `/v1/docs/${path}`);
@@ -195,23 +252,34 @@ function buildDocumentRef(http, path) {
     }
   };
 }
-function buildCollectionRef(http, path, state = { where: [], orderBy: [] }) {
+__name(buildDocumentRef, "buildDocumentRef");
+function buildCollectionRef(http, path, state = {
+  where: [],
+  orderBy: []
+}) {
   function snapshot(doc) {
     return {
       id: doc.id,
       exists: true,
-      data: () => doc.data,
-      ref: { path: `${path}/${doc.id}` }
+      data: /* @__PURE__ */ __name(() => doc.data, "data"),
+      ref: {
+        path: `${path}/${doc.id}`
+      }
     };
   }
+  __name(snapshot, "snapshot");
   function querySnapshot(docs) {
     return {
       docs,
       empty: docs.length === 0,
       size: docs.length,
-      docChanges: () => docs.map((doc) => ({ type: "added", doc }))
+      docChanges: /* @__PURE__ */ __name(() => docs.map((doc) => ({
+        type: "added",
+        doc
+      })), "docChanges")
     };
   }
+  __name(querySnapshot, "querySnapshot");
   return {
     path,
     doc(id) {
@@ -219,9 +287,15 @@ function buildCollectionRef(http, path, state = { where: [], orderBy: [] }) {
       return buildDocumentRef(http, `${path}/${id}`);
     },
     async add(data) {
-      const resp = await http.request("POST", `/v1/docs/${path}`, { body: data });
+      const resp = await http.request("POST", `/v1/docs/${path}`, {
+        body: data
+      });
       if (resp.error || !resp.data) {
-        return { data: null, error: resp.error, status: resp.status };
+        return {
+          data: null,
+          error: resp.error,
+          status: resp.status
+        };
       }
       return {
         data: buildDocumentRef(http, `${path}/${resp.data.id}`),
@@ -234,59 +308,85 @@ function buildCollectionRef(http, path, state = { where: [], orderBy: [] }) {
     where(field, op, value) {
       return buildCollectionRef(http, path, {
         ...state,
-        where: [...state.where, { field, op, value }]
+        where: [
+          ...state.where,
+          {
+            field,
+            op,
+            value
+          }
+        ]
       });
     },
     orderBy(field, direction = "asc") {
       return buildCollectionRef(http, path, {
         ...state,
-        orderBy: [...state.orderBy, { field, direction }]
+        orderBy: [
+          ...state.orderBy,
+          {
+            field,
+            direction
+          }
+        ]
       });
     },
     limit(n) {
-      return buildCollectionRef(http, path, { ...state, limit: n });
+      return buildCollectionRef(http, path, {
+        ...state,
+        limit: n
+      });
     },
     async get() {
       const narrowed = state.where.length > 0 || state.orderBy.length > 0 || state.limit !== void 0;
-      const resp = narrowed ? await http.request(
-        "POST",
-        `/v1/docs/${path}/query`,
-        { body: queryBody(state) }
-      ) : await http.request(
-        "GET",
-        `/v1/docs/${path}`
-      );
-      if (resp.error) return { data: null, error: resp.error, status: resp.status };
+      const resp = narrowed ? await http.request("POST", `/v1/docs/${path}/query`, {
+        body: queryBody(state)
+      }) : await http.request("GET", `/v1/docs/${path}`);
+      if (resp.error) return {
+        data: null,
+        error: resp.error,
+        status: resp.status
+      };
       const docs = (resp.data?.documents ?? []).map(snapshot);
-      return { data: querySnapshot(docs), error: null, status: resp.status };
+      return {
+        data: querySnapshot(docs),
+        error: null,
+        status: resp.status
+      };
     }
   };
 }
+__name(buildCollectionRef, "buildCollectionRef");
 function queryBody(state) {
   const body = {};
   if (state.where.length > 0) {
-    body.where = state.where.map((w) => ({ field: w.field, op: w.op, value: w.value }));
+    body.where = state.where.map((w) => ({
+      field: w.field,
+      op: w.op,
+      value: w.value
+    }));
   }
   if (state.orderBy.length > 0) {
-    body.orderBy = state.orderBy.map((o) => ({ field: o.field, direction: o.direction }));
+    body.orderBy = state.orderBy.map((o) => ({
+      field: o.field,
+      direction: o.direction
+    }));
   }
   if (state.limit !== void 0) body.limit = state.limit;
   return body;
 }
+__name(queryBody, "queryBody");
 var MAX_BATCH = 500;
 function buildDocumentsClient(http) {
   return {
     /**
-     * `Documents.doc("users/alice")` — segments are collection/documentId PAIRS,
-     * so an odd count addresses a COLLECTION and is refused. Accepting it would
-     * write a document whose id happens to be a collection's name.
-     */
+    * `Documents.doc("users/alice")` — segments are collection/documentId PAIRS,
+    * so an odd count addresses a COLLECTION and is refused. Accepting it would
+    * write a document whose id happens to be a collection's name.
+    */
     doc(path) {
       const segments = String(path).split("/").filter((s) => s.length > 0);
       if (segments.length === 0 || segments.length % 2 !== 0) {
-        throw new Error(
-          `Invalid document path: "${path}". Expected collection/documentId pairs, got ${segments.length} segment(s).`
-        );
+        throw new Error(`Invalid document path: "${path}". Expected collection/documentId pairs, got ${segments.length} segment(s).`);
       }
       segments.forEach((s, i) => validateSegment(s, i % 2 === 0 ? "collection name" : "document ID"));
       return buildDocumentRef(http, segments.join("/"));
@@ -299,21 +399,26 @@ function buildDocumentsClient(http) {
       if (operations.length > MAX_BATCH) {
         return {
           data: null,
-          error: new PalbaseModuleError(
-            "batch_too_large",
-            `Batch size ${operations.length} exceeds maximum of ${MAX_BATCH}`,
-            400
-          ),
+          error: new PalbaseModuleError("batch_too_large", `Batch size ${operations.length} exceeds maximum of ${MAX_BATCH}`, 400),
           status: 400
         };
       }
-      if (operations.length === 0) return { data: null, error: null, status: 200 };
+      if (operations.length === 0) return {
+        data: null,
+        error: null,
+        status: 200
+      };
       return http.request("POST", "/v1/docs/batch", {
-        body: operations.map((op) => ({ op: op.op, path: op.ref.path, data: op.data }))
+        body: operations.map((op) => ({
+          op: op.op,
+          path: op.ref.path,
+          data: op.data
+        }))
       });
     }
   };
 }
+__name(buildDocumentsClient, "buildDocumentsClient");
 
 // src/clients/flags.ts
 var FLAG_NAME_RE = /^[A-Za-z0-9_.-]+$/;
@@ -322,46 +427,54 @@ function assertFlagName(flagName) {
     throw new Error(`Invalid flag name: "${flagName}". Flag names must match ${FLAG_NAME_RE.source}`);
   }
 }
+__name(assertFlagName, "assertFlagName");
 function flagEnabled(value) {
   if (typeof value === "boolean") return value;
   return value != null && value !== 0 && value !== "";
 }
+__name(flagEnabled, "flagEnabled");
 function flagVariant(value) {
-  return typeof value === "string" ? { name: value } : null;
+  return typeof value === "string" ? {
+    name: value
+  } : null;
 }
+__name(flagVariant, "flagVariant");
 function isContextObject(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v) && ("userId" in v || "properties" in v);
 }
+__name(isContextObject, "isContextObject");
 function buildFlagsClient(http, cfg) {
   function resolveUserId(context) {
     if (context && "userId" in context) return context.userId ?? null;
     return cfg.getCurrentUserId() || void 0;
   }
+  __name(resolveUserId, "resolveUserId");
   function mergedPath(context) {
     const uid = resolveUserId(context);
     return uid ? `/v1/user-flags/users/${encodeURIComponent(uid)}` : "/v1/user-flags";
   }
+  __name(mergedPath, "mergedPath");
   function fetchMerged(context) {
     return http.request("GET", mergedPath(context));
   }
+  __name(fetchMerged, "fetchMerged");
   const service = {
     async setOverrideForUser(userId, key, value) {
-      return http.request(
-        "PUT",
-        `/v1/user-flags/users/${encodeURIComponent(userId)}/${encodeURIComponent(key)}`,
-        { body: { value } }
-      );
+      return http.request("PUT", `/v1/user-flags/users/${encodeURIComponent(userId)}/${encodeURIComponent(key)}`, {
+        body: {
+          value
+        }
+      });
     },
     async setOverridesForUser(userId, values) {
       return http.request("PUT", `/v1/user-flags/users/${encodeURIComponent(userId)}`, {
-        body: { values }
+        body: {
+          values
+        }
       });
     },
     async clearOverrideForUser(userId, key) {
-      return http.request(
-        "DELETE",
-        `/v1/user-flags/users/${encodeURIComponent(userId)}/${encodeURIComponent(key)}`
-      );
+      return http.request("DELETE", `/v1/user-flags/users/${encodeURIComponent(userId)}/${encodeURIComponent(key)}`);
     },
     async clearAllOverridesForUser(userId) {
       return http.request("DELETE", `/v1/user-flags/users/${encodeURIComponent(userId)}`);
@@ -369,31 +482,54 @@ function buildFlagsClient(http, cfg) {
     async batchSetOverrides(operations) {
       const ops = (operations ?? []).map((op) => {
         const raw2 = op;
-        return { user_id: raw2.userId ?? raw2.user_id, values: raw2.values };
+        return {
+          user_id: raw2.userId ?? raw2.user_id,
+          values: raw2.values
+        };
+      });
+      return http.request("POST", "/v1/user-flags/batch", {
+        body: {
+          operations: ops
+        }
       });
-      return http.request("POST", "/v1/user-flags/batch", { body: { operations: ops } });
     }
   };
   return {
     async isEnabled(flagName, context) {
       assertFlagName(flagName);
       const res = await fetchMerged(context);
-      if (res.error || res.data == null) return { data: null, error: res.error, status: res.status };
-      return { data: flagEnabled(res.data.values?.[flagName]), error: null, status: res.status };
+      if (res.error || res.data == null) return {
+        data: null,
+        error: res.error,
+        status: res.status
+      };
+      return {
+        data: flagEnabled(res.data.values?.[flagName]),
+        error: null,
+        status: res.status
+      };
     },
     async getVariant(flagName, context) {
       assertFlagName(flagName);
       const res = await fetchMerged(context);
-      if (res.error || res.data == null) return { data: null, error: res.error, status: res.status };
-      return { data: flagVariant(res.data.values?.[flagName]), error: null, status: res.status };
+      if (res.error || res.data == null) return {
+        data: null,
+        error: res.error,
+        status: res.status
+      };
+      return {
+        data: flagVariant(res.data.values?.[flagName]),
+        error: null,
+        status: res.status
+      };
     },
     /**
-     * `get(key)` · `get(key, default)` · `get(key, default, ctx)` · `get(key, ctx)`.
-     *
-     * The default is substituted when the flag is ABSENT or when the flags
-     * service is unreachable — a product that hides a feature because a lookup
-     * timed out is behaving correctly; one that crashes is not.
-     */
+    * `get(key)` · `get(key, default)` · `get(key, default, ctx)` · `get(key, ctx)`.
+    *
+    * The default is substituted when the flag is ABSENT or when the flags
+    * service is unreachable — a product that hides a feature because a lookup
+    * timed out is behaving correctly; one that crashes is not.
+    */
     async get(flagName, defaultOrContext, maybeContext) {
       assertFlagName(flagName);
       let defaultValue;
@@ -411,19 +547,39 @@ function buildFlagsClient(http, cfg) {
       }
       const resp = await fetchMerged(context);
       if (resp.error !== null) {
-        if (hasDefault) return { data: defaultValue ?? null, error: null, status: resp.status };
-        return { data: null, error: resp.error, status: resp.status };
+        if (hasDefault) return {
+          data: defaultValue ?? null,
+          error: null,
+          status: resp.status
+        };
+        return {
+          data: null,
+          error: resp.error,
+          status: resp.status
+        };
       }
       const values = resp.data?.values ?? {};
       const value = values[flagName];
       if (value === void 0) {
-        return { data: hasDefault ? defaultValue ?? null : null, error: null, status: resp.status };
+        return {
+          data: hasDefault ? defaultValue ?? null : null,
+          error: null,
+          status: resp.status
+        };
       }
-      return { data: value, error: null, status: resp.status };
+      return {
+        data: value,
+        error: null,
+        status: resp.status
+      };
     },
     async getAll(context) {
       const res = await fetchMerged(context);
-      if (res.error || res.data == null) return { data: null, error: res.error, status: res.status };
+      if (res.error || res.data == null) return {
+        data: null,
+        error: res.error,
+        status: res.status
+      };
       const values = res.data.values ?? {};
       return {
         data: Object.keys(values).map((name) => {
@@ -432,7 +588,9 @@ function buildFlagsClient(http, cfg) {
             name,
             enabled: flagEnabled(value)
           };
-          if (typeof value === "string") flag.variant = { name: value };
+          if (typeof value === "string") flag.variant = {
+            name: value
+          };
           return flag;
         }),
         error: null,
@@ -440,11 +598,11 @@ function buildFlagsClient(http, cfg) {
       };
     },
     /**
-     * Override a flag for the CURRENT request user.
-     *
-     * On an anonymous request this does not silently no-op and does not write
-     * for nobody: it refuses and names the call that does cross-user writes.
-     */
+    * Override a flag for the CURRENT request user.
+    *
+    * On an anonymous request this does not silently no-op and does not write
+    * for nobody: it refuses and names the call that does cross-user writes.
+    */
     async setOverride(key, value) {
       const uid = cfg.getCurrentUserId();
       if (!uid) {
@@ -456,25 +614,35 @@ function buildFlagsClient(http, cfg) {
           status: 400
         };
       }
-      return http.request(
-        "PUT",
-        `/v1/user-flags/users/${encodeURIComponent(uid)}/${encodeURIComponent(key)}`,
-        { body: { value } }
-      );
+      return http.request("PUT", `/v1/user-flags/users/${encodeURIComponent(uid)}/${encodeURIComponent(key)}`, {
+        body: {
+          value
+        }
+      });
     },
     asService() {
       return service;
     }
   };
 }
+__name(buildFlagsClient, "buildFlagsClient");
 
 // src/clients/notifications.ts
 function mapEnvelope(res, map) {
   if (res.error !== null || res.data === null || res.data === void 0) {
-    return { data: null, error: res.error, status: res.status };
+    return {
+      data: null,
+      error: res.error,
+      status: res.status
+    };
   }
-  return { data: map(res.data), error: null, status: res.status };
+  return {
+    data: map(res.data),
+    error: null,
+    status: res.status
+  };
 }
+__name(mapEnvelope, "mapEnvelope");
 function toEmailTemplate(wire) {
   const view = {
     id: wire.id,
@@ -490,6 +658,7 @@ function toEmailTemplate(wire) {
   if (wire.text_body !== void 0) view.textBody = wire.text_body;
   return view;
 }
+__name(toEmailTemplate, "toEmailTemplate");
 function toSmsTemplate(wire) {
   return {
     id: wire.id,
@@ -502,40 +671,58 @@ function toSmsTemplate(wire) {
     updatedAt: wire.updated_at
   };
 }
+__name(toSmsTemplate, "toSmsTemplate");
 function buildNotificationsClient(http) {
   const push = {
     async send(params) {
-      return http.request("POST", "/v1/notifications/push", { body: params });
+      return http.request("POST", "/v1/notifications/push", {
+        body: params
+      });
     }
   };
   const email = {
     async send(params) {
       const { templateSlug, html, text: text2, ...rest } = params;
-      const body = { ...rest };
+      const body = {
+        ...rest
+      };
       if (templateSlug !== void 0) body.template_slug = templateSlug;
       if (html !== void 0) body.html_body = html;
       if (text2 !== void 0) body.text_body = text2;
-      return http.request("POST", "/v1/notifications/email", { body });
+      return http.request("POST", "/v1/notifications/email", {
+        body
+      });
     }
   };
   const sms = {
     async send(params) {
       const { templateSlug, ...rest } = params;
-      const body = templateSlug !== void 0 ? { ...rest, template_slug: templateSlug } : rest;
-      return http.request("POST", "/v1/notifications/sms", { body });
+      const body = templateSlug !== void 0 ? {
+        ...rest,
+        template_slug: templateSlug
+      } : rest;
+      return http.request("POST", "/v1/notifications/sms", {
+        body
+      });
     }
   };
   const verifications = {
     async start(params) {
-      return http.request("POST", "/v1/notifications/verifications", { body: params });
+      return http.request("POST", "/v1/notifications/verifications", {
+        body: params
+      });
     },
     async check(params) {
-      return http.request("POST", "/v1/notifications/verifications/check", { body: params });
+      return http.request("POST", "/v1/notifications/verifications/check", {
+        body: params
+      });
     }
   };
   const inbox = {
     async send(params) {
-      return http.request("POST", "/v1/notifications/inbox", { body: params });
+      return http.request("POST", "/v1/notifications/inbox", {
+        body: params
+      });
     },
     async list(options) {
       const opts = options ?? {};
@@ -566,7 +753,9 @@ function buildNotificationsClient(http) {
       return http.request("GET", "/v1/notifications/preferences");
     },
     async update(params) {
-      return http.request("PUT", "/v1/notifications/preferences", { body: params });
+      return http.request("PUT", "/v1/notifications/preferences", {
+        body: params
+      });
     }
   };
   const emailTemplates = {
@@ -575,10 +764,7 @@ function buildNotificationsClient(http) {
       return mapEnvelope(resp, (rows) => (rows ?? []).map(toEmailTemplate));
     },
     async get(id) {
-      const resp = await http.request(
-        "GET",
-        `/v1/notifications/templates/${encodeURIComponent(id)}`
-      );
+      const resp = await http.request("GET", `/v1/notifications/templates/${encodeURIComponent(id)}`);
       return mapEnvelope(resp, toEmailTemplate);
     },
     async create(input) {
@@ -589,7 +775,9 @@ function buildNotificationsClient(http) {
       };
       if (input.textBody !== void 0) body.text_body = input.textBody;
       if (input.variables !== void 0) body.variables = input.variables;
-      const resp = await http.request("POST", "/v1/notifications/templates", { body });
+      const resp = await http.request("POST", "/v1/notifications/templates", {
+        body
+      });
       return mapEnvelope(resp, toEmailTemplate);
     },
     async update(id, input) {
@@ -598,11 +786,9 @@ function buildNotificationsClient(http) {
       if (input.htmlBody !== void 0) body.html_body = input.htmlBody;
       if (input.textBody !== void 0) body.text_body = input.textBody;
       if (input.variables !== void 0) body.variables = input.variables;
-      const resp = await http.request(
-        "PUT",
-        `/v1/notifications/templates/${encodeURIComponent(id)}`,
-        { body }
-      );
+      const resp = await http.request("PUT", `/v1/notifications/templates/${encodeURIComponent(id)}`, {
+        body
+      });
       return mapEnvelope(resp, toEmailTemplate);
     },
     async delete(id) {
@@ -615,27 +801,27 @@ function buildNotificationsClient(http) {
       return mapEnvelope(resp, (rows) => (rows ?? []).map(toSmsTemplate));
     },
     async get(id) {
-      const resp = await http.request(
-        "GET",
-        `/v1/notifications/sms-templates/${encodeURIComponent(id)}`
-      );
+      const resp = await http.request("GET", `/v1/notifications/sms-templates/${encodeURIComponent(id)}`);
       return mapEnvelope(resp, toSmsTemplate);
     },
     async create(input) {
-      const body = { slug: input.slug, body: input.body };
+      const body = {
+        slug: input.slug,
+        body: input.body
+      };
       if (input.variables !== void 0) body.variables = input.variables;
-      const resp = await http.request("POST", "/v1/notifications/sms-templates", { body });
+      const resp = await http.request("POST", "/v1/notifications/sms-templates", {
+        body
+      });
       return mapEnvelope(resp, toSmsTemplate);
     },
     async update(id, input) {
       const body = {};
       if (input.body !== void 0) body.body = input.body;
       if (input.variables !== void 0) body.variables = input.variables;
-      const resp = await http.request(
-        "PUT",
-        `/v1/notifications/sms-templates/${encodeURIComponent(id)}`,
-        { body }
-      );
+      const resp = await http.request("PUT", `/v1/notifications/sms-templates/${encodeURIComponent(id)}`, {
+        body
+      });
       return mapEnvelope(resp, toSmsTemplate);
     },
     async delete(id) {
@@ -649,27 +835,40 @@ function buildNotificationsClient(http) {
     verifications,
     inbox,
     preferences,
-    templates: { email: emailTemplates, sms: smsTemplates },
+    templates: {
+      email: emailTemplates,
+      sms: smsTemplates
+    },
     async registerDevice(params) {
-      return http.request("POST", "/v1/notifications/devices", { body: params });
+      return http.request("POST", "/v1/notifications/devices", {
+        body: params
+      });
     },
     async unregisterDevice(deviceId) {
       return http.request("DELETE", `/v1/notifications/devices/${encodeURIComponent(deviceId)}`);
     }
   };
 }
+__name(buildNotificationsClient, "buildNotificationsClient");
 
 // src/clients/realtime.ts
 import { createHmac } from "crypto";
 function mintToken(secret) {
   const now2 = Math.floor(Date.now() / 1e3);
-  const header = Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" })).toString("base64url");
-  const payload = Buffer.from(
-    JSON.stringify({ iss: "backend-runtime", role: "service_role", iat: now2, exp: now2 + 60 })
-  ).toString("base64url");
+  const header = Buffer.from(JSON.stringify({
+    alg: "HS256",
+    typ: "JWT"
+  })).toString("base64url");
+  const payload = Buffer.from(JSON.stringify({
+    iss: "backend-runtime",
+    role: "service_role",
+    iat: now2,
+    exp: now2 + 60
+  })).toString("base64url");
   const sig = createHmac("sha256", secret).update(`${header}.${payload}`).digest("base64url");
   return `${header}.${payload}.${sig}`;
 }
+__name(mintToken, "mintToken");
 function buildRealtimeClient(cfg) {
   const url = `${cfg.baseUrl}/realtime/api/broadcast`;
   const stateUrl = `${cfg.baseUrl}/realtime/api/state`;
@@ -689,11 +888,7 @@ function buildRealtimeClient(cfg) {
     if (!cfg.apiJwtSecret) {
       return {
         data: null,
-        error: new PalbaseModuleError(
-          "realtime_unconfigured",
-          "Realtime.state is unavailable: realtime is not provisioned for this Environment (PALBASE_REALTIME_API_JWT_SECRET unset).",
-          503
-        )
+        error: new PalbaseModuleError("realtime_unconfigured", "Realtime.state is unavailable: realtime is not provisioned for this Environment (PALBASE_REALTIME_API_JWT_SECRET unset).", 503)
       };
     }
     let token;
@@ -702,57 +897,64 @@ function buildRealtimeClient(cfg) {
     } catch (err) {
       return {
         data: null,
-        error: new PalbaseModuleError(
-          "realtime_token_error",
-          err instanceof Error ? err.message : "token mint failed",
-          500
-        )
+        error: new PalbaseModuleError("realtime_token_error", err instanceof Error ? err.message : "token mint failed", 500)
       };
     }
-    const op = del ? { topic, key, del: true } : { topic, key, value: value ?? {} };
+    const op = del ? {
+      topic,
+      key,
+      del: true
+    } : {
+      topic,
+      key,
+      value: value ?? {}
+    };
     const doFetch = cfg.fetchImpl ?? globalThis.fetch;
     let response;
     try {
       response = await doFetch(stateUrl, {
         method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
-        body: JSON.stringify({ ops: [op] })
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          ops: [
+            op
+          ]
+        })
       });
     } catch (err) {
       return {
         data: null,
-        error: new PalbaseModuleError(
-          "network_error",
-          err instanceof Error ? err.message : "state request failed",
-          0
-        )
+        error: new PalbaseModuleError("network_error", err instanceof Error ? err.message : "state request failed", 0)
       };
     }
     if (response.status === 202 || response.status === 200) {
-      return { data: void 0, error: null };
+      return {
+        data: void 0,
+        error: null
+      };
     }
     const detail = await response.text().catch(() => "");
     return {
       data: null,
-      error: new PalbaseModuleError(
-        "realtime_state_failed",
-        `realtime state write returned ${response.status}${detail ? `: ${detail}` : ""}`,
-        response.status
-      )
+      error: new PalbaseModuleError("realtime_state_failed", `realtime state write returned ${response.status}${detail ? `: ${detail}` : ""}`, response.status)
     };
   }
+  __name(writeState, "writeState");
   return {
     state: {
       /** Write one DURABLE entry on a channel's shared state.
-       *
-       * The difference from broadcast is WHO it reaches: a broadcast reaches
-       * whoever is listening at that instant, while state is also handed to
-       * whoever joins afterwards. "This value is now X" wants the second — a
-       * client connecting a second later should not have to wait for the next
-       * change to learn X. */
-      set: (topic, key, value) => writeState(topic, key, value, false),
+      *
+      * The difference from broadcast is WHO it reaches: a broadcast reaches
+      * whoever is listening at that instant, while state is also handed to
+      * whoever joins afterwards. "This value is now X" wants the second — a
+      * client connecting a second later should not have to wait for the next
+      * change to learn X. */
+      set: /* @__PURE__ */ __name((topic, key, value) => writeState(topic, key, value, false), "set"),
       /** Remove one entry. */
-      clear: (topic, key) => writeState(topic, key, void 0, true)
+      clear: /* @__PURE__ */ __name((topic, key) => writeState(topic, key, void 0, true), "clear")
     },
     async broadcast(channel, event, payload) {
       if (typeof channel !== "string" || channel.length === 0) {
@@ -770,11 +972,7 @@ function buildRealtimeClient(cfg) {
       if (!cfg.apiJwtSecret) {
         return {
           data: null,
-          error: new PalbaseModuleError(
-            "realtime_unconfigured",
-            "Realtime.broadcast is unavailable: realtime is not provisioned for this Environment (PALBASE_REALTIME_API_JWT_SECRET unset).",
-            503
-          )
+          error: new PalbaseModuleError("realtime_unconfigured", "Realtime.broadcast is unavailable: realtime is not provisioned for this Environment (PALBASE_REALTIME_API_JWT_SECRET unset).", 503)
         };
       }
       let token;
@@ -783,49 +981,51 @@ function buildRealtimeClient(cfg) {
       } catch (err) {
         return {
           data: null,
-          error: new PalbaseModuleError(
-            "realtime_token_error",
-            err instanceof Error ? err.message : "token mint failed",
-            500
-          )
+          error: new PalbaseModuleError("realtime_token_error", err instanceof Error ? err.message : "token mint failed", 500)
         };
       }
       const body = JSON.stringify({
-        messages: [{ topic: channel, event, payload: payload ?? {}, private: false }]
+        messages: [
+          {
+            topic: channel,
+            event,
+            payload: payload ?? {},
+            private: false
+          }
+        ]
       });
       const doFetch = cfg.fetchImpl ?? globalThis.fetch;
       let response;
       try {
         response = await doFetch(url, {
           method: "POST",
-          headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
           body
         });
       } catch (err) {
         return {
           data: null,
-          error: new PalbaseModuleError(
-            "network_error",
-            err instanceof Error ? err.message : "broadcast request failed",
-            0
-          )
+          error: new PalbaseModuleError("network_error", err instanceof Error ? err.message : "broadcast request failed", 0)
         };
       }
       if (response.status === 202 || response.status === 200) {
-        return { data: void 0, error: null };
+        return {
+          data: void 0,
+          error: null
+        };
       }
       const detail = await response.text().catch(() => "");
       return {
         data: null,
-        error: new PalbaseModuleError(
-          "realtime_broadcast_failed",
-          `broadcast returned ${response.status}: ${detail.slice(0, 200)}`,
-          response.status
-        )
+        error: new PalbaseModuleError("realtime_broadcast_failed", `broadcast returned ${response.status}: ${detail.slice(0, 200)}`, response.status)
       };
     }
   };
 }
+__name(buildRealtimeClient, "buildRealtimeClient");
 
 // src/clients/storage.ts
 var BUCKET_NAME_RE = /^[a-zA-Z0-9_-]+$/;
@@ -833,11 +1033,10 @@ var STORAGE_PATH_RE = /^[a-zA-Z0-9_./-]+$/;
 var STORAGE_TRAVERSAL_RE = /(?:^|\/)\.\.(?:\/|$)/;
 function validateStoragePath(p) {
   if (!STORAGE_PATH_RE.test(p) || STORAGE_TRAVERSAL_RE.test(p)) {
-    throw new Error(
-      `Invalid file path: "${p}". Paths must not contain traversal sequences and must match ${STORAGE_PATH_RE.source}`
-    );
+    throw new Error(`Invalid file path: "${p}". Paths must not contain traversal sequences and must match ${STORAGE_PATH_RE.source}`);
   }
 }
+__name(validateStoragePath, "validateStoragePath");
 function toFileObject(bucket, row) {
   return {
     name: row.path ?? "",
@@ -852,14 +1051,24 @@ function toFileObject(bucket, row) {
     variants: row.variants ?? {}
   };
 }
+__name(toFileObject, "toFileObject");
 function mapResponse(res, map) {
   if (res.error || res.data === null || res.data === void 0) {
-    return { data: null, error: res.error, status: res.status };
+    return {
+      data: null,
+      error: res.error,
+      status: res.status
+    };
   }
-  return { data: map(res.data), error: null, status: res.status };
+  return {
+    data: map(res.data),
+    error: null,
+    status: res.status
+  };
 }
+__name(mapResponse, "mapResponse");
 function buildBucketClient(http, bucketName, publicOrigin) {
-  const objectPath = (path) => `/v1/storage/object/${bucketName}/${path}`;
+  const objectPath = /* @__PURE__ */ __name((path) => `/v1/storage/object/${bucketName}/${path}`, "objectPath");
   return {
     async upload(path, file, options) {
       validateStoragePath(path);
@@ -876,22 +1085,26 @@ function buildBucketClient(http, bucketName, publicOrigin) {
     },
     async download(path) {
       validateStoragePath(path);
-      return http.request("GET", objectPath(path), { headers: { Accept: "*/*" } });
+      return http.request("GET", objectPath(path), {
+        headers: {
+          Accept: "*/*"
+        }
+      });
     },
     getPublicUrl(path, options) {
       validateStoragePath(path);
       const variant = options?.variant ? `?variant=${encodeURIComponent(options.variant)}` : "";
       if (!publicOrigin) {
-        throw new Error(
-          `Storage.bucket("${bucketName}").getPublicUrl() needs this stack's public origin, and it was not configured. Set PALBASE_PUBLIC_ORIGIN to the address clients reach this stack at (e.g. https://myproject.palbase.studio).`
-        );
+        throw new Error(`Storage.bucket("${bucketName}").getPublicUrl() needs this stack's public origin, and it was not configured. Set PALBASE_PUBLIC_ORIGIN to the address clients reach this stack at (e.g. https://myproject.palbase.studio).`);
       }
       return `${publicOrigin}/v1/files/${bucketName}/${path}${variant}`;
     },
     async createSignedUrl(path, options) {
       validateStoragePath(path);
       return http.request("POST", `/v1/storage/sign/${bucketName}/${path}`, {
-        body: { expiresIn: options.expiresIn }
+        body: {
+          expiresIn: options.expiresIn
+        }
       });
     },
     async list(prefix, options) {
@@ -900,10 +1113,7 @@ function buildBucketClient(http, bucketName, publicOrigin) {
       if (prefix) params.set("prefix", prefix);
       if (options?.limit !== void 0) params.set("limit", String(options.limit));
       const query = params.toString();
-      const res = await http.request(
-        "GET",
-        `/v1/storage/bucket/${bucketName}${query ? `?${query}` : ""}`
-      );
+      const res = await http.request("GET", `/v1/storage/bucket/${bucketName}${query ? `?${query}` : ""}`);
       return mapResponse(res, (body) => (body?.objects ?? []).map((row) => toFileObject(bucketName, row)));
     },
     async remove(paths) {
@@ -911,23 +1121,44 @@ function buildBucketClient(http, bucketName, publicOrigin) {
       const removed = [];
       for (const p of paths) {
         const res = await http.request("DELETE", objectPath(p));
-        if (res.error) return { data: null, error: res.error, status: res.status };
-        removed.push(toFileObject(bucketName, { path: p }));
+        if (res.error) return {
+          data: null,
+          error: res.error,
+          status: res.status
+        };
+        removed.push(toFileObject(bucketName, {
+          path: p
+        }));
       }
-      return { data: removed, error: null, status: 200 };
+      return {
+        data: removed,
+        error: null,
+        status: 200
+      };
     },
     async move(from, to) {
       validateStoragePath(from);
       validateStoragePath(to);
-      return http.request("POST", `/v1/storage/move/${bucketName}`, { body: { from, to } });
+      return http.request("POST", `/v1/storage/move/${bucketName}`, {
+        body: {
+          from,
+          to
+        }
+      });
     },
     async copy(from, to) {
       validateStoragePath(from);
       validateStoragePath(to);
-      return http.request("POST", `/v1/storage/copy/${bucketName}`, { body: { from, to } });
+      return http.request("POST", `/v1/storage/copy/${bucketName}`, {
+        body: {
+          from,
+          to
+        }
+      });
     }
   };
 }
+__name(buildBucketClient, "buildBucketClient");
 function buildStorageClient(http, publicOrigin) {
   return {
     bucket(name) {
@@ -938,18 +1169,25 @@ function buildStorageClient(http, publicOrigin) {
     }
   };
 }
+__name(buildStorageClient, "buildStorageClient");
 
 // src/clients/index.ts
 function buildModuleClients(cfg) {
   const baseUrl = (cfg.baseUrl || "").replace(/\/+$/, "");
   if (!baseUrl) return {};
   const apiKey = cfg.serviceRoleKey || cfg.apiKey || "";
-  const http = makeHttpClient({ baseUrl, apiKey, fetchImpl: cfg.fetchImpl });
+  const http = makeHttpClient({
+    baseUrl,
+    apiKey,
+    fetchImpl: cfg.fetchImpl
+  });
   return {
     Documents: buildDocumentsClient(http),
     Storage: buildStorageClient(http, cfg.publicOrigin),
     Notifications: buildNotificationsClient(http),
-    Flags: buildFlagsClient(http, { getCurrentUserId: cfg.getCurrentUserId }),
+    Flags: buildFlagsClient(http, {
+      getCurrentUserId: cfg.getCurrentUserId
+    }),
     Realtime: buildRealtimeClient({
       baseUrl,
       apiJwtSecret: cfg.realtimeApiJwtSecret,
@@ -957,46 +1195,68 @@ function buildModuleClients(cfg) {
     })
   };
 }
+__name(buildModuleClients, "buildModuleClients");
 
 // src/channels.ts
 var CHANNELS = /* @__PURE__ */ Symbol.for("palbase.backend.channels");
 function ownerOnly() {
-  return { kind: "owner" };
+  return {
+    kind: "owner"
+  };
 }
+__name(ownerOnly, "ownerOnly");
 function publicChannel(opts = {}) {
-  return { kind: "public", publish: opts.publish ?? false, state: opts.state };
+  return {
+    kind: "public",
+    publish: opts.publish ?? false,
+    state: opts.state
+  };
 }
+__name(publicChannel, "publicChannel");
 function paramCount(pattern) {
   return pattern.split(":").filter((s) => s.startsWith("{") && s.endsWith("}")).length;
 }
+__name(paramCount, "paramCount");
 function defineChannels(map) {
   const entries = [];
   for (const [pattern, entry] of Object.entries(map)) {
     if ("kind" in entry && entry.kind === "owner") {
       if (paramCount(pattern) !== 1) {
-        throw new Error(
-          `defineChannels: ownerOnly() pattern "${pattern}" must carry exactly one {param} (its value is compared to the token subject)`
-        );
+        throw new Error(`defineChannels: ownerOnly() pattern "${pattern}" must carry exactly one {param} (its value is compared to the token subject)`);
       }
-      entries.push({ pattern, kind: "owner" });
+      entries.push({
+        pattern,
+        kind: "owner"
+      });
     } else if ("kind" in entry && entry.kind === "public") {
-      entries.push({ pattern, kind: "public", publish: entry.publish, state: entry.state });
+      entries.push({
+        pattern,
+        kind: "public",
+        publish: entry.publish,
+        state: entry.state
+      });
     } else {
       const c = entry;
-      entries.push({ pattern, kind: "custom", authorize: c.authorize, handler: c.handler });
+      entries.push({
+        pattern,
+        kind: "custom",
+        authorize: c.authorize,
+        handler: c.handler
+      });
     }
   }
-  const def = { entries };
+  const def = {
+    entries
+  };
   const carrier = globalThis;
   const existing = carrier[CHANNELS];
   if (existing && !sameDeclaration(existing, def)) {
-    throw new Error(
-      `defineChannels: channels were already declared (${existing.entries.length} pattern(s): ${existing.entries.map((e) => e.pattern).join(", ")}). A project declares its channels ONCE \u2014 a second call would overwrite the first, and channels nobody declared are refused.`
-    );
+    throw new Error(`defineChannels: channels were already declared (${existing.entries.length} pattern(s): ${existing.entries.map((e) => e.pattern).join(", ")}). A project declares its channels ONCE \u2014 a second call would overwrite the first, and channels nobody declared are refused.`);
   }
   carrier[CHANNELS] = def;
   return def;
 }
+__name(defineChannels, "defineChannels");
 function wireRow(e) {
   return JSON.stringify([
     e.pattern,
@@ -1010,214 +1270,46 @@ function wireRow(e) {
     e.authorize ? e.authorize.toString() : ""
   ]);
 }
+__name(wireRow, "wireRow");
 function sameDeclaration(a, b) {
   if (a.entries.length !== b.entries.length) return false;
   return a.entries.every((x, i) => wireRow(x) === wireRow(b.entries[i]));
 }
-
-// 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";
-  }
-}
-function rowType(def) {
-  const base = baseTsType(def);
-  return def.nullable ? `${base} | null` : base;
-}
-function optionalOnInsert(def) {
-  return def.nullable === true || def.defaultRandom === true || def.defaultNow === true || def.defaultValue !== void 0;
-}
-function forwardName(column) {
-  return column.endsWith("_id") ? column.slice(0, -3) : column;
-}
-function describeOrigin(o) {
-  return o.direction === "forward" ? `the foreign key "${o.table}.${o.column}"` : `the reverse of "${o.table}.${o.column}"`;
-}
-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" })`;
-}
-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 = (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);
-  };
-  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;
-}
-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;`] : [],
-    `${indent}};`
-  ].join("\n");
-}
-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.tables.*\`
-// 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(sameDeclaration, "sameDeclaration");
 
 // src/stack-gen.ts
 function liveNames(names) {
-  return [...new Set(names)].sort();
+  return [
+    ...new Set(names)
+  ].sort();
 }
+__name(liveNames, "liveNames");
 function memberName(name) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
 }
+__name(memberName, "memberName");
 function members(names) {
   if (names.length === 0) return "";
   return `
 ${names.map((n) => `    ${memberName(n)}: true;`).join("\n")}
   `;
 }
+__name(members, "members");
 function bucketMembers(buckets) {
-  const normalized = buckets.map((b) => typeof b === "string" ? { name: b, variants: [] } : b);
+  const normalized = buckets.map((b) => typeof b === "string" ? {
+    name: b,
+    variants: []
+  } : b);
   const byName = /* @__PURE__ */ new Map();
   for (const b of normalized) byName.set(b.name, b.variants);
-  const names = [...byName.keys()].sort();
+  const names = [
+    ...byName.keys()
+  ].sort();
   if (names.length === 0) return "";
   const rows = names.map((name) => {
-    const variants = [...new Set(byName.get(name) ?? [])].sort();
+    const variants = [
+      ...new Set(byName.get(name) ?? [])
+    ].sort();
     const union = variants.length === 0 ? "never" : variants.map((v) => JSON.stringify(v)).join(" | ");
     return `    ${memberName(name)}: { variants: ${union} };`;
   });
@@ -1225,6 +1317,7 @@ function bucketMembers(buckets) {
 ${rows.join("\n")}
   `;
 }
+__name(bucketMembers, "bucketMembers");
 function makeStackDts(names) {
   const secrets = liveNames(names.secrets);
   const flags = liveNames(names.flags);
@@ -1242,20 +1335,20 @@ declare module "@palbase/backend/stack" {
 export {};
 `;
 }
+__name(makeStackDts, "makeStackDts");
 
 // src/decorators/methods.ts
 function makeMethodDecorator(method) {
   return function(subpath, options = {}) {
     if (typeof subpath !== "string") {
-      throw new Error(
-        `@${method[0]}${method.slice(1).toLowerCase()}(subpath) expects a string subpath, got ${typeof subpath}.` + (method === "QUERY" ? " If this is a zod schema on a method parameter: the query-string param decorator was renamed @QueryParams(schema) in @palbase/backend 9.0.0." : "")
-      );
+      throw new Error(`@${method[0]}${method.slice(1).toLowerCase()}(subpath) expects a string subpath, got ${typeof subpath}.` + (method === "QUERY" ? " If this is a zod schema on a method parameter: the query-string param decorator was renamed @QueryParams(schema) in @palbase/backend 9.0.0." : ""));
     }
     return function(target, propertyKey) {
       recordRoute(target, String(propertyKey), method, subpath, options);
     };
   };
 }
+__name(makeMethodDecorator, "makeMethodDecorator");
 var Get = makeMethodDecorator("GET");
 var Post = makeMethodDecorator("POST");
 var Put = makeMethodDecorator("PUT");
@@ -1263,12 +1356,25 @@ var Patch = makeMethodDecorator("PATCH");
 var Delete = makeMethodDecorator("DELETE");
 var Query = makeMethodDecorator("QUERY");
 
+// src/decorators/surface-name.ts
+var SHAPE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+function assertSurfaceName(name, decorator, kind) {
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new Error(`${decorator} requires a \`name\` \u2014 it is this ${kind}'s identity, and it is declared rather than taken from the file name.`);
+  }
+  if (!SHAPE.test(name)) {
+    throw new Error(`${decorator} name "${name}" is not usable: it reaches a URL and a log line, so it must be lowercase letters, digits and dashes, starting and ending with one of those.`);
+  }
+}
+__name(assertSurfaceName, "assertSurfaceName");
+
 // src/decorators/webhook.ts
 var WEBHOOK_META = /* @__PURE__ */ Symbol.for("palbase.backend.webhookMeta");
 var WEBHOOK_EVENTS = /* @__PURE__ */ Symbol.for("palbase.backend.webhookEvents");
 function carrierOf(ctor) {
   return ctor;
 }
+__name(carrierOf, "carrierOf");
 function Webhook(options) {
   return function(ctor) {
     const carrier = carrierOf(ctor);
@@ -1287,12 +1393,18 @@ function Webhook(options) {
     return ctor;
   };
 }
+__name(Webhook, "Webhook");
 function On(event) {
   return function(target, fnName) {
     const carrier = carrierOf(target.constructor);
     const existing = carrier[WEBHOOK_EVENTS];
-    const entries = existing ? [...existing] : [];
-    entries.push({ event, fnName: String(fnName) });
+    const entries = existing ? [
+      ...existing
+    ] : [];
+    entries.push({
+      event,
+      fnName: String(fnName)
+    });
     Object.defineProperty(carrier, WEBHOOK_EVENTS, {
       value: entries,
       enumerable: false,
@@ -1301,24 +1413,30 @@ function On(event) {
     });
   };
 }
-function getWebhookConfig(ctor) {
+__name(On, "On");
+function getWebhookManifest(ctor) {
+  const { meta, entries } = validateWebhook(ctor);
+  return {
+    name: meta.name,
+    provider: meta.provider,
+    secretEnv: meta.secret.env,
+    events: entries.map((e) => e.event)
+  };
+}
+__name(getWebhookManifest, "getWebhookManifest");
+function validateWebhook(ctor) {
   const carrier = carrierOf(ctor);
   const meta = carrier[WEBHOOK_META];
   const entries = carrier[WEBHOOK_EVENTS] ?? [];
   if (!meta) {
-    throw new Error(
-      `@On used on a class that is not decorated with @Webhook (${ctor.name ?? "anonymous"})`
-    );
+    throw new Error(`@On used on a class that is not decorated with @Webhook (${ctor.name ?? "anonymous"})`);
   }
+  assertSurfaceName(meta.name, "@Webhook", "webhook");
   if (!meta.provider && !meta.signature) {
-    throw new Error(
-      "@Webhook requires either a `provider` preset or an explicit `signature` \u2014 an endpoint with no verification would accept forged deliveries"
-    );
+    throw new Error("@Webhook requires either a `provider` preset or an explicit `signature` \u2014 an endpoint with no verification would accept forged deliveries");
   }
   if (meta.provider && meta.signature) {
-    throw new Error(
-      "@Webhook declares BOTH a `provider` preset and an explicit `signature` \u2014 these are alternatives; keep the one that describes the sender, because only `provider` would be used"
-    );
+    throw new Error("@Webhook declares BOTH a `provider` preset and an explicit `signature` \u2014 these are alternatives; keep the one that describes the sender, because only `provider` would be used");
   }
   if (meta.signature) {
     const sig = meta.signature;
@@ -1344,8 +1462,15 @@ function getWebhookConfig(ctor) {
   if (entries.length === 0) {
     throw new Error("@Webhook requires at least one @On handler");
   }
-  assertZeroArgConstructor(ctor, "webhook class");
-  const instance = new ctor();
+  return {
+    meta,
+    entries
+  };
+}
+__name(validateWebhook, "validateWebhook");
+function getWebhookConfig(ctor, container) {
+  const { meta, entries } = validateWebhook(ctor);
+  const instance = container.get(ctor);
   const events = /* @__PURE__ */ Object.create(null);
   for (const entry of entries) {
     if (Object.prototype.hasOwnProperty.call(events, entry.event)) {
@@ -1354,15 +1479,23 @@ function getWebhookConfig(ctor) {
     events[entry.event] = (event, metaArg) => instance[entry.fnName].call(instance, event, metaArg);
   }
   return {
-    ...meta.provider ? { provider: meta.provider } : {},
-    ...meta.signature ? { signature: meta.signature } : {},
+    ...meta.provider ? {
+      provider: meta.provider
+    } : {},
+    ...meta.signature ? {
+      signature: meta.signature
+    } : {},
     secret: meta.secret,
     events
   };
 }
+__name(getWebhookConfig, "getWebhookConfig");
 
 // src/decorators/hook.ts
 var Deny = class extends Error {
+  static {
+    __name(this, "Deny");
+  }
   constructor(reason) {
     super(reason);
     this.name = "Deny";
@@ -1373,8 +1506,13 @@ function Hook(event) {
   return function(target, fnName) {
     const carrier = target.constructor;
     const existing = carrier[HOOK_BLOCKING];
-    const entries = existing ? [...existing] : [];
-    entries.push({ event, fnName: String(fnName) });
+    const entries = existing ? [
+      ...existing
+    ] : [];
+    entries.push({
+      event,
+      fnName: String(fnName)
+    });
     Object.defineProperty(carrier, HOOK_BLOCKING, {
       value: entries,
       enumerable: false,
@@ -1383,6 +1521,7 @@ function Hook(event) {
     });
   };
 }
+__name(Hook, "Hook");
 function bind(instance, entries, kind) {
   const out = /* @__PURE__ */ Object.create(null);
   for (const entry of entries) {
@@ -1397,22 +1536,34 @@ function bind(instance, entries, kind) {
   }
   return out;
 }
-function getHookConfig(ctor) {
+__name(bind, "bind");
+function getHookConfig(ctor, container) {
   const carrier = ctor;
   const blockingEntries = carrier[HOOK_BLOCKING] ?? [];
   const listenerEntries = carrier[WEBHOOK_EVENTS] ?? [];
   if (blockingEntries.length === 0 && listenerEntries.length === 0) {
-    throw new Error(
-      `${ctor.name ?? "a hook class"} carries no handler \u2014 a hook file must declare at least one @Hook (blocking) or @On (listener) method`
-    );
+    throw new Error(`${ctor.name ?? "a hook class"} carries no handler \u2014 a hook file must declare at least one @Hook (blocking) or @On (listener) method`);
   }
-  assertZeroArgConstructor(ctor, "hook class");
-  const instance = new ctor();
+  const instance = container.get(ctor);
   return {
     blocking: bind(instance, blockingEntries, "@Hook"),
     listeners: bind(instance, listenerEntries, "@On")
   };
 }
+__name(getHookConfig, "getHookConfig");
+function getHookManifest(ctor) {
+  const carrier = ctor;
+  const blockingEntries = carrier[HOOK_BLOCKING] ?? [];
+  const listenerEntries = carrier[WEBHOOK_EVENTS] ?? [];
+  if (blockingEntries.length === 0 && listenerEntries.length === 0) {
+    throw new Error(`${ctor.name ?? "a hook class"} carries no handler \u2014 a hook file must declare at least one @Hook (blocking) or @On (listener) method`);
+  }
+  return {
+    blocking: blockingEntries.map((e) => e.event),
+    listeners: listenerEntries.map((e) => e.event)
+  };
+}
+__name(getHookManifest, "getHookManifest");
 
 // src/decorators/upload.ts
 function Upload(subpath, config) {
@@ -1420,13 +1571,18 @@ function Upload(subpath, config) {
   validateUploadConfigShape(uploadConfig);
   const options = {
     uploadConfig,
-    ...auth !== void 0 ? { auth } : {},
-    ...rateLimit !== void 0 ? { rateLimit } : {}
+    ...auth !== void 0 ? {
+      auth
+    } : {},
+    ...rateLimit !== void 0 ? {
+      rateLimit
+    } : {}
   };
   return function(target, propertyKey) {
     recordRoute(target, String(propertyKey), "POST", subpath, options);
   };
 }
+__name(Upload, "Upload");
 function UploadedObject() {
   return function(target, propertyKey, parameterIndex) {
     recordParam(target, String(propertyKey), {
@@ -1435,6 +1591,7 @@ function UploadedObject() {
     });
   };
 }
+__name(UploadedObject, "UploadedObject");
 function validateUploadConfigShape(c) {
   if (c === null || typeof c !== "object") {
     throw new Error("@Upload config must be an object { bucket, pathTemplate, ... }");
@@ -1447,37 +1604,49 @@ function validateUploadConfigShape(c) {
     throw new Error("@Upload config.pathTemplate must be a non-empty key template");
   }
 }
+__name(validateUploadConfigShape, "validateUploadConfigShape");
 
 // src/decorators/sse.ts
 function Sse(subpath = "", config) {
   const { auth, rateLimit, ...sseConfig } = config;
   const options = {
     sseConfig,
-    ...auth !== void 0 ? { auth } : {},
-    ...rateLimit !== void 0 ? { rateLimit } : {}
+    ...auth !== void 0 ? {
+      auth
+    } : {},
+    ...rateLimit !== void 0 ? {
+      rateLimit
+    } : {}
   };
   return function(target, propertyKey) {
     recordRoute(target, String(propertyKey), "POST", subpath, options);
   };
 }
+__name(Sse, "Sse");
 function SseOut() {
   return function(target, propertyKey, parameterIndex) {
-    recordParam(target, String(propertyKey), { index: parameterIndex, kind: "sseOut" });
+    recordParam(target, String(propertyKey), {
+      index: parameterIndex,
+      kind: "sseOut"
+    });
   };
 }
+__name(SseOut, "SseOut");
 function Signal() {
   return function(target, propertyKey, parameterIndex) {
-    recordParam(target, String(propertyKey), { index: parameterIndex, kind: "signal" });
+    recordParam(target, String(propertyKey), {
+      index: parameterIndex,
+      kind: "signal"
+    });
   };
 }
+__name(Signal, "Signal");
 
 // src/decorators/room.ts
 var DEFAULT_GRACE_MS = 6e4;
 function assertPattern(pattern) {
   if (pattern.includes("/")) {
-    throw new Error(
-      `@Room("${pattern}"): channel patterns are colon-separated, not slash-separated. Write "${pattern.replace(/\//g, ":")}" \u2014 a slash matches no live topic.`
-    );
+    throw new Error(`@Room("${pattern}"): channel patterns are colon-separated, not slash-separated. Write "${pattern.replace(/\//g, ":")}" \u2014 a slash matches no live topic.`);
   }
   const segments = pattern.split(":");
   if (segments.some((s) => s === "")) {
@@ -1494,6 +1663,7 @@ function assertPattern(pattern) {
     seen.add(name);
   }
 }
+__name(assertPattern, "assertPattern");
 function Room(pattern, options) {
   return function(ctor) {
     assertPattern(pattern);
@@ -1505,11 +1675,13 @@ function Room(pattern, options) {
     return ctor;
   };
 }
+__name(Room, "Room");
 function hookDecorator(hook) {
   return () => function(target, propertyKey) {
     recordRoomHook(target, hook, String(propertyKey));
   };
 }
+__name(hookDecorator, "hookDecorator");
 var OnAuthorize = hookDecorator("authorize");
 var OnFirst = hookDecorator("first");
 var OnJoin = hookDecorator("join");
@@ -1520,6 +1692,7 @@ function OnMessage(name, schema) {
     recordRoomMessage(target, name, String(propertyKey), schema);
   };
 }
+__name(OnMessage, "OnMessage");
 
 // src/decorators/params.ts
 function makeParamDecorator(kind, extra) {
@@ -1527,48 +1700,70 @@ function makeParamDecorator(kind, extra) {
     recordParam(target, String(propertyKey), {
       index: parameterIndex,
       kind,
-      ...extra?.schema !== void 0 ? { schema: extra.schema } : {},
-      ...extra?.name !== void 0 ? { name: extra.name } : {}
+      ...extra?.schema !== void 0 ? {
+        schema: extra.schema
+      } : {},
+      ...extra?.name !== void 0 ? {
+        name: extra.name
+      } : {}
     });
   };
 }
+__name(makeParamDecorator, "makeParamDecorator");
 function Body(schema) {
-  return makeParamDecorator("body", { schema });
+  return makeParamDecorator("body", {
+    schema
+  });
 }
+__name(Body, "Body");
 function QueryParams(schema) {
-  return makeParamDecorator("query", { schema });
+  return makeParamDecorator("query", {
+    schema
+  });
 }
+__name(QueryParams, "QueryParams");
 function Headers(schema) {
-  return makeParamDecorator("headers", schema !== void 0 ? { schema } : void 0);
+  return makeParamDecorator("headers", schema !== void 0 ? {
+    schema
+  } : void 0);
 }
+__name(Headers, "Headers");
 function Param(name) {
-  return makeParamDecorator("param", { name });
+  return makeParamDecorator("param", {
+    name
+  });
 }
+__name(Param, "Param");
 function User() {
   return makeParamDecorator("user");
 }
+__name(User, "User");
 function OptionalUser() {
   return makeParamDecorator("optionalUser");
 }
+__name(OptionalUser, "OptionalUser");
 function Client() {
   return makeParamDecorator("client");
 }
+__name(Client, "Client");
 function RequestId() {
   return makeParamDecorator("requestId");
 }
+__name(RequestId, "RequestId");
 function TraceId() {
   return makeParamDecorator("traceId");
 }
+__name(TraceId, "TraceId");
 function Req() {
   return makeParamDecorator("req");
 }
+__name(Req, "Req");
 
 // src/middleware.ts
 function defineMiddleware(_fn) {
-  throw new Error(
-    "defineMiddleware() is not wired to anything: no bundler reads a `middleware/` directory and the engine has no middleware pipeline, so a handler defined here deploys and never runs. Put cross-cutting work in a service the controllers call, and use route options for auth (`@Controller(path, { auth })`) and rate limits (`@Get(path, { rateLimit })`)."
-  );
+  throw new Error("defineMiddleware() is not wired to anything: no bundler reads a `middleware/` directory and the engine has no middleware pipeline, so a handler defined here deploys and never runs. Put cross-cutting work in a service the controllers call, and use route options for auth (`@Controller(path, { auth })`) and rate limits (`@Get(path, { rateLimit })`).");
 }
+__name(defineMiddleware, "defineMiddleware");
 
 // src/job.ts
 function validateCronExpression(expression) {
@@ -1580,13 +1775,34 @@ function validateCronExpression(expression) {
   if (parts.length !== 5) {
     return `Invalid cron expression "${trimmed}": expected 5 fields (minute hour day month weekday), got ${parts.length}`;
   }
-  const fieldNames = ["minute", "hour", "day of month", "month", "day of week"];
+  const fieldNames = [
+    "minute",
+    "hour",
+    "day of month",
+    "month",
+    "day of week"
+  ];
   const fieldRanges = [
-    [0, 59],
-    [0, 23],
-    [1, 31],
-    [1, 12],
-    [0, 7]
+    [
+      0,
+      59
+    ],
+    [
+      0,
+      23
+    ],
+    [
+      1,
+      31
+    ],
+    [
+      1,
+      12
+    ],
+    [
+      0,
+      7
+    ]
   ];
   for (let i = 0; i < 5; i++) {
     const field = parts[i];
@@ -1599,6 +1815,7 @@ function validateCronExpression(expression) {
   }
   return null;
 }
+__name(validateCronExpression, "validateCronExpression");
 function validateCronField(field, name, min, max) {
   const listParts = field.split(",");
   for (const part of listParts) {
@@ -1636,6 +1853,7 @@ function validateCronField(field, name, min, max) {
   }
   return null;
 }
+__name(validateCronField, "validateCronField");
 
 // src/decorators/job.ts
 var DEFAULT_TIMEOUT_SECONDS = 30;
@@ -1661,13 +1879,13 @@ function Job(options) {
     return ctor;
   };
 }
-function getJobConfig(ctor) {
+__name(Job, "Job");
+function getJobManifest(ctor) {
   const meta = ctor[JOB_META];
   if (!meta) {
-    throw new Error(
-      `getJobConfig on a class with no @Job decorator (${ctor.name ?? "anonymous"})`
-    );
+    throw new Error(`getJobConfig on a class with no @Job decorator (${ctor.name ?? "anonymous"})`);
   }
+  assertSurfaceName(meta.name, "@Job", "job");
   if (!meta.schedule || meta.schedule.trim() === "") {
     throw new Error("@Job requires a `schedule` cron expression");
   }
@@ -1689,14 +1907,30 @@ function getJobConfig(ctor) {
   if (retry > MAX_RETRY) {
     throw new Error(`@Job \`retry\` exceeds the ceiling of ${MAX_RETRY}`);
   }
-  assertZeroArgConstructor(ctor, "job class");
-  const instance = new ctor();
+  return {
+    name: meta.name,
+    schedule: meta.schedule,
+    timeout,
+    retry
+  };
+}
+__name(getJobManifest, "getJobManifest");
+function getJobConfig(ctor, container) {
+  const { name, schedule, timeout, retry } = getJobManifest(ctor);
+  const instance = container.get(ctor);
   if (typeof instance.run !== "function") {
     throw new Error("@Job class must declare an async run() method");
   }
   const run = instance.run.bind(instance);
-  return { schedule: meta.schedule, timeout, retry, handler: run };
+  return {
+    name,
+    schedule,
+    timeout,
+    retry,
+    handler: run
+  };
 }
+__name(getJobConfig, "getJobConfig");
 
 // src/index.ts
 import { z } from "zod";
@@ -1708,8 +1942,10 @@ export {
   Conflict,
   Controller,
   Database,
+  DeadlockDetected,
   Delete,
   Deny,
+  DiError,
   Documents,
   EXTENSION_DEPENDENCIES,
   Flags,
@@ -1718,8 +1954,11 @@ export {
   Headers,
   Hook,
   HttpError,
+  IndexBuilder,
+  Injectable,
   Job,
   Log,
+  Module,
   NotFound,
   Notifications,
   On,
@@ -1736,6 +1975,7 @@ export {
   Param,
   Patch,
   PolicyBuilder,
+  PolicyExprRef,
   Post,
   Put,
   Query,
@@ -1745,6 +1985,7 @@ export {
   RequestId,
   Room,
   Secrets,
+  SerializationFailure,
   Signal,
   Sse,
   SseOut,
@@ -1760,6 +2001,8 @@ export {
   UploadedObject,
   User,
   Webhook,
+  __claimInjectables,
+  __claimModules,
   __getRuntime,
   __requestALS,
   __resetDefaultAuth,
@@ -1768,11 +2011,16 @@ export {
   __runStartHooks,
   __runWithRuntime,
   __setRuntime,
+  assertNoOrphanEntryPoints,
   assertZeroArgConstructor,
   bigint,
   boolean,
+  buildContainer,
   buildModuleClients,
+  col,
+  controllersOf,
   dec,
+  decrement,
   defineChannels,
   defineDefaultAuth,
   defineError,
@@ -1780,16 +2028,25 @@ export {
   defineSchema,
   defineTable,
   enumType,
+  exprCtx,
   getErrorRegistry,
   getHookConfig,
+  getHookManifest,
   getJobConfig,
+  getJobManifest,
   getRegisteredControllers,
   getRoutes,
   getWebhookConfig,
+  getWebhookManifest,
+  hooksOf,
   inc,
+  increment,
+  index,
   installationRef,
   integer,
   isPalbaseExtension,
+  isRetryable,
+  jobsOf,
   jsonb,
   makeEnvDts,
   makeHttpClient,
@@ -1807,12 +2064,16 @@ export {
   raw,
   recordThrows,
   resolveEffectiveAuth,
+  roomsOf,
+  sqlFragment,
   text,
   timestamp,
   toSchemaJSON,
   userRef,
   uuid,
   vector,
+  webhooksOf,
+  withRetry,
   z
 };
 //# sourceMappingURL=index.js.map