@cadenza.io/service 2.10.0 → 2.12.0

package/dist/index.mjs

@@ -1649,7 +1649,7 @@ var ServiceRegistry = class _ServiceRegistry {
       }
     ).emits("meta.service_registry.service_inserted").emitsOnFail("meta.service_registry.service_insertion_failed");
     this.insertServiceInstanceTask = CadenzaService.createCadenzaDBInsertTask(
-      "serviceInstance",
+      "service_instance",
       {},
       {
         inputSchema: {
@@ -2593,20 +2593,44 @@ var RestController = class _RestController {
                 let ctx2;
                 ctx2 = req.body;
                 deputyExecId = ctx2.__metadata.__deputyExecId;
+                const remoteRoutineName = ctx2.__remoteRoutineName;
+                const targetNotFoundSignal = `meta.rest.delegation_target_not_found:${deputyExecId}`;
+                let resolved = false;
+                const resolveDelegation = (endCtx, status) => {
+                  if (resolved || res.headersSent) {
+                    return;
+                  }
+                  resolved = true;
+                  const metadata = endCtx?.__metadata && typeof endCtx.__metadata === "object" ? endCtx.__metadata : {};
+                  if (endCtx?.__metadata) {
+                    delete endCtx.__metadata;
+                  }
+                  res.json({
+                    ...endCtx,
+                    ...metadata,
+                    __status: status
+                  });
+                };
                 CadenzaService.createEphemeralMetaTask(
                   "Resolve delegation",
-                  (endCtx) => {
-                    const metadata = endCtx.__metadata;
-                    delete endCtx.__metadata;
-                    res.json({
-                      ...endCtx,
-                      ...metadata,
-                      __status: "success"
-                    });
-                  },
+                  (endCtx) => resolveDelegation(endCtx, "success"),
                   "Resolves a delegation request",
                   { register: false }
                 ).doOn(`meta.node.graph_completed:${deputyExecId}`).emits(`meta.rest.delegation_resolved:${deputyExecId}`);
+                CadenzaService.createEphemeralMetaTask(
+                  "Resolve delegation target lookup failure",
+                  (endCtx) => resolveDelegation(endCtx, "error"),
+                  "Resolves delegation requests that cannot find a local task or routine",
+                  { register: false }
+                ).doOn(targetNotFoundSignal);
+                if (!CadenzaService.get(remoteRoutineName) && !CadenzaService.registry.routines.get(remoteRoutineName)) {
+                  CadenzaService.emit(targetNotFoundSignal, {
+                    ...ctx2,
+                    __error: `No task or routine registered for delegation target ${remoteRoutineName}.`,
+                    errored: true
+                  });
+                  return;
+                }
                 CadenzaService.emit("meta.rest.delegation_requested", {
                   ...ctx2,
                   __name: ctx2.__remoteRoutineName
@@ -2777,8 +2801,16 @@ var RestController = class _RestController {
                         CadenzaService.runner.run(routine, context);
                         return true;
                       } else {
+                        const deputyExecId = context.__metadata?.__deputyExecId ?? context.__deputyExecId;
+                        const remoteRoutineName = context.__remoteRoutineName ?? context.__name ?? "unknown";
                         context.errored = true;
-                        context.__error = "No routine or task defined.";
+                        context.__error = `No task or routine registered for delegation target ${remoteRoutineName}.`;
+                        if (deputyExecId) {
+                          emit(
+                            `meta.rest.delegation_target_not_found:${deputyExecId}`,
+                            context
+                          );
+                        }
                         emit("meta.runner.failed", context);
                         return false;
                       }
@@ -2801,25 +2833,25 @@ var RestController = class _RestController {
       (ctx) => {
         const { serviceName, serviceAddress, servicePort, protocol } = ctx;
         const port = protocol === "https" ? 443 : servicePort;
-        const URL = `${protocol}://${serviceAddress}:${port}`;
+        const URL2 = `${protocol}://${serviceAddress}:${port}`;
         const fetchId = `${serviceAddress}_${port}`;
         const fetchDiagnostics = this.ensureFetchClientDiagnostics(
           fetchId,
           serviceName,
-          URL
+          URL2
         );
         fetchDiagnostics.destroyed = false;
         fetchDiagnostics.updatedAt = Date.now();
-        if (CadenzaService.get(`Send Handshake to ${URL}`)) {
-          console.error("Fetch client already exists", URL);
+        if (CadenzaService.get(`Send Handshake to ${URL2}`)) {
+          console.error("Fetch client already exists", URL2);
           return;
         }
         const handshakeTask = CadenzaService.createMetaTask(
-          `Send Handshake to ${URL}`,
+          `Send Handshake to ${URL2}`,
           async (ctx2, emit) => {
             try {
               const response = await this.fetchDataWithTimeout(
-                `${URL}/handshake`,
+                `${URL2}/handshake`,
                 {
                   headers: {
                     "Content-Type": "application/json"
@@ -2834,10 +2866,10 @@ var RestController = class _RestController {
                 fetchDiagnostics.connected = false;
                 fetchDiagnostics.lastHandshakeError = error;
                 fetchDiagnostics.updatedAt = Date.now();
-                this.recordFetchClientError(fetchId, serviceName, URL, error);
+                this.recordFetchClientError(fetchId, serviceName, URL2, error);
                 CadenzaService.log(
                   "Fetch handshake failed.",
-                  { error, serviceName, URL },
+                  { error, serviceName, URL: URL2 },
                   "warning"
                 );
                 emit(`meta.fetch.handshake_failed:${fetchId}`, response);
@@ -2852,7 +2884,7 @@ var RestController = class _RestController {
               CadenzaService.log("Fetch client connected.", {
                 response,
                 serviceName,
-                URL
+                URL: URL2
               });
               for (const communicationType of ctx2.communicationTypes) {
                 emit("global.meta.fetch.service_communication_established", {
@@ -2867,10 +2899,10 @@ var RestController = class _RestController {
               fetchDiagnostics.connected = false;
               fetchDiagnostics.lastHandshakeError = this.getErrorMessage(e);
               fetchDiagnostics.updatedAt = Date.now();
-              this.recordFetchClientError(fetchId, serviceName, URL, e);
+              this.recordFetchClientError(fetchId, serviceName, URL2, e);
               CadenzaService.log(
                 "Error in fetch handshake",
-                { error: e, serviceName, URL, ctx: ctx2 },
+                { error: e, serviceName, URL: URL2, ctx: ctx2 },
                 "error"
               );
               return { ...ctx2, __error: e, errored: true };
@@ -2884,7 +2916,7 @@ var RestController = class _RestController {
           "global.meta.fetch.service_communication_established"
         );
         const delegateTask = CadenzaService.createMetaTask(
-          `Delegate flow to REST server ${URL}`,
+          `Delegate flow to REST server ${URL2}`,
           async (ctx2, emit) => {
             if (ctx2.__remoteRoutineName === void 0) {
               return;
@@ -2894,7 +2926,7 @@ var RestController = class _RestController {
             let resultContext;
             try {
               resultContext = await this.fetchDataWithTimeout(
-                `${URL}/delegation`,
+                `${URL2}/delegation`,
                 {
                   headers: {
                     "Content-Type": "application/json"
@@ -2910,7 +2942,7 @@ var RestController = class _RestController {
                 this.recordFetchClientError(
                   fetchId,
                   serviceName,
-                  URL,
+                  URL2,
                   resultContext?.__error ?? resultContext?.error ?? "Delegation failed"
                 );
               }
@@ -2918,7 +2950,7 @@ var RestController = class _RestController {
               console.error("Error in delegation", e);
               fetchDiagnostics.delegationFailures++;
               fetchDiagnostics.updatedAt = Date.now();
-              this.recordFetchClientError(fetchId, serviceName, URL, e);
+              this.recordFetchClientError(fetchId, serviceName, URL2, e);
               resultContext = {
                 __error: `Error: ${e}`,
                 errored: true,
@@ -2939,7 +2971,7 @@ var RestController = class _RestController {
           `meta.service_registry.socket_failed:${fetchId}`
         ).emitsOnFail("meta.fetch.delegate_failed").attachSignal("meta.fetch.delegated");
         const transmitTask = CadenzaService.createMetaTask(
-          `Transmit signal to server ${URL}`,
+          `Transmit signal to server ${URL2}`,
           async (ctx2, emit) => {
             if (ctx2.__signalName === void 0) {
               return;
@@ -2949,7 +2981,7 @@ var RestController = class _RestController {
             let response;
             try {
               response = await this.fetchDataWithTimeout(
-                `${URL}/signal`,
+                `${URL2}/signal`,
                 {
                   headers: {
                     "Content-Type": "application/json"
@@ -2968,7 +3000,7 @@ var RestController = class _RestController {
                 this.recordFetchClientError(
                   fetchId,
                   serviceName,
-                  URL,
+                  URL2,
                   response?.__error ?? response?.error ?? "Signal transmission failed"
                 );
               }
@@ -2976,7 +3008,7 @@ var RestController = class _RestController {
               console.error("Error in transmission", e);
               fetchDiagnostics.signalFailures++;
               fetchDiagnostics.updatedAt = Date.now();
-              this.recordFetchClientError(fetchId, serviceName, URL, e);
+              this.recordFetchClientError(fetchId, serviceName, URL2, e);
               response = {
                 __error: `Error: ${e}`,
                 errored: true,
@@ -2992,14 +3024,14 @@ var RestController = class _RestController {
           "meta.signal_controller.wildcard_signal_registered"
         ).emitsOnFail("meta.fetch.signal_transmission_failed").attachSignal("meta.fetch.transmitted");
         const statusTask = CadenzaService.createMetaTask(
-          `Request status from ${URL}`,
+          `Request status from ${URL2}`,
           async (ctx2) => {
             fetchDiagnostics.statusChecks++;
             fetchDiagnostics.updatedAt = Date.now();
             let status;
             try {
               status = await this.fetchDataWithTimeout(
-                `${URL}/status`,
+                `${URL2}/status`,
                 {
                   method: "GET"
                 },
@@ -3011,14 +3043,14 @@ var RestController = class _RestController {
                 this.recordFetchClientError(
                   fetchId,
                   serviceName,
-                  URL,
+                  URL2,
                   status?.__error ?? status?.error ?? "Status check failed"
                 );
               }
             } catch (e) {
               fetchDiagnostics.statusFailures++;
               fetchDiagnostics.updatedAt = Date.now();
-              this.recordFetchClientError(fetchId, serviceName, URL, e);
+              this.recordFetchClientError(fetchId, serviceName, URL2, e);
               status = {
                 __error: `Error: ${e}`,
                 errored: true,
@@ -3033,7 +3065,7 @@ var RestController = class _RestController {
           fetchDiagnostics.connected = false;
           fetchDiagnostics.destroyed = true;
           fetchDiagnostics.updatedAt = Date.now();
-          CadenzaService.log("Destroying fetch client", { URL, serviceName });
+          CadenzaService.log("Destroying fetch client", { URL: URL2, serviceName });
           handshakeTask.destroy();
           delegateTask.destroy();
           transmitTask.destroy();
@@ -3435,13 +3467,13 @@ var SocketController = class _SocketController {
           Object.assign(base, patch);
           base.fetchId = fetchId;
           base.updatedAt = now;
-          const errorMessage = input.error !== void 0 ? this.getErrorMessage(input.error) : void 0;
-          if (errorMessage) {
-            base.lastError = errorMessage;
+          const errorMessage2 = input.error !== void 0 ? this.getErrorMessage(input.error) : void 0;
+          if (errorMessage2) {
+            base.lastError = errorMessage2;
             base.lastErrorAt = now;
             base.errorHistory.push({
               at: new Date(now).toISOString(),
-              message: errorMessage
+              message: errorMessage2
             });
             if (base.errorHistory.length > this.diagnosticsErrorHistoryLimit) {
               base.errorHistory.splice(
@@ -3943,12 +3975,12 @@ var SocketController = class _SocketController {
                 if (ack) ack(response);
                 resolve(response);
               };
-              const resolveWithError = (errorMessage, fallbackError) => {
+              const resolveWithError = (errorMessage2, fallbackError) => {
                 settle({
                   ...data,
                   errored: true,
-                  __error: errorMessage,
-                  error: fallbackError instanceof Error ? fallbackError.message : errorMessage,
+                  __error: errorMessage2,
+                  error: fallbackError instanceof Error ? fallbackError.message : errorMessage2,
                   socketId: runtimeHandle.socket.id,
                   serviceName,
                   url
@@ -4253,19 +4285,19 @@ var SocketController = class _SocketController {
                       url
                     });
                   } else {
-                    const errorMessage = result?.__error ?? result?.error ?? "Socket handshake failed";
+                    const errorMessage2 = result?.__error ?? result?.error ?? "Socket handshake failed";
                     upsertDiagnostics(
                       {
                         connected: false,
                         handshake: false,
-                        lastHandshakeError: errorMessage
+                        lastHandshakeError: errorMessage2
                       },
-                      errorMessage
+                      errorMessage2
                     );
                     applySessionOperation("handshake", {
                       connected: false,
                       handshake: false,
-                      lastHandshakeError: errorMessage
+                      lastHandshakeError: errorMessage2
                     });
                     CadenzaService.log(
                       "Socket handshake failed",
@@ -4313,15 +4345,15 @@ var SocketController = class _SocketController {
                   });
                 }
                 if (resultContext?.errored || resultContext?.failed) {
-                  const errorMessage = resultContext?.__error ?? resultContext?.error ?? "Socket delegation failed";
+                  const errorMessage2 = resultContext?.__error ?? resultContext?.error ?? "Socket delegation failed";
                   upsertDiagnostics(
                     {
-                      lastHandshakeError: String(errorMessage)
+                      lastHandshakeError: String(errorMessage2)
                     },
-                    errorMessage
+                    errorMessage2
                   );
                   applySessionOperation("delegate", {
-                    lastHandshakeError: String(errorMessage)
+                    lastHandshakeError: String(errorMessage2)
                   });
                 }
                 return resultContext;
@@ -4768,6 +4800,7 @@ var SignalController = class _SignalController {
 };
 
 // src/graph/controllers/GraphMetadataController.ts
+import { META_ACTOR_SESSION_STATE_PERSIST_INTENT } from "@cadenza.io/core";
 var GraphMetadataController = class _GraphMetadataController {
   static get instance() {
     if (!this._instance) this._instance = new _GraphMetadataController();
@@ -5001,6 +5034,123 @@ var GraphMetadataController = class _GraphMetadataController {
         }
       };
     }).doOn("meta.actor.task_associated").emits("global.meta.graph_metadata.actor_task_associated");
+    const actorSessionStateInsertTask = CadenzaService.get("dbInsertActorSessionState") ?? CadenzaService.get("Insert actor_session_state in CadenzaDB") ?? CadenzaService.createCadenzaDBInsertTask(
+      "actor_session_state",
+      {},
+      { concurrency: 100, isSubMeta: true }
+    );
+    const validateActorSessionStatePersistenceTask = CadenzaService.createMetaTask(
+      "Validate actor session state persistence",
+      (ctx) => {
+        if (ctx.errored || ctx.failed || ctx.__success !== true) {
+          throw new Error(
+            String(
+              ctx.__error ?? ctx.error ?? "actor_session_state persistence query failed"
+            )
+          );
+        }
+        const rowCount = Number(ctx.rowCount ?? 0);
+        if (!Number.isFinite(rowCount) || rowCount <= 0) {
+          throw new Error(
+            "actor_session_state persistence did not affect any rows (possible stale durable_version)"
+          );
+        }
+        return {
+          __success: true,
+          persisted: true,
+          actor_name: ctx.actor_name,
+          actor_version: ctx.actor_version,
+          actor_key: ctx.actor_key,
+          service_name: ctx.service_name,
+          durable_version: ctx.durable_version
+        };
+      },
+      "Enforces strict actor session persistence success contract.",
+      { isSubMeta: true, concurrency: 100 }
+    );
+    const insertAndValidateActorSessionStateTask = actorSessionStateInsertTask.then(
+      validateActorSessionStatePersistenceTask
+    );
+    CadenzaService.createMetaTask(
+      "Persist actor session state",
+      (ctx) => {
+        const actorName = typeof ctx.actor_name === "string" ? ctx.actor_name.trim() : "";
+        const actorKey = typeof ctx.actor_key === "string" ? ctx.actor_key.trim() : "";
+        const actorVersion = Number(ctx.actor_version ?? 1);
+        const durableVersion = Number(ctx.durable_version);
+        if (!actorName) {
+          throw new Error("actor_name is required for actor session persistence");
+        }
+        if (!actorKey) {
+          throw new Error("actor_key is required for actor session persistence");
+        }
+        if (!Number.isInteger(actorVersion) || actorVersion < 1) {
+          throw new Error("actor_version must be a positive integer");
+        }
+        if (!Number.isInteger(durableVersion) || durableVersion < 0) {
+          throw new Error("durable_version must be a non-negative integer");
+        }
+        if (typeof ctx.durable_state !== "object" || ctx.durable_state === null || Array.isArray(ctx.durable_state)) {
+          throw new Error("durable_state must be a non-null object");
+        }
+        const serviceName = CadenzaService.serviceRegistry.serviceName;
+        if (!serviceName) {
+          throw new Error("service_name is not available for actor session persistence");
+        }
+        let expiresAt = null;
+        if (ctx.expires_at !== void 0 && ctx.expires_at !== null) {
+          if (ctx.expires_at instanceof Date) {
+            expiresAt = ctx.expires_at.toISOString();
+          } else if (typeof ctx.expires_at === "string" && ctx.expires_at.trim().length > 0) {
+            expiresAt = ctx.expires_at;
+          } else {
+            throw new Error("expires_at must be null, Date, or non-empty string");
+          }
+        }
+        const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return {
+          ...ctx,
+          actor_name: actorName,
+          actor_key: actorKey,
+          actor_version: actorVersion,
+          durable_version: durableVersion,
+          expires_at: expiresAt,
+          service_name: serviceName,
+          queryData: {
+            data: {
+              actor_name: actorName,
+              actor_version: actorVersion,
+              actor_key: actorKey,
+              service_name: serviceName,
+              durable_state: ctx.durable_state,
+              durable_version: durableVersion,
+              expires_at: expiresAt,
+              updated: updatedAt
+            },
+            onConflict: {
+              target: [
+                "actor_name",
+                "actor_version",
+                "actor_key",
+                "service_name"
+              ],
+              action: {
+                do: "update",
+                set: {
+                  durable_state: "excluded",
+                  durable_version: "excluded",
+                  expires_at: "excluded",
+                  updated: "excluded"
+                },
+                where: "actor_session_state.durable_version <= excluded.durable_version"
+              }
+            }
+          }
+        };
+      },
+      "Validates and prepares actor_session_state payload for strict write-through persistence.",
+      { isSubMeta: true, concurrency: 100 }
+    ).then(insertAndValidateActorSessionStateTask).respondsTo(META_ACTOR_SESSION_STATE_PERSIST_INTENT);
     CadenzaService.createMetaTask("Handle Intent Creation", (ctx) => {
       const intentName = ctx.data?.name;
       return {
@@ -5037,566 +5187,175 @@ var SCHEMA_TYPES = [
 
 // src/database/DatabaseController.ts
 import { Pool } from "pg";
-import { camelCase, snakeCase } from "lodash-es";
-function resolveTableQueryIntents(serviceName, tableName, table, defaultInputSchema) {
-  const resolvedServiceName = serviceName ?? "unknown-service";
-  const defaultIntentName = `query-${resolvedServiceName}-${tableName}`;
-  const defaultDescription = `Perform a query operation on the ${tableName} table`;
+import { camelCase, kebabCase, snakeCase } from "lodash-es";
+function normalizeIntentToken(value) {
+  const normalized = kebabCase(String(value ?? "").trim());
+  if (!normalized) {
+    throw new Error("Actor token cannot be empty");
+  }
+  return normalized;
+}
+function validateIntentName(intentName) {
+  if (!intentName || typeof intentName !== "string") {
+    throw new Error("Intent name must be a non-empty string");
+  }
+  if (intentName.length > 100) {
+    throw new Error(`Intent name must be <= 100 characters: ${intentName}`);
+  }
+  if (intentName.includes(" ") || intentName.includes(".") || intentName.includes("\\")) {
+    throw new Error(
+      `Intent name cannot contain spaces, dots or backslashes: ${intentName}`
+    );
+  }
+}
+function defaultOperationIntentDescription(operation, tableName) {
+  return `Perform a ${operation} operation on the ${tableName} table`;
+}
+function readCustomIntentConfig(customIntent) {
+  if (typeof customIntent === "string") {
+    return {
+      intent: customIntent
+    };
+  }
+  return {
+    intent: customIntent.intent,
+    description: customIntent.description,
+    input: customIntent.input
+  };
+}
+function resolveTableOperationIntents(actorName, tableName, table, operation, defaultInputSchema) {
+  const actorToken = normalizeIntentToken(actorName);
+  const defaultIntentName = `${operation}-pg-${actorToken}-${tableName}`;
+  validateIntentName(defaultIntentName);
   const intents = [
     {
       name: defaultIntentName,
-      description: defaultDescription,
+      description: defaultOperationIntentDescription(operation, tableName),
       input: defaultInputSchema
     }
   ];
-  const warnings = [];
-  const names = /* @__PURE__ */ new Set([defaultIntentName]);
-  for (const customIntent of table.customIntents?.query ?? []) {
-    const name = typeof customIntent === "string" ? customIntent.trim() : customIntent.intent?.trim();
-    if (!name) {
-      warnings.push(
-        `Skipped empty custom query intent for table '${tableName}'.`
-      );
-      continue;
-    }
-    if (name.length > 100) {
-      warnings.push(
-        `Skipped custom query intent '${name}' for table '${tableName}': name must be <= 100 characters.`
-      );
-      continue;
-    }
-    if (name.includes(" ") || name.includes(".") || name.includes("\\")) {
-      warnings.push(
-        `Skipped custom query intent '${name}' for table '${tableName}': name cannot contain spaces, dots or backslashes.`
+  const seenNames = /* @__PURE__ */ new Set([defaultIntentName]);
+  const customIntentList = table.customIntents?.[operation] ?? [];
+  for (const rawCustomIntent of customIntentList) {
+    const customIntent = readCustomIntentConfig(rawCustomIntent);
+    const intentName = String(customIntent.intent ?? "").trim();
+    if (!intentName) {
+      throw new Error(
+        `Invalid custom ${operation} intent on table '${tableName}': intent must be a non-empty string`
       );
-      continue;
     }
-    if (names.has(name)) {
-      warnings.push(
-        `Skipped duplicate custom query intent '${name}' for table '${tableName}'.`
+    validateIntentName(intentName);
+    if (seenNames.has(intentName)) {
+      throw new Error(
+        `Duplicate ${operation} intent '${intentName}' on table '${tableName}'`
       );
-      continue;
     }
-    names.add(name);
+    seenNames.add(intentName);
     intents.push({
-      name,
-      description: typeof customIntent === "string" ? `Perform a query operation on the ${tableName} table` : customIntent.description ?? defaultDescription,
-      input: typeof customIntent === "string" ? defaultInputSchema : customIntent.input ?? defaultInputSchema
+      name: intentName,
+      description: customIntent.description ?? defaultOperationIntentDescription(operation, tableName),
+      input: customIntent.input ?? defaultInputSchema
     });
   }
-  return { intents, warnings };
+  return { intents };
+}
+function ensurePlainObject(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function sleep(timeoutMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeoutMs);
+  });
+}
+function normalizePositiveInteger(value, fallback, min = 1) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  const normalized = Math.trunc(value);
+  if (normalized < min) {
+    return fallback;
+  }
+  return normalized;
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function isTransientDatabaseError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const dbError = error;
+  const code = String(dbError.code ?? "");
+  if (["40001", "40P01", "57P03", "53300", "08006", "08001"].includes(code)) {
+    return true;
+  }
+  const message = String(dbError.message ?? "").toLowerCase();
+  return message.includes("timeout") || message.includes("terminating connection") || message.includes("connection reset");
+}
+function isSqlIdentifier(value) {
+  return /^[a-z_][a-z0-9_]*$/.test(value);
+}
+function toSafeSqlIdentifier(value, fallback) {
+  const normalized = snakeCase(value || "").replace(/[^a-z0-9_]/g, "_");
+  const candidate = normalized || fallback;
+  if (!isSqlIdentifier(candidate)) {
+    throw new Error(`Invalid SQL identifier: ${value}`);
+  }
+  return candidate;
+}
+function isSupportedAggregateFunction(value) {
+  const fn = String(value ?? "").toLowerCase();
+  return ["count", "sum", "avg", "min", "max"].includes(fn);
+}
+function buildAggregateAlias(aggregate, index) {
+  const fn = String(aggregate.fn ?? "").toLowerCase();
+  const hasField = typeof aggregate.field === "string" && aggregate.field.trim().length > 0;
+  return toSafeSqlIdentifier(
+    String(aggregate.as ?? `${fn}_${hasField ? aggregate.field : "all"}_${index}`),
+    `${fn || "aggregate"}_${index}`
+  );
+}
+function resolveDataRows(data) {
+  if (!data) {
+    return [];
+  }
+  if (Array.isArray(data)) {
+    return data.map((entry) => ensurePlainObject(entry, "data item"));
+  }
+  return [ensurePlainObject(data, "data")];
 }
 var DatabaseController = class _DatabaseController {
-  /**
-   * Constructor for initializing the `DatabaseService` class.
-   *
-   * This constructor method initializes a sequence of meta tasks to perform the following database-related operations:
-   *
-   * 1. **Database Creation**: Creates a new database with the specified name if it doesn't already exist.
-   *    Validates the database name to ensure it conforms to the required format.
-   * 2. **Database Schema Validation**: Validates the structure and constraints of the schema definition provided.
-   * 3. **Table Dependency Management**: Sorts tables within the schema by their dependencies to ensure proper creation order.
-   * 4. **Schema Definition Processing**:
-   *    - Converts schema definitions into Data Definition Language (DDL) based on table and field specifications.
-   *    - Handles constraints, relationships, and field attributes such as uniqueness, primary keys, nullable fields, etc.
-   * 5. **Index and Primary Key Definition**: Generates SQL for indices and primary keys based on the schema configuration.
-   *
-   * These tasks are encapsulated within a meta routine to provide a structured and procedural approach to database initialization and schema management.
-   */
   constructor() {
-    this.databaseName = "";
-    this.dbClient = new Pool({
+    this.registrationsByService = /* @__PURE__ */ new Map();
+    this.adminDbClient = new Pool({
       connectionString: process.env.DATABASE_ADDRESS ?? "",
       database: "postgres",
       ssl: {
         rejectUnauthorized: false
-        // ← This bypasses the chain validation error
       }
     });
-    CadenzaService.createMetaRoutine(
-      "DatabaseServiceInit",
-      [
-        // TODO: Database health check
-        // TODO: Create database role
-        // TODO: Create schema version table
-        CadenzaService.createMetaTask(
-          "Create database",
-          async (ctx) => {
-            const { databaseName } = ctx;
-            try {
-              if (!databaseName.split("").every((c) => /[a-z_]/.test(c))) {
-                throw new Error(
-                  `Invalid database name ${databaseName}. Names must only contain lowercase alphanumeric characters and underscores`
-                );
-              }
-              console.log(`Creating database ${databaseName}`, {
-                connectionString: process.env.DATABASE_ADDRESS ?? "",
-                database: "postgres"
-              });
-              await this.dbClient.query(`CREATE DATABASE ${databaseName}`);
-              console.log(`Database ${databaseName} created`);
-              this.dbClient = new Pool({
-                connectionString: process.env.DATABASE_ADDRESS ? process.env.DATABASE_ADDRESS.slice(
-                  0,
-                  process.env.DATABASE_ADDRESS.lastIndexOf("/")
-                ) + "/" + databaseName + "?sslmode=disable" : "",
-                ssl: {
-                  rejectUnauthorized: false
-                  // ← This bypasses the chain validation error
-                }
-              });
-              this.databaseName = databaseName;
-              return true;
-            } catch (error) {
-              if (error.code === "42P04") {
-                console.log("Database already exists");
-                return true;
-              }
-              console.error("Failed to create database", error);
-              throw new Error(`Failed to create database: ${error.message}`);
-            }
-          },
-          "Creates the target database if it doesn't exist"
-        ).then(
-          CadenzaService.createMetaTask(
-            "Validate schema",
-            (ctx) => {
-              const { schema } = ctx;
-              if (!schema?.tables || typeof schema.tables !== "object") {
-                throw new Error("Invalid schema: missing or invalid tables");
-              }
-              for (const [tableName, table] of Object.entries(schema.tables)) {
-                if (!table.fields || typeof table.fields !== "object") {
-                  console.log(tableName, "missing fields");
-                  throw new Error(`Invalid table ${tableName}: missing fields`);
-                }
-                for (const [fieldName, field] of Object.entries(table.fields)) {
-                  if (!fieldName.split("").every((c) => /[a-z_]/.test(c))) {
-                    console.log(tableName, "field not lowercase", fieldName);
-                    throw new Error(
-                      `Invalid field name ${fieldName} for ${tableName}. Field names must only contain lowercase alphanumeric characters and underscores`
-                    );
-                  }
-                  if (!Object.values(SCHEMA_TYPES).includes(field.type)) {
-                    console.log(
-                      tableName,
-                      "field invalid type",
-                      fieldName,
-                      field.type
-                    );
-                    throw new Error(
-                      `Invalid type ${field.type} for ${tableName}.${fieldName}`
-                    );
-                  }
-                  if (field.references && !field.references.match(/^[\w]+[(\w)]+$/)) {
-                    console.log(
-                      tableName,
-                      "invalid reference",
-                      fieldName,
-                      field.references
-                    );
-                    throw new Error(
-                      `Invalid reference ${field.references} for ${tableName}.${fieldName}`
-                    );
-                  }
-                  if (table.customSignals) {
-                    for (const op of ["query", "insert", "update", "delete"]) {
-                      const triggers = table.customSignals.triggers?.[op];
-                      const emissions = table.customSignals.emissions?.[op];
-                      if (triggers && !Array.isArray(triggers) && typeof triggers !== "object") {
-                        console.log(
-                          tableName,
-                          "invalid triggers",
-                          op,
-                          triggers
-                        );
-                        throw new Error(
-                          `Invalid triggers for ${tableName}.${op}`
-                        );
-                      }
-                      if (emissions && !Array.isArray(emissions) && typeof emissions !== "object") {
-                        console.log(
-                          tableName,
-                          "invalid emissions",
-                          op,
-                          emissions
-                        );
-                        throw new Error(
-                          `Invalid emissions for ${tableName}.${op}`
-                        );
-                      }
-                    }
-                  }
-                  if (table.customIntents?.query) {
-                    if (!Array.isArray(table.customIntents.query)) {
-                      throw new Error(
-                        `Invalid customIntents.query for ${tableName}: expected array`
-                      );
-                    }
-                    for (const customIntent of table.customIntents.query) {
-                      if (typeof customIntent !== "string" && (typeof customIntent !== "object" || !customIntent || typeof customIntent.intent !== "string")) {
-                        throw new Error(
-                          `Invalid custom query intent on ${tableName}: expected string or object with intent`
-                        );
-                      }
-                    }
-                  }
-                }
-              }
-              console.log("SCHEMA VALIDATED");
-              return true;
-            },
-            "Validates database schema structure and content"
-          ).then(
-            CadenzaService.createMetaTask(
-              "Sort tables by dependencies",
-              this.sortTablesByReferences.bind(this),
-              "Sorts tables by dependencies"
-            ).then(
-              CadenzaService.createMetaTask(
-                "Split schema into tables",
-                this.splitTables.bind(this),
-                "Generates DDL for database schema"
-              ).then(
-                CadenzaService.createMetaTask(
-                  "Generate DDL from table",
-                  async (ctx) => {
-                    const {
-                      ddl,
-                      table,
-                      tableName,
-                      schema,
-                      options,
-                      sortedTables
-                    } = ctx;
-                    const fieldDefs = Object.entries(table.fields).map((value) => {
-                      const [fieldName, field] = value;
-                      let def = `${fieldName} ${field.type.toUpperCase()}`;
-                      if (field.type === "varchar")
-                        def += `(${field.constraints?.maxLength ?? 255})`;
-                      if (field.type === "decimal")
-                        def += `(${field.constraints?.precision ?? 10},${field.constraints?.scale ?? 2})`;
-                      if (field.primary) def += " PRIMARY KEY";
-                      if (field.unique) def += " UNIQUE";
-                      if (field.default !== void 0)
-                        def += ` DEFAULT ${field.default === "" ? "''" : String(field.default)}`;
-                      if (field.required && !field.nullable)
-                        def += " NOT NULL";
-                      if (field.nullable) def += " NULL";
-                      if (field.generated)
-                        def += ` GENERATED ALWAYS AS ${field.generated.toUpperCase()} STORED`;
-                      if (field.references)
-                        def += ` REFERENCES ${field.references} ON DELETE ${field.onDelete || "CASCADE"}`;
-                      if (field.encrypted) def += " ENCRYPTED";
-                      if (field.constraints?.check) {
-                        def += ` CHECK (${field.constraints.check})`;
-                      }
-                      return def;
-                    }).join(", ");
-                    if (schema.meta?.dropExisting) {
-                      const result = await this.dbClient.query(
-                        `DELETE FROM ${tableName};`
-                      );
-                      console.log("DROP TABLE", tableName, result);
-                    }
-                    const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${fieldDefs})`;
-                    ddl.push(sql);
-                    return {
-                      ddl,
-                      table,
-                      tableName,
-                      schema,
-                      options,
-                      sortedTables
-                    };
-                  }
-                ).then(
-                  CadenzaService.createMetaTask("Generate index DDL", (ctx) => {
-                    const {
-                      ddl,
-                      table,
-                      tableName,
-                      schema,
-                      options,
-                      sortedTables
-                    } = ctx;
-                    if (table.indexes) {
-                      table.indexes.forEach((fields) => {
-                        ddl.push(
-                          `CREATE INDEX IF NOT EXISTS idx_${tableName}_${fields.join("_")} ON ${tableName} (${fields.join(", ")});`
-                        );
-                      });
-                    }
-                    return {
-                      ddl,
-                      table,
-                      tableName,
-                      schema,
-                      options,
-                      sortedTables
-                    };
-                  }).then(
-                    CadenzaService.createMetaTask(
-                      "Generate primary key ddl",
-                      (ctx) => {
-                        const {
-                          ddl,
-                          table,
-                          tableName,
-                          schema,
-                          options,
-                          sortedTables
-                        } = ctx;
-                        if (table.primaryKey) {
-                          ddl.push(
-                            `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS unique_${tableName}_${table.primaryKey.join("_")};`,
-                            // TODO: should be cascade?
-                            `ALTER TABLE ${tableName} ADD CONSTRAINT unique_${tableName}_${table.primaryKey.join("_")} PRIMARY KEY (${table.primaryKey.join(", ")});`
-                          );
-                        }
-                        return {
-                          ddl,
-                          table,
-                          tableName,
-                          schema,
-                          options,
-                          sortedTables
-                        };
-                      }
-                    ).then(
-                      CadenzaService.createMetaTask(
-                        "Generate unique index DDL",
-                        (ctx) => {
-                          const {
-                            ddl,
-                            table,
-                            tableName,
-                            schema,
-                            options,
-                            sortedTables
-                          } = ctx;
-                          if (table.uniqueConstraints) {
-                            table.uniqueConstraints.forEach(
-                              (fields) => {
-                                ddl.push(
-                                  `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS unique_${tableName}_${fields.join("_")};`,
-                                  // TODO: should be cascade?
-                                  `ALTER TABLE ${tableName} ADD CONSTRAINT unique_${tableName}_${fields.join("_")} UNIQUE (${fields.join(", ")});`
-                                );
-                              }
-                            );
-                          }
-                          return {
-                            ddl,
-                            table,
-                            tableName,
-                            schema,
-                            options,
-                            sortedTables
-                          };
-                        }
-                      ).then(
-                        CadenzaService.createMetaTask(
-                          "Generate foreign key DDL",
-                          (ctx) => {
-                            const {
-                              ddl,
-                              table,
-                              tableName,
-                              schema,
-                              options,
-                              sortedTables
-                            } = ctx;
-                            if (table.foreignKeys) {
-                              for (const foreignKey of table.foreignKeys) {
-                                const foreignKeyName = `fk_${tableName}_${foreignKey.fields.join("_")}`;
-                                ddl.push(
-                                  `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS ${foreignKeyName};`,
-                                  // TODO: should be cascade?
-                                  `ALTER TABLE ${tableName} ADD CONSTRAINT ${foreignKeyName} FOREIGN KEY (${foreignKey.fields.join(
-                                    ", "
-                                  )}) REFERENCES ${foreignKey.tableName} (${foreignKey.referenceFields.join(
-                                    ", "
-                                  )});`
-                                );
-                              }
-                            }
-                            return {
-                              ddl,
-                              table,
-                              tableName,
-                              schema,
-                              options,
-                              sortedTables
-                            };
-                          }
-                        ).then(
-                          CadenzaService.createMetaTask(
-                            "Generate trigger DDL",
-                            (ctx) => {
-                              const {
-                                ddl,
-                                table,
-                                tableName,
-                                schema,
-                                options,
-                                sortedTables
-                              } = ctx;
-                              if (table.triggers) {
-                                for (const [
-                                  triggerName,
-                                  trigger
-                                ] of Object.entries(table.triggers)) {
-                                  ddl.push(
-                                    `CREATE TRIGGER ${triggerName} ${trigger.when} ${trigger.event} ON ${tableName} FOR EACH STATEMENT EXECUTE FUNCTION ${trigger.function};`
-                                  );
-                                }
-                              }
-                              return {
-                                ddl,
-                                table,
-                                tableName,
-                                schema,
-                                options,
-                                sortedTables
-                              };
-                            }
-                          ).then(
-                            CadenzaService.createMetaTask(
-                              "Generate initial data DDL",
-                              (ctx) => {
-                                const {
-                                  ddl,
-                                  table,
-                                  tableName,
-                                  schema,
-                                  options,
-                                  sortedTables
-                                } = ctx;
-                                if (table.initialData) {
-                                  ddl.push(
-                                    `INSERT INTO ${tableName} (${table.initialData.fields.join(", ")}) VALUES ${table.initialData.data.map(
-                                      (row) => `(${row.map(
-                                        (value) => value === void 0 ? "NULL" : value.charAt(0) === "'" ? value : `'${value}'`
-                                      ).join(", ")})`
-                                      // TODO: handle non string data
-                                    ).join(", ")} ON CONFLICT DO NOTHING;`
-                                  );
-                                }
-                                return {
-                                  ddl,
-                                  table,
-                                  tableName,
-                                  schema,
-                                  options,
-                                  sortedTables
-                                };
-                              }
-                            ).then(
-                              CadenzaService.createUniqueMetaTask(
-                                "Join DDL",
-                                (ctx) => {
-                                  const { joinedContexts } = ctx;
-                                  const ddl = [];
-                                  for (const joinedContext of joinedContexts) {
-                                    ddl.push(...joinedContext.ddl);
-                                  }
-                                  ddl.flat();
-                                  return {
-                                    ddl,
-                                    schema: joinedContexts[0].schema,
-                                    options: joinedContexts[0].options,
-                                    table: joinedContexts[0].table,
-                                    tableName: joinedContexts[0].tableName,
-                                    sortedTables: joinedContexts[0].sortedTables
-                                  };
-                                }
-                              ).then(
-                                CadenzaService.createMetaTask(
-                                  "Apply Database Changes",
-                                  async (ctx) => {
-                                    const { ddl } = ctx;
-                                    if (ddl && ddl.length > 0) {
-                                      for (const sql of ddl) {
-                                        try {
-                                          await this.dbClient.query(sql);
-                                        } catch (error) {
-                                          console.error(
-                                            "Error applying DDL",
-                                            sql,
-                                            error
-                                          );
-                                        }
-                                      }
-                                    }
-                                    return true;
-                                  },
-                                  "Applies generated DDL to the database"
-                                ).then(
-                                  CadenzaService.createMetaTask(
-                                    "Split schema into tables for task creation",
-                                    this.splitTables.bind(this),
-                                    "Splits schema into tables for task creation"
-                                  ).then(
-                                    CadenzaService.createMetaTask(
-                                      "Generate tasks",
-                                      (ctx) => {
-                                        const { table, tableName, options } = ctx;
-                                        this.createDatabaseTask(
-                                          "query",
-                                          tableName,
-                                          table,
-                                          this.queryFunction.bind(this),
-                                          options
-                                        );
-                                        this.createDatabaseTask(
-                                          "insert",
-                                          tableName,
-                                          table,
-                                          this.insertFunction.bind(this),
-                                          options
-                                        );
-                                        this.createDatabaseTask(
-                                          "update",
-                                          tableName,
-                                          table,
-                                          this.updateFunction.bind(this),
-                                          options
-                                        );
-                                        this.createDatabaseTask(
-                                          "delete",
-                                          tableName,
-                                          table,
-                                          this.deleteFunction.bind(this),
-                                          options
-                                        );
-                                        return true;
-                                      },
-                                      "Generates auto-tasks for database schema"
-                                    ).then(
-                                      CadenzaService.createUniqueMetaTask(
-                                        "Join table tasks",
-                                        () => {
-                                          return true;
-                                        }
-                                      ).emits("meta.database.setup_done")
-                                    )
-                                  )
-                                )
-                              )
-                            )
-                          )
-                        )
-                      )
-                    )
-                  )
-                )
-              )
-            )
-          )
-        )
-      ],
-      "Initializes the database service with schema parsing and task/signal generation"
+    CadenzaService.createMetaTask(
+      "Route PostgresActor setup requests",
+      (ctx) => {
+        const serviceName = String(ctx.options?.serviceName ?? ctx.serviceName ?? "");
+        if (!serviceName) {
+          return ctx;
+        }
+        const registration = this.registrationsByService.get(serviceName);
+        if (!registration) {
+          return ctx;
+        }
+        CadenzaService.emit(`meta.postgres_actor.setup_requested.${registration.actorToken}`, ctx);
+        return ctx;
+      },
+      "Routes generic database init requests to actor-scoped setup signal.",
+      { isMeta: true, isSubMeta: true }
     ).doOn("meta.database_init_requested");
   }
   static get instance() {
@@ -5604,632 +5363,1013 @@ var DatabaseController = class _DatabaseController {
     return this._instance;
   }
   reset() {
-    this.dbClient.end();
+    for (const registration of this.registrationsByService.values()) {
+      const runtimeState = registration.actor.getRuntimeState(registration.actorKey);
+      if (runtimeState?.pool) {
+        runtimeState.pool.end().catch(() => void 0);
+      }
+    }
+    this.registrationsByService.clear();
+    this.adminDbClient.end().catch(() => void 0);
   }
-  /**
-   * Asynchronously retrieves a database client from the connection pool with additional logging and timeout capabilities.
-   * The method modifies the client instance by adding timeout tracking and logging functionality to ensure
-   * the client is not held for an extended period and track the last executed query for debugging purposes.
-   *
-   * @return {Promise<PoolClient>} A promise resolving to a database client from the pool with enhanced behavior for query tracking and timeout handling.
-   */
-  async getClient() {
-    const client = await this.dbClient.connect();
-    const query = client.query;
-    const release = client.release;
-    const timeout = setTimeout(() => {
-      CadenzaService.log(
-        "CRITICAL: A database client has been checked out for more than 5 seconds!",
-        {
-          clientId: client.uuid,
-          query: client.lastQuery,
-          databaseName: this.databaseName
-        },
-        "critical"
-      );
-    }, 5e3);
-    client.query = (...args) => {
-      client.lastQuery = args;
-      return query.apply(client, args);
+  createPostgresActor(serviceName, schema, options) {
+    const existing = this.registrationsByService.get(serviceName);
+    if (existing) {
+      return existing;
+    }
+    const actorName = `${serviceName}PostgresActor`;
+    const actorToken = normalizeIntentToken(actorName);
+    const actorKey = String(options.databaseName ?? snakeCase(serviceName));
+    const optionTimeout = typeof options.timeoutMs === "number" ? Number(options.timeoutMs) : Number(options.timeout);
+    const safetyPolicy = {
+      statementTimeoutMs: normalizePositiveInteger(
+        optionTimeout,
+        normalizePositiveInteger(Number(process.env.DATABASE_STATEMENT_TIMEOUT_MS ?? 15e3), 15e3)
+      ),
+      retryCount: normalizePositiveInteger(options.retryCount, 3, 0),
+      retryDelayMs: normalizePositiveInteger(Number(process.env.DATABASE_RETRY_DELAY_MS ?? 100), 100),
+      retryDelayMaxMs: normalizePositiveInteger(
+        Number(process.env.DATABASE_RETRY_DELAY_MAX_MS ?? 1e3),
+        1e3
+      ),
+      retryDelayFactor: Number(process.env.DATABASE_RETRY_DELAY_FACTOR ?? 2)
     };
-    client.release = () => {
-      clearTimeout(timeout);
-      client.query = query;
-      client.release = release;
-      return release.apply(client);
+    const actor = CadenzaService.createActor(
+      {
+        name: actorName,
+        description: "Specialized PostgresActor owning pool runtime state and schema-driven DB task generation.",
+        defaultKey: actorKey,
+        keyResolver: (input) => typeof input.databaseName === "string" ? input.databaseName : void 0,
+        loadPolicy: "eager",
+        writeContract: "overwrite",
+        initState: {
+          actorName,
+          actorToken,
+          serviceName,
+          databaseName: actorKey,
+          status: "idle",
+          schemaVersion: Number(schema.version ?? 1),
+          setupStartedAt: null,
+          setupCompletedAt: null,
+          lastHealthCheckAt: null,
+          lastError: null,
+          tables: Object.keys(schema.tables ?? {}),
+          safetyPolicy
+        }
+      },
+      { isMeta: Boolean(options.isMeta) }
+    );
+    const registration = {
+      serviceName,
+      databaseName: actorKey,
+      actorName,
+      actorToken,
+      actorKey,
+      actor,
+      schema,
+      options,
+      tasksGenerated: false,
+      intentNames: /* @__PURE__ */ new Set()
     };
-    return client;
+    this.registrationsByService.set(serviceName, registration);
+    this.registerSetupTask(registration);
+    return registration;
   }
-  async waitForDatabase(transaction, client, context) {
-    for (let i = 0; i < 10; i++) {
-      try {
-        return await transaction(client, context);
-      } catch (err) {
-        if (err && err.message.includes("does not exist")) {
-          CadenzaService.log("Waiting for database to be ready...");
-          await new Promise((res) => setTimeout(res, 1e3));
-        } else {
-          CadenzaService.log(
-            "Database query errored",
-            { error: err, context },
-            "warning"
+  registerSetupTask(registration) {
+    const setupSignal = `meta.postgres_actor.setup_requested.${registration.actorToken}`;
+    CadenzaService.createMetaTask(
+      `Setup ${registration.actorName}`,
+      registration.actor.task(
+        async ({ input, state, runtimeState, setState, setRuntimeState, emit }) => {
+          const requestedDatabaseName = String(
+            input.options?.databaseName ?? input.databaseName ?? registration.databaseName
           );
-          return { rows: [] };
-        }
+          if (requestedDatabaseName !== registration.databaseName) {
+            return input;
+          }
+          setState({
+            ...state,
+            status: "initializing",
+            setupStartedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            lastError: null
+          });
+          const priorRuntimePool = runtimeState?.pool ?? null;
+          if (priorRuntimePool) {
+            await priorRuntimePool.end().catch(() => void 0);
+          }
+          try {
+            await this.createDatabaseIfMissing(requestedDatabaseName);
+            const pool = this.createTargetPool(
+              requestedDatabaseName,
+              state.safetyPolicy.statementTimeoutMs
+            );
+            await this.checkPoolHealth(pool, state.safetyPolicy);
+            this.validateSchema({
+              schema: registration.schema,
+              options: registration.options
+            });
+            const sortedTables = this.sortTablesByReferences({
+              schema: registration.schema
+            }).sortedTables;
+            const ddlStatements = this.buildSchemaDdlStatements(
+              registration.schema,
+              sortedTables
+            );
+            await this.applyDdlStatements(pool, ddlStatements);
+            if (!registration.tasksGenerated) {
+              this.generateDatabaseTasks(registration);
+              registration.tasksGenerated = true;
+            }
+            const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+            setRuntimeState({
+              pool,
+              ready: true,
+              pendingQueries: 0,
+              lastHealthCheckAt: Date.now(),
+              lastError: null
+            });
+            setState({
+              ...state,
+              status: "ready",
+              setupCompletedAt: nowIso,
+              lastHealthCheckAt: nowIso,
+              lastError: null,
+              tables: Object.keys(registration.schema.tables ?? {})
+            });
+            emit("meta.database.setup_done", {
+              serviceName: registration.serviceName,
+              databaseName: registration.databaseName,
+              actorName: registration.actorName,
+              __success: true
+            });
+            return {
+              ...input,
+              __success: true,
+              actorName: registration.actorName,
+              databaseName: registration.databaseName
+            };
+          } catch (error) {
+            const message = errorMessage(error);
+            setRuntimeState({
+              pool: null,
+              ready: false,
+              pendingQueries: 0,
+              lastHealthCheckAt: runtimeState?.lastHealthCheckAt ?? null,
+              lastError: message
+            });
+            setState({
+              ...state,
+              status: "error",
+              setupCompletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              lastError: message
+            });
+            throw error;
+          }
+        },
+        { mode: "write" }
+      ),
+      "Initializes PostgresActor runtime pool, applies schema, and generates CRUD tasks/intents.",
+      { isMeta: true }
+    ).doOn(setupSignal);
+  }
+  createTargetPool(databaseName, statementTimeoutMs) {
+    const connectionString = this.buildDatabaseConnectionString(databaseName);
+    return new Pool({
+      connectionString,
+      statement_timeout: statementTimeoutMs,
+      query_timeout: statementTimeoutMs,
+      ssl: {
+        rejectUnauthorized: false
+      }
+    });
+  }
+  buildDatabaseConnectionString(databaseName) {
+    const base = process.env.DATABASE_ADDRESS ?? "";
+    if (!base) {
+      throw new Error("DATABASE_ADDRESS environment variable is required");
+    }
+    try {
+      const parsed = new URL(base);
+      parsed.pathname = `/${databaseName}`;
+      if (!parsed.searchParams.has("sslmode")) {
+        parsed.searchParams.set("sslmode", "disable");
+      }
+      return parsed.toString();
+    } catch {
+      const lastSlashIndex = base.lastIndexOf("/");
+      if (lastSlashIndex === -1) {
+        throw new Error("DATABASE_ADDRESS must be a valid postgres connection string");
       }
+      const root = base.slice(0, lastSlashIndex + 1);
+      return `${root}${databaseName}?sslmode=disable`;
     }
-    throw new Error(`Timeout waiting for database to be ready`);
   }
-  /**
-   * Sorts database tables based on their reference dependencies using a topological sort.
-   *
-   * Tables are reordered such that dependent tables appear later in the list
-   * to ensure a dependency hierarchy. If cycles are detected in the dependency graph,
-   * they will be noted but the process will not stop. Unreferenced tables are included at the end.
-   *
-   * @param {Object} ctx - The context object containing the database schema definition and table metadata.
-   *        ctx.schema {Object} - The schema definition object.
-   *        ctx.schema.tables {Object} - A mapping of table names to table definitions.
-   *        Each table definition may contain `fields` (with `references` info)
-   *        and `foreignKeys` indicating cross-table relationships.
-   *
-   * @return {Object} - The modified context object with an additional property:
-   *         sortedTables {string[]} - An array of table names sorted in dependency order.
-   *         hasCycles {boolean} - Indicates if the dependency graph contains cycles.
-   */
-  sortTablesByReferences(ctx) {
-    const schema = ctx.schema;
-    const graph = /* @__PURE__ */ new Map();
-    const allTables = Object.keys(schema.tables);
-    allTables.forEach((table) => graph.set(table, /* @__PURE__ */ new Set()));
-    for (const [tableName, table] of Object.entries(schema.tables)) {
-      for (const field of Object.values(table.fields)) {
-        if (field.references) {
-          const [refTable] = field.references.split("(");
-          if (refTable !== tableName && allTables.includes(refTable)) {
-            graph.get(refTable)?.add(tableName);
-          }
-        }
-      }
-      if (table.foreignKeys) {
-        for (const foreignKey of table.foreignKeys) {
-          const refTable = foreignKey.tableName;
-          if (refTable !== tableName && allTables.includes(refTable)) {
-            graph.get(refTable)?.add(tableName);
-          }
-        }
-      }
+  async createDatabaseIfMissing(databaseName) {
+    if (!isSqlIdentifier(databaseName)) {
+      throw new Error(
+        `Invalid database name '${databaseName}'. Names must contain only lowercase alphanumerics and underscores and cannot start with a number.`
+      );
     }
-    const visited = /* @__PURE__ */ new Set();
-    const tempMark = /* @__PURE__ */ new Set();
-    const sorted = [];
-    let hasCycles = false;
-    function visit(table) {
-      if (tempMark.has(table)) {
-        hasCycles = true;
+    try {
+      await this.adminDbClient.query(`CREATE DATABASE ${databaseName}`);
+      CadenzaService.log(`Database ${databaseName} created.`);
+    } catch (error) {
+      if (error?.code === "42P04") {
+        CadenzaService.log(`Database ${databaseName} already exists.`);
         return;
       }
-      if (visited.has(table)) return;
-      tempMark.add(table);
-      for (const dep of graph.get(table) || []) {
-        visit(dep);
-      }
-      tempMark.delete(table);
-      visited.add(table);
-      sorted.push(table);
+      throw new Error(`Failed to create database '${databaseName}': ${errorMessage(error)}`);
     }
-    for (const table of allTables) {
-      if (!visited.has(table)) {
-        visit(table);
-      }
+  }
+  async checkPoolHealth(pool, safetyPolicy) {
+    await this.runWithRetries(
+      async () => {
+        await this.withTimeout(
+          () => pool.query("SELECT 1 as health"),
+          safetyPolicy.statementTimeoutMs,
+          "Database health check timed out"
+        );
+      },
+      safetyPolicy,
+      "Health check"
+    );
+  }
+  getPoolOrThrow(registration) {
+    const runtimeState = registration.actor.getRuntimeState(
+      registration.actorKey
+    );
+    if (!runtimeState || !runtimeState.ready || !runtimeState.pool) {
+      throw new Error(
+        `PostgresActor '${registration.actorName}' is not ready. Ensure setup completed before running DB tasks.`
+      );
     }
-    for (const table of allTables) {
-      if (!visited.has(table)) {
-        sorted.push(table);
+    return runtimeState.pool;
+  }
+  async withTimeout(work, timeoutMs, timeoutMessage) {
+    let timeoutHandle = null;
+    try {
+      return await Promise.race([
+        work(),
+        new Promise((_, reject) => {
+          timeoutHandle = setTimeout(() => {
+            reject(new Error(timeoutMessage));
+          }, timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
       }
     }
-    sorted.reverse();
-    return { ...ctx, sortedTables: sorted, hasCycles };
   }
-  /**
-   * Asynchronously creates an iterator that splits the provided tables from the schema.
-   *
-   * @param {Object} ctx - The context object containing the necessary data.
-   * @param {string[]} ctx.sortedTables - An array of table names sorted in a specific order.
-   * @param {Object} ctx.schema - The schema object that includes table definitions.
-   * @param {Object} [ctx.options={}] - Optional configuration options for processing tables.
-   *
-   * @return {AsyncGenerator} An asynchronous generator that yields objects containing the table definition, metadata, and other context details.
-   */
-  async *splitTables(ctx) {
-    const { sortedTables, schema, options = {} } = ctx;
-    for (const tableName of sortedTables) {
-      const table = schema.tables[tableName];
-      yield { ddl: [], table, tableName, schema, options, sortedTables };
+  async runWithRetries(work, safetyPolicy, operationLabel) {
+    const attempts = normalizePositiveInteger(safetyPolicy.retryCount, 0, 0) + 1;
+    let delayMs = normalizePositiveInteger(safetyPolicy.retryDelayMs, 100);
+    const maxDelayMs = normalizePositiveInteger(safetyPolicy.retryDelayMaxMs, 1e3);
+    const factor = Number.isFinite(safetyPolicy.retryDelayFactor) ? Math.max(1, safetyPolicy.retryDelayFactor) : 1;
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+      try {
+        return await work();
+      } catch (error) {
+        lastError = error;
+        const transient = isTransientDatabaseError(error);
+        if (!transient || attempt >= attempts) {
+          break;
+        }
+        CadenzaService.log(
+          `${operationLabel} failed with transient error. Retrying...`,
+          {
+            attempt,
+            attempts,
+            delayMs,
+            error: errorMessage(error)
+          },
+          "warning"
+        );
+        await sleep(delayMs);
+        delayMs = Math.min(Math.trunc(delayMs * factor), maxDelayMs);
+      }
     }
+    throw lastError;
   }
-  /**
-   * Converts the keys of objects in an array to camelCase format.
-   *
-   * @param {Array<any>} rows - An array of objects whose keys should be converted to camelCase.
-   * @return {Array<any>} A new array of objects with their keys converted to camelCase.
-   */
-  toCamelCase(rows) {
-    return rows.map((row) => {
-      const camelCasedRow = {};
-      for (const [key, value] of Object.entries(row)) {
-        camelCasedRow[camelCase(key)] = value;
-      }
-      return camelCasedRow;
-    });
+  async executeWithTransaction(pool, transaction, callback) {
+    if (!transaction) {
+      return callback(pool);
+    }
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await callback(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
   }
-  /**
-   * Executes a query against a specified database table with given parameters.
-   *
-   * @param {string} tableName - The name of the database table to query.
-   * @param {DbOperationPayload} context - An object containing query parameters such as filters, fields, joins, sort, limit, and offset.
-   * @return {Promise<any>} A promise that resolves with the query result, including rows, row count, and metadata, or an error object if the query fails.
-   */
-  async queryFunction(tableName, context) {
+  async queryFunction(registration, tableName, context) {
     const {
       filter = {},
       fields = [],
       joins = {},
       sort = {},
       limit,
-      offset
+      offset,
+      queryMode = "rows",
+      aggregates = [],
+      groupBy = []
     } = context;
-    let sql = `SELECT ${fields.length ? fields.join(", ") : "*"} FROM ${tableName}`;
+    const pool = this.getPoolOrThrow(registration);
+    const statementTimeoutMs = this.resolveSafetyPolicy(registration).statementTimeoutMs;
+    const resolvedMode = queryMode;
+    const aggregateDefinitions = Array.isArray(aggregates) ? aggregates : [];
+    const groupByFields = Array.isArray(groupBy) ? groupBy : [];
     const params = [];
-    if (Object.keys(filter).length > 0) {
-      sql += " " + this.buildWhereClause(filter, params);
-    }
-    if (Object.keys(joins).length > 0) {
-      sql += " " + this.buildJoinClause(joins);
+    const whereClause = Object.keys(filter).length > 0 ? this.buildWhereClause(filter, params) : "";
+    const joinClause = Object.keys(joins).length > 0 ? this.buildJoinClause(joins) : "";
+    let sql;
+    if (resolvedMode === "count") {
+      sql = `SELECT COUNT(*)::bigint AS count FROM ${tableName} ${joinClause} ${whereClause}`;
+    } else if (resolvedMode === "exists") {
+      sql = `SELECT EXISTS(SELECT 1 FROM ${tableName} ${joinClause} ${whereClause}) AS exists`;
+    } else if (resolvedMode === "aggregate") {
+      if (aggregateDefinitions.length === 0) {
+        throw new Error("Aggregate queries require at least one aggregate definition");
+      }
+      const aggregateExpressions = aggregateDefinitions.map(
+        (aggregate, index) => {
+          const fn = String(aggregate.fn ?? "").toLowerCase();
+          if (!isSupportedAggregateFunction(fn)) {
+            throw new Error(`Unsupported aggregate function '${aggregate.fn}'`);
+          }
+          const hasField = typeof aggregate.field === "string" && aggregate.field.trim().length > 0;
+          if (fn !== "count" && !hasField) {
+            throw new Error(`Aggregate '${fn}' requires a field`);
+          }
+          const fieldExpression = hasField ? snakeCase(String(aggregate.field)) : "*";
+          const distinctPrefix = aggregate.distinct ? "DISTINCT " : "";
+          const expression = fn === "count" && !hasField ? "COUNT(*)" : `${fn.toUpperCase()}(${distinctPrefix}${fieldExpression})`;
+          const alias = buildAggregateAlias(aggregate, index);
+          return `${expression} AS ${alias}`;
+        }
+      );
+      const groupByExpressions = groupByFields.map((field) => snakeCase(field));
+      const selectExpressions = [...groupByExpressions, ...aggregateExpressions];
+      sql = `SELECT ${selectExpressions.join(", ")} FROM ${tableName} ${joinClause} ${whereClause}`;
+      if (groupByExpressions.length > 0) {
+        sql += ` GROUP BY ${groupByExpressions.join(", ")}`;
+      }
+    } else {
+      sql = `SELECT ${fields.length ? fields.map(snakeCase).join(", ") : "*"} FROM ${tableName} ${joinClause} ${whereClause}`;
     }
-    if (Object.keys(sort).length > 0) {
-      sql += " ORDER BY " + Object.entries(sort).map(([field, direction]) => `${field} ${direction}`).join(", ");
+    if (Object.keys(sort).length > 0 && resolvedMode !== "count" && resolvedMode !== "exists") {
+      sql += " ORDER BY " + Object.entries(sort).map(([field, direction]) => `${snakeCase(field)} ${direction}`).join(", ");
     }
-    if (limit !== void 0) {
+    if (resolvedMode === "one") {
+      sql += ` LIMIT $${params.length + 1}`;
+      params.push(1);
+    } else if (resolvedMode !== "count" && resolvedMode !== "exists" && limit !== void 0) {
       sql += ` LIMIT $${params.length + 1}`;
       params.push(limit);
     }
-    if (offset !== void 0) {
+    if (resolvedMode !== "count" && resolvedMode !== "exists" && offset !== void 0) {
       sql += ` OFFSET $${params.length + 1}`;
       params.push(offset);
     }
     try {
-      const result = await this.dbClient.query(sql, params);
+      const result = await this.withTimeout(
+        () => pool.query(sql, params),
+        statementTimeoutMs,
+        `Query timeout on table ${tableName}`
+      );
       const rows = this.toCamelCase(result.rows);
+      const rowCount = Number(result.rowCount ?? 0);
+      if (resolvedMode === "count") {
+        return {
+          count: Number(rows[0]?.count ?? 0),
+          rowCount: Number(rows[0]?.count ?? 0),
+          __success: true
+        };
+      }
+      if (resolvedMode === "exists") {
+        const exists = Boolean(rows[0]?.exists);
+        return {
+          exists,
+          rowCount: exists ? 1 : 0,
+          __success: true
+        };
+      }
+      if (resolvedMode === "one") {
+        return {
+          [`${camelCase(tableName)}`]: rows[0] ?? null,
+          rowCount,
+          __success: true
+        };
+      }
+      if (resolvedMode === "aggregate") {
+        return {
+          aggregates: rows,
+          rowCount,
+          __success: true
+        };
+      }
       return {
         [`${camelCase(tableName)}s`]: rows,
-        rowCount: result.rowCount,
-        __success: true,
-        ...context
+        rowCount,
+        __success: true
       };
     } catch (error) {
       return {
-        ...context,
+        rowCount: 0,
         errored: true,
-        __error: `Query failed: ${error.message}`,
+        __error: `Query failed: ${errorMessage(error)}`,
         __success: false
       };
     }
   }
-  /**
-   * Inserts data into the specified database table with optional conflict handling.
-   *
-   * @param {string} tableName - The name of the target database table.
-   * @param {DbOperationPayload} context - The context containing data to insert, transaction settings, field mappings, conflict resolution options, and other configurations.
-   *   - `data` (object | array): The data to be inserted into the database.
-   *   - `transaction` (boolean): Specifies whether the operation should use a transaction. Defaults to true.
-   *   - `fields` (array): The fields to return in the result after insertion.
-   *   - `onConflict` (object): Options for handling conflicts on insert.
-   *     - `target` (array): Columns to determine conflicts.
-   *     - `action` (object): Specifies the action to take on conflict, such as updating specified fields.
-   *   - `awaitExists` (object): Specifies foreign key references to wait for to ensure existence before insertion.
-   *
-   * @return {Promise<any>} A promise resolving to the result of the database insert operation, including the inserted rows, the row count, and metadata indicating success or error.
-   */
-  async insertFunction(tableName, context) {
+  async insertFunction(registration, tableName, context) {
     const { data, transaction = true, fields = [], onConflict } = context;
     if (!data || Array.isArray(data) && data.length === 0) {
-      return { errored: true, __error: "No data provided for insert" };
+      return {
+        rowCount: 0,
+        errored: true,
+        __error: "No data provided for insert",
+        __success: false
+      };
     }
-    let resultContext = {};
-    const client = transaction ? await this.getClient() : this.dbClient;
+    const pool = this.getPoolOrThrow(registration);
+    const safetyPolicy = this.resolveSafetyPolicy(registration);
     try {
-      if (transaction) await client.query("BEGIN");
-      const resolvedData = await this.resolveNestedData(data, tableName);
-      const isBatch = Array.isArray(resolvedData);
-      const rows = isBatch ? resolvedData : [resolvedData];
-      const sql = `INSERT INTO ${tableName} (${Object.keys(rows[0]).map(snakeCase).join(", ")}) VALUES `;
-      const values = rows.map(
-        (row) => `(${Object.values(row).map((value, i) => {
-          if (typeof value === "object" && value?.__effect) {
-            if (value.__effect === "increment") {
-              return `${Object.keys(row)[i]} + 1`;
-            }
-            if (value.__effect === "decrement") {
-              return `${Object.keys(row)[i]} - 1`;
-            }
-            if (value.__effect === "set") {
-              return `${Object.keys(row)[i]} = ${value.__value}`;
-            }
+      const resultContext = await this.runWithRetries(
+        async () => this.executeWithTransaction(pool, Boolean(transaction), async (client) => {
+          const resolvedData = await this.resolveNestedData(
+            registration,
+            data,
+            tableName
+          );
+          const rows = Array.isArray(resolvedData) ? resolvedData : [resolvedData];
+          if (rows.length === 0) {
+            throw new Error("No rows available for insert after resolving data");
           }
-          return `$${i + 1}`;
-        }).join(", ")})`
-      ).join(", ");
-      const params = rows.flatMap((row) => Object.values(row));
-      let onConflictSql = "";
-      if (onConflict) {
-        const { target, action } = onConflict;
-        onConflictSql += ` ON CONFLICT (${target.join(", ")})`;
-        if (action.do === "update") {
-          if (!action.set || Object.keys(action.set).length === 0) {
-            throw new Error("Update action requires 'set' fields");
+          const keys = Object.keys(rows[0]);
+          const sqlPrefix = `INSERT INTO ${tableName} (${keys.map((key) => snakeCase(key)).join(", ")}) VALUES `;
+          const params = [];
+          const placeholders = rows.map((row) => {
+            const tuple = keys.map((key) => {
+              params.push(row[key]);
+              return `$${params.length}`;
+            }).join(", ");
+            return `(${tuple})`;
+          }).join(", ");
+          let onConflictSql = "";
+          if (onConflict) {
+            onConflictSql = this.buildOnConflictClause(onConflict, params);
           }
-          const setClauses = Object.entries(action.set).map(
-            ([field, value]) => `${field} = ${value === "excluded" ? "excluded." + field : `$${params.length + 1}`}`
-          ).join(", ");
-          params.push(
-            ...Object.values(action.set).filter(
-              (v) => typeof v !== "string" || !v.startsWith("excluded.")
-            )
+          const sql = `${sqlPrefix}${placeholders}${onConflictSql} RETURNING ${fields.length ? fields.map(snakeCase).join(", ") : "*"}`;
+          const result = await this.withTimeout(
+            () => client.query(sql, params),
+            safetyPolicy.statementTimeoutMs,
+            `Insert timeout on table ${tableName}`
           );
-          onConflictSql += ` DO UPDATE SET ${setClauses}`;
-          if (action.where) onConflictSql += ` WHERE ${action.where}`;
-        } else {
-          onConflictSql += ` DO NOTHING`;
-        }
-      }
-      const result = await client.query(
-        `${sql} ${values}${onConflictSql} RETURNING ${fields.length ? fields.join(", ") : "*"}`,
-        params
+          const resultRows = this.toCamelCase(result.rows);
+          return {
+            [`${camelCase(tableName)}${rows.length > 1 ? "s" : ""}`]: rows.length > 1 ? resultRows : resultRows[0] ?? null,
+            rowCount: result.rowCount,
+            __success: true
+          };
+        }),
+        safetyPolicy,
+        `Insert ${tableName}`
       );
-      if (transaction) await client.query("COMMIT");
-      const resultRows = this.toCamelCase(result.rows);
-      resultContext = {
-        [`${camelCase(tableName)}${isBatch ? "s" : ""}`]: isBatch ? resultRows : resultRows[0],
-        rowCount: result.rowCount,
-        __success: true
-      };
+      return resultContext;
     } catch (error) {
-      if (transaction) await client.query("ROLLBACK");
-      if (error.message.includes("violates unique constraint")) {
-        resultContext = {
-          [`${camelCase(tableName)}`]: null,
-          __success: false
-        };
-      } else {
-        resultContext = {
-          ...context,
-          errored: true,
-          __error: `Insert failed: ${error.message}`,
-          __success: false
-        };
-      }
-    } finally {
-      if (transaction && client) {
-        client.release();
-      }
+      return {
+        rowCount: 0,
+        errored: true,
+        __error: `Insert failed: ${errorMessage(error)}`,
+        __success: false
+      };
     }
-    return resultContext;
   }
-  /**
-   * Updates a database table with the provided data and filter conditions.
-   *
-   * @param {string} tableName - The name of the database table to update.
-   * @param {DbOperationPayload} context - The payload for the update operation, which includes:
-   *        - data: The data to update in the table.
-   *        - filter: The conditions to identify the rows to update (default is an empty object).
-   *        - transaction: Whether the operation should run within a database transaction (default is true).
-   * @return {Promise<any>} Returns a Promise resolving to an object that includes:
-   *         - The updated data if the update is successful.
-   *         - In case of error:
-   *           - Error details.
-   *           - The SQL query and parameters if applicable.
-   *         - A flag indicating if the update succeeded or failed.
-   */
-  async updateFunction(tableName, context) {
+  async updateFunction(registration, tableName, context) {
     const { data, filter = {}, transaction = true } = context;
     if (!data || Object.keys(data).length === 0) {
       return {
+        rowCount: 0,
         errored: true,
-        __error: `No data provided for update of ${tableName}`
+        __error: `No data provided for update of ${tableName}`,
+        __success: false
       };
     }
-    let resultContext = {};
-    const client = transaction ? await this.getClient() : this.dbClient;
+    const pool = this.getPoolOrThrow(registration);
+    const safetyPolicy = this.resolveSafetyPolicy(registration);
     try {
-      if (transaction) await client.query("BEGIN");
-      const resolvedData = await this.resolveNestedData(data, tableName);
-      const params = Object.values(resolvedData);
-      let offset = 0;
-      const setClause = Object.entries(Object.keys(resolvedData)).map(([i, key]) => {
-        const value = resolvedData[key];
-        const offsetIndex = parseInt(i) - offset;
-        if (value.__effect === "increment") {
-          params.splice(offsetIndex, 1);
-          offset++;
-          return `${snakeCase(key)} = ${snakeCase(key)} + 1`;
-        }
-        if (value.__effect === "decrement") {
-          params.splice(offsetIndex, 1);
-          offset++;
-          return `${snakeCase(key)} = ${snakeCase(key)} - 1`;
-        }
-        if (value.__effect === "set") {
-          params.splice(offsetIndex, 1);
-          offset++;
-          return `${snakeCase(key)} = ${value.__value}`;
-        }
-        return `${snakeCase(key)} = $${offsetIndex + 1}`;
-      }).join(", ");
-      const whereClause = this.buildWhereClause(filter, params);
-      const sql = `UPDATE ${tableName} SET ${setClause} ${whereClause} RETURNING *;`;
-      const result = await client.query(sql, params);
-      if (transaction) await client.query("COMMIT");
-      const rows = this.toCamelCase(result.rows);
-      if (rows.length === 0) {
-        resultContext = {
-          sql,
-          params,
-          __success: false
-        };
-      } else {
-        resultContext = {
-          [`${camelCase(tableName)}`]: rows[0],
-          __success: true
-        };
-      }
+      return await this.runWithRetries(
+        async () => this.executeWithTransaction(pool, Boolean(transaction), async (client) => {
+          const resolvedData = await this.resolveNestedData(
+            registration,
+            data,
+            tableName
+          );
+          const params = Object.values(resolvedData);
+          let offset = 0;
+          const setClause = Object.keys(resolvedData).map((key, index) => {
+            const value = resolvedData[key];
+            const offsetIndex = index - offset;
+            if (value?.__effect === "increment") {
+              params.splice(offsetIndex, 1);
+              offset += 1;
+              return `${snakeCase(key)} = ${snakeCase(key)} + 1`;
+            }
+            if (value?.__effect === "decrement") {
+              params.splice(offsetIndex, 1);
+              offset += 1;
+              return `${snakeCase(key)} = ${snakeCase(key)} - 1`;
+            }
+            if (value?.__effect === "set") {
+              params.splice(offsetIndex, 1);
+              offset += 1;
+              return `${snakeCase(key)} = ${value.__value}`;
+            }
+            return `${snakeCase(key)} = $${offsetIndex + 1}`;
+          }).join(", ");
+          const whereClause = this.buildWhereClause(filter, params);
+          const sql = `UPDATE ${tableName} SET ${setClause} ${whereClause} RETURNING *`;
+          const result = await this.withTimeout(
+            () => client.query(sql, params),
+            safetyPolicy.statementTimeoutMs,
+            `Update timeout on table ${tableName}`
+          );
+          const rows = this.toCamelCase(result.rows);
+          const rowCount = Number(result.rowCount ?? 0);
+          return {
+            [`${camelCase(tableName)}`]: rows[0] ?? null,
+            rowCount,
+            __success: rowCount > 0
+          };
+        }),
+        safetyPolicy,
+        `Update ${tableName}`
+      );
     } catch (error) {
-      if (transaction) await client.query("ROLLBACK");
-      resultContext = {
-        ...context,
+      return {
+        rowCount: 0,
         errored: true,
-        __error: `Update failed: ${error.message}`,
+        __error: `Update failed: ${errorMessage(error)}`,
         __success: false
       };
-    } finally {
-      if (transaction && client) {
-        client.release();
-      }
     }
-    return resultContext;
   }
-  /**
-   * Deletes a record from the specified database table based on the given filter criteria.
-   *
-   * @param {string} tableName - The name of the database table from which records should be deleted.
-   * @param {DbOperationPayload} context - The context for the operation, including filter conditions and transaction settings.
-   * @param {Object} context.filter - The filter criteria to identify the records to delete.
-   * @param {boolean} [context.transaction=true] - Indicates if the operation should be executed within a transaction.
-   * @return {Promise<any>} A promise that resolves to an object containing information about the deleted record
-   * or an error object if the delete operation fails.
-   */
-  async deleteFunction(tableName, context) {
+  async deleteFunction(registration, tableName, context) {
     const { filter = {}, transaction = true } = context;
     if (Object.keys(filter).length === 0) {
-      return { errored: true, __error: "No filter provided for delete" };
+      return {
+        rowCount: 0,
+        errored: true,
+        __error: "No filter provided for delete",
+        __success: false
+      };
     }
-    let resultContext = {};
-    const client = transaction ? await this.getClient() : this.dbClient;
+    const pool = this.getPoolOrThrow(registration);
+    const safetyPolicy = this.resolveSafetyPolicy(registration);
     try {
-      if (transaction) await client.query("BEGIN");
-      const params = [];
-      const whereClause = this.buildWhereClause(filter, params);
-      const sql = `DELETE FROM ${tableName} ${whereClause} RETURNING *`;
-      const result = await client.query(sql, params);
-      if (transaction) await client.query("COMMIT");
-      const rows = this.toCamelCase(result.rows);
-      resultContext = {
-        [`${camelCase(tableName)}`]: rows[0],
-        __success: true
-      };
+      return await this.runWithRetries(
+        async () => this.executeWithTransaction(pool, Boolean(transaction), async (client) => {
+          const params = [];
+          const whereClause = this.buildWhereClause(filter, params);
+          const sql = `DELETE FROM ${tableName} ${whereClause} RETURNING *`;
+          const result = await this.withTimeout(
+            () => client.query(sql, params),
+            safetyPolicy.statementTimeoutMs,
+            `Delete timeout on table ${tableName}`
+          );
+          const rows = this.toCamelCase(result.rows);
+          return {
+            [`${camelCase(tableName)}`]: rows[0] ?? null,
+            rowCount: result.rowCount,
+            __success: true
+          };
+        }),
+        safetyPolicy,
+        `Delete ${tableName}`
+      );
     } catch (error) {
-      if (transaction) await client.query("ROLLBACK");
-      resultContext = {
+      return {
+        rowCount: 0,
         errored: true,
-        __error: `Delete failed: ${error.message}`,
-        __errors: { delete: error.message },
+        __error: `Delete failed: ${errorMessage(error)}`,
         __success: false
       };
-    } finally {
-      if (transaction && client) {
-        client.release();
+    }
+  }
+  resolveSafetyPolicy(registration) {
+    const durableState = registration.actor.getState(
+      registration.actorKey
+    );
+    return {
+      statementTimeoutMs: normalizePositiveInteger(
+        durableState.safetyPolicy?.statementTimeoutMs,
+        15e3
+      ),
+      retryCount: normalizePositiveInteger(durableState.safetyPolicy?.retryCount, 3, 0),
+      retryDelayMs: normalizePositiveInteger(durableState.safetyPolicy?.retryDelayMs, 100),
+      retryDelayMaxMs: normalizePositiveInteger(
+        durableState.safetyPolicy?.retryDelayMaxMs,
+        1e3
+      ),
+      retryDelayFactor: Number.isFinite(durableState.safetyPolicy?.retryDelayFactor) ? Math.max(1, Number(durableState.safetyPolicy?.retryDelayFactor)) : 1
+    };
+  }
+  buildOnConflictClause(onConflict, params) {
+    const { target, action } = onConflict;
+    let sql = ` ON CONFLICT (${target.map(snakeCase).join(", ")})`;
+    if (action.do === "update") {
+      if (!action.set || Object.keys(action.set).length === 0) {
+        throw new Error("Update action requires 'set' fields");
+      }
+      const assignments = Object.entries(action.set).map(([field, value]) => {
+        if (typeof value === "string" && value === "excluded") {
+          return `${snakeCase(field)} = excluded.${snakeCase(field)}`;
+        }
+        params.push(value);
+        return `${snakeCase(field)} = $${params.length}`;
+      });
+      sql += ` DO UPDATE SET ${assignments.join(", ")}`;
+      if (action.where) {
+        sql += ` WHERE ${action.where}`;
       }
+      return sql;
     }
-    return resultContext;
+    sql += " DO NOTHING";
+    return sql;
   }
   /**
-   * Constructs a SQL WHERE clause based on the provided filter object.
-   * Builds parameterized queries to prevent SQL injection, appending parameters
-   * to the provided params array and utilizing placeholders.
-   *
-   * @param {Object} filter - An object representing the filtering conditions with
-   *                          keys as column names and values as their corresponding
-   *                          desired values. Values can also be arrays for `IN` queries.
-   * @param {any[]} params - An array for storing parameterized values, which will be
-   *                         populated with the filter values for the constructed SQL clause.
-   * @return {string} The constructed SQL WHERE clause as a string. If no conditions
-   *                  are provided, an empty string is returned.
+   * Validates database schema structure and content.
    */
-  buildWhereClause(filter, params) {
-    const conditions = [];
-    for (const [key, value] of Object.entries(filter)) {
-      if (value !== void 0) {
-        if (Array.isArray(value)) {
-          conditions.push(
-            `${snakeCase(key)} IN (${value.map((v) => {
-              const val = `$${params.length + 1}`;
-              params.push(v);
-              return val;
-            }).join(", ")})`
+  validateSchema(ctx) {
+    const schema = ctx.schema;
+    if (!schema?.tables || typeof schema.tables !== "object") {
+      throw new Error("Invalid schema: missing or invalid tables");
+    }
+    for (const [tableName, table] of Object.entries(schema.tables)) {
+      if (!isSqlIdentifier(tableName)) {
+        throw new Error(
+          `Invalid table name ${tableName}. Table names must use lowercase snake_case identifiers.`
+        );
+      }
+      if (!table.fields || typeof table.fields !== "object") {
+        throw new Error(`Invalid table ${tableName}: missing fields`);
+      }
+      for (const [fieldName, field] of Object.entries(table.fields)) {
+        if (!isSqlIdentifier(fieldName)) {
+          throw new Error(
+            `Invalid field name ${fieldName} for ${tableName}. Field names must use lowercase snake_case identifiers.`
+          );
+        }
+        if (!SCHEMA_TYPES.includes(field.type)) {
+          throw new Error(`Invalid type ${field.type} for ${tableName}.${fieldName}`);
+        }
+        if (field.references && !field.references.match(/^[\w]+\([\w]+\)$/)) {
+          throw new Error(
+            `Invalid reference ${field.references} for ${tableName}.${fieldName}`
           );
-        } else {
-          conditions.push(`${snakeCase(key)} = $${params.length + 1}`);
-          params.push(value);
+        }
+      }
+      for (const operation of ["query", "insert", "update", "delete"]) {
+        const customIntents = table.customIntents?.[operation] ?? [];
+        if (!Array.isArray(customIntents)) {
+          throw new Error(
+            `Invalid customIntents.${operation} for table ${tableName}: expected array`
+          );
+        }
+        for (const customIntent of customIntents) {
+          const parsed = readCustomIntentConfig(
+            customIntent
+          );
+          validateIntentName(String(parsed.intent ?? ""));
         }
       }
     }
-    return conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    return true;
   }
-  /**
-   * Constructs a SQL join clause from a given set of join definitions.
-   *
-   * @param {Record<string, JoinDefinition>} joins - An object where keys are table names
-   *                                                  and values are definitions of join conditions.
-   * @return {string} The constructed SQL join clause as a string.
-   */
-  buildJoinClause(joins) {
-    let joinSql = "";
-    for (const [table, join] of Object.entries(joins)) {
-      joinSql += ` LEFT JOIN ${snakeCase(table)} ${join.alias} ON ${join.on}`;
-      if (join.joins) joinSql += " " + this.buildJoinClause(join.joins);
+  sortTablesByReferences(ctx) {
+    const schema = ctx.schema;
+    const graph = /* @__PURE__ */ new Map();
+    const allTables = Object.keys(schema.tables);
+    allTables.forEach((table) => graph.set(table, /* @__PURE__ */ new Set()));
+    for (const [tableName, table] of Object.entries(schema.tables)) {
+      for (const field of Object.values(table.fields)) {
+        if (field.references) {
+          const [refTable] = field.references.split("(");
+          if (refTable !== tableName && allTables.includes(refTable)) {
+            graph.get(refTable)?.add(tableName);
+          }
+        }
+      }
+      if (table.foreignKeys) {
+        for (const foreignKey of table.foreignKeys) {
+          const refTable = foreignKey.tableName;
+          if (refTable !== tableName && allTables.includes(refTable)) {
+            graph.get(refTable)?.add(tableName);
+          }
+        }
+      }
     }
-    return joinSql;
+    const visited = /* @__PURE__ */ new Set();
+    const tempMark = /* @__PURE__ */ new Set();
+    const sorted = [];
+    let hasCycles = false;
+    const visit = (table) => {
+      if (tempMark.has(table)) {
+        hasCycles = true;
+        return;
+      }
+      if (visited.has(table)) return;
+      tempMark.add(table);
+      for (const dependent of graph.get(table) || []) {
+        visit(dependent);
+      }
+      tempMark.delete(table);
+      visited.add(table);
+      sorted.push(table);
+    };
+    for (const table of allTables) {
+      if (!visited.has(table)) {
+        visit(table);
+      }
+    }
+    for (const table of allTables) {
+      if (!visited.has(table)) {
+        sorted.push(table);
+      }
+    }
+    sorted.reverse();
+    return { ...ctx, sortedTables: sorted, hasCycles };
   }
-  /**
-   * Recursively resolves nested data structure by processing special operations and transforming the data accordingly.
-   * Handles specific object structures with sub-operations, strings with specific commands, and other nested objects.
-   *
-   * @param {any} data The initial data to be resolved, which can be an object, array, or primitive value.
-   * @param {string} tableName The name of the table associated with the data, used contextually for operation resolution.
-   * @return {Promise<any>} A promise that resolves to the fully processed data structure with all nested elements resolved.
-   */
-  async resolveNestedData(data, tableName) {
-    if (Array.isArray(data))
-      return Promise.all(data.map((d) => this.resolveNestedData(d, tableName)));
-    if (typeof data !== "object" || data === null) return data;
-    const resolved = { ...data };
-    for (const [key, value] of Object.entries(data)) {
-      if (typeof value === "object" && value !== null && "subOperation" in value) {
-        const subOp = value;
-        resolved[key] = await this.executeSubOperation(subOp);
-      } else if (typeof value === "string" && ["increment", "decrement", "set"].includes(value)) {
-        resolved[key] = { __effect: value };
-      } else if (typeof value === "object") {
-        resolved[key] = await this.resolveNestedData(value, tableName);
+  buildSchemaDdlStatements(schema, sortedTables) {
+    const ddl = [];
+    for (const tableName of sortedTables) {
+      const table = schema.tables[tableName];
+      const fieldDefs = Object.entries(table.fields).map(([fieldName, field]) => this.fieldDefinitionToSql(fieldName, field)).join(", ");
+      ddl.push(`CREATE TABLE IF NOT EXISTS ${tableName} (${fieldDefs});`);
+      for (const indexFields of table.indexes ?? []) {
+        ddl.push(
+          `CREATE INDEX IF NOT EXISTS idx_${tableName}_${indexFields.join("_")} ON ${tableName} (${indexFields.map(snakeCase).join(", ")});`
+        );
+      }
+      if (table.primaryKey) {
+        ddl.push(
+          `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS pk_${tableName}_${table.primaryKey.join("_")};`,
+          `ALTER TABLE ${tableName} ADD CONSTRAINT pk_${tableName}_${table.primaryKey.join("_")} PRIMARY KEY (${table.primaryKey.map(snakeCase).join(", ")});`
+        );
+      }
+      for (const uniqueFields of table.uniqueConstraints ?? []) {
+        ddl.push(
+          `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS uq_${tableName}_${uniqueFields.join("_")};`,
+          `ALTER TABLE ${tableName} ADD CONSTRAINT uq_${tableName}_${uniqueFields.join("_")} UNIQUE (${uniqueFields.map(snakeCase).join(", ")});`
+        );
+      }
+      for (const foreignKey of table.foreignKeys ?? []) {
+        const fkName = `fk_${tableName}_${foreignKey.fields.join("_")}`;
+        ddl.push(
+          `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS ${fkName};`,
+          `ALTER TABLE ${tableName} ADD CONSTRAINT ${fkName} FOREIGN KEY (${foreignKey.fields.map(snakeCase).join(", ")}) REFERENCES ${foreignKey.tableName} (${foreignKey.referenceFields.map(snakeCase).join(", ")});`
+        );
+      }
+      for (const [triggerName, trigger] of Object.entries(table.triggers ?? {})) {
+        ddl.push(
+          `CREATE OR REPLACE TRIGGER ${triggerName} ${trigger.when} ${trigger.event} ON ${tableName} FOR EACH STATEMENT EXECUTE FUNCTION ${trigger.function};`
+        );
+      }
+      if (table.initialData) {
+        ddl.push(
+          `INSERT INTO ${tableName} (${table.initialData.fields.map(snakeCase).join(", ")}) VALUES ${table.initialData.data.map(
+            (row) => `(${row.map((value) => {
+              if (value === void 0) return "NULL";
+              if (value === null) return "NULL";
+              if (typeof value === "number") return String(value);
+              if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+              const stringValue = String(value);
+              return `'${stringValue.replace(/'/g, "''")}'`;
+            }).join(", ")})`
+          ).join(", ")} ON CONFLICT DO NOTHING;`
+        );
       }
     }
-    return resolved;
+    return ddl;
   }
-  /**
-   * Executes a sub-operation against the database, such as an insert or query operation.
-   *
-   * @param {SubOperation} op - The operation to be executed. Contains details such as the type of sub-operation
-   * (e.g., "insert" or "query"), the target table, data to be inserted, filters for querying, fields to be retrieved, etc.
-   * @return {Promise<any>} A promise that resolves with the result of the operation.
-   * For "insert", the result will include the inserted row or a partial response for uuid conflicts.
-   * For "query", the result will include the first row that matches the query condition. If no result is found,
-   * resolves with an empty object.
-   * @throws Throws an error if the operation fails. Rolls back the transaction in case of an error.
-   */
-  async executeSubOperation(op) {
-    const client = await this.getClient();
-    try {
-      await client.query("BEGIN");
-      let result;
-      if (op.subOperation === "insert") {
-        const resolvedData = await this.resolveNestedData(op.data, op.table);
-        const sql = `INSERT INTO ${op.table} (${Object.keys(resolvedData).map((k) => snakeCase(k)).join(", ")}) VALUES (${Object.values(resolvedData).map((_, i) => `$${i + 1}`).join(", ")}) ON CONFLICT DO NOTHING RETURNING ${op.return ?? "*"}`;
-        result = await client.query(sql, Object.values(resolvedData));
-        result = result.rows[0]?.[op.return ?? "uuid"];
-        if (!result) {
-          result = op.return && op.return in resolvedData ? resolvedData[op.return] : resolvedData["uuid"];
-        }
-      } else if (op.subOperation === "query") {
-        const params = [];
-        const whereClause = this.buildWhereClause(op.filter || {}, params);
-        const sql = `SELECT ${op.fields?.join(", ") || "*"} FROM ${op.table} ${whereClause} LIMIT 1`;
-        result = (await client.query(sql, params)).rows[0]?.[op.return ?? "uuid"];
+  fieldDefinitionToSql(fieldName, field) {
+    let definition = `${snakeCase(fieldName)} ${field.type.toUpperCase()}`;
+    if (field.type === "varchar") {
+      definition += `(${field.constraints?.maxLength ?? 255})`;
+    }
+    if (field.type === "decimal") {
+      definition += `(${field.constraints?.precision ?? 10},${field.constraints?.scale ?? 2})`;
+    }
+    if (field.primary) definition += " PRIMARY KEY";
+    if (field.unique) definition += " UNIQUE";
+    if (field.default !== void 0) {
+      definition += ` DEFAULT ${field.default === "" ? "''" : String(field.default)}`;
+    }
+    if (field.required && !field.nullable) definition += " NOT NULL";
+    if (field.nullable) definition += " NULL";
+    if (field.generated) {
+      definition += ` GENERATED ALWAYS AS ${field.generated.toUpperCase()} STORED`;
+    }
+    if (field.references) {
+      definition += ` REFERENCES ${field.references} ON DELETE ${field.onDelete || "CASCADE"}`;
+    }
+    if (field.constraints?.check) {
+      definition += ` CHECK (${field.constraints.check})`;
+    }
+    return definition;
+  }
+  async applyDdlStatements(pool, statements) {
+    for (const sql of statements) {
+      try {
+        await pool.query(sql);
+      } catch (error) {
+        CadenzaService.log(
+          "Error applying DDL statement",
+          {
+            sql,
+            error: errorMessage(error)
+          },
+          "error"
+        );
+        throw error;
       }
-      await client.query("COMMIT");
-      return result || {};
-    } catch (error) {
-      await client.query("ROLLBACK");
-      throw error;
-    } finally {
-      client.release();
     }
   }
-  /**
-   * Creates a database task configured for specific operations such as query, insert, update, or delete on a given table.
-   *
-   * @param {DbOperationType} op - The type of database operation to perform (e.g., "query", "insert", "update", "delete").
-   * @param {string} tableName - The name of the table on which the operation will be performed.
-   * @param {TableDefinition} table - The table definition that includes configurations such as custom signal triggers and emissions.
-   * @param {function(string, AnyObject): Promise<any>} queryFunction - The function to execute the database operation. It takes the table name and a context object as arguments and returns a promise.
-   * @param {ServerOptions} options - The options for configuring the server context and metadata behavior.
-   * @return {void} This function does not return a value, but it registers a database task for the specified operation.
-   */
-  createDatabaseTask(op, tableName, table, queryFunction, options) {
-    const opAction = op === "query" ? "queried" : op === "insert" ? "inserted" : op === "update" ? "updated" : op === "delete" ? "deleted" : "";
-    const defaultSignal = `global.${options.isMeta ? "meta." : ""}${tableName}.${opAction}`;
+  generateDatabaseTasks(registration) {
+    for (const [tableName, table] of Object.entries(registration.schema.tables)) {
+      this.createDatabaseTask(registration, "query", tableName, table);
+      this.createDatabaseTask(registration, "insert", tableName, table);
+      this.createDatabaseTask(registration, "update", tableName, table);
+      this.createDatabaseTask(registration, "delete", tableName, table);
+      this.createDatabaseMacroTasks(registration, tableName, table);
+    }
+  }
+  createDatabaseMacroTasks(registration, tableName, table) {
+    const querySchema = this.getInputSchema("query", tableName, table);
+    const insertSchema = this.getInputSchema("insert", tableName, table);
+    const queryMacroOperations = [
+      "count",
+      "exists",
+      "one",
+      "aggregate"
+    ];
+    for (const macroOperation of queryMacroOperations) {
+      const intentName = `${macroOperation}-pg-${registration.actorToken}-${tableName}`;
+      if (registration.intentNames.has(intentName)) {
+        throw new Error(
+          `Duplicate macro intent '${intentName}' detected for table '${tableName}' in actor '${registration.actorName}'`
+        );
+      }
+      registration.intentNames.add(intentName);
+      CadenzaService.defineIntent({
+        name: intentName,
+        description: `Macro ${macroOperation} operation for table ${tableName}`,
+        input: querySchema
+      });
+      CadenzaService.createThrottledTask(
+        `${macroOperation.toUpperCase()} ${tableName}`,
+        registration.actor.task(
+          async ({ input }) => {
+            const payload = typeof input.queryData === "object" && input.queryData ? input.queryData : input;
+            const result = await this.queryFunction(registration, tableName, {
+              ...payload,
+              queryMode: macroOperation
+            });
+            return {
+              ...input,
+              ...result
+            };
+          },
+          { mode: "read" }
+        ),
+        (context) => context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? "default",
+        `Macro ${macroOperation} task for ${tableName}`,
+        {
+          isMeta: registration.options.isMeta,
+          isSubMeta: registration.options.isMeta,
+          validateInputContext: registration.options.securityProfile !== "low",
+          inputSchema: querySchema
+        }
+      ).respondsTo(intentName);
+    }
+    const upsertIntentName = `upsert-pg-${registration.actorToken}-${tableName}`;
+    if (registration.intentNames.has(upsertIntentName)) {
+      throw new Error(
+        `Duplicate macro intent '${upsertIntentName}' detected for table '${tableName}' in actor '${registration.actorName}'`
+      );
+    }
+    registration.intentNames.add(upsertIntentName);
+    CadenzaService.defineIntent({
+      name: upsertIntentName,
+      description: `Macro upsert operation for table ${tableName}`,
+      input: insertSchema
+    });
+    CadenzaService.createThrottledTask(
+      `UPSERT ${tableName}`,
+      registration.actor.task(
+        async ({ input }) => {
+          const payload = typeof input.queryData === "object" && input.queryData ? input.queryData : input;
+          if (!payload.onConflict) {
+            return {
+              ...input,
+              errored: true,
+              __success: false,
+              __error: `Macro upsert requires 'onConflict' payload for table '${tableName}'`
+            };
+          }
+          const result = await this.insertFunction(registration, tableName, payload);
+          return {
+            ...input,
+            ...result
+          };
+        },
+        { mode: "write" }
+      ),
+      (context) => context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? "default",
+      `Macro upsert task for ${tableName}`,
+      {
+        isMeta: registration.options.isMeta,
+        isSubMeta: registration.options.isMeta,
+        validateInputContext: registration.options.securityProfile !== "low",
+        inputSchema: insertSchema
+      }
+    ).respondsTo(upsertIntentName);
+  }
+  createDatabaseTask(registration, op, tableName, table) {
+    const opAction = op === "query" ? "queried" : op === "insert" ? "inserted" : op === "update" ? "updated" : "deleted";
+    const defaultSignal = `global.${registration.options.isMeta ? "meta." : ""}${tableName}.${opAction}`;
     const taskName = `${op.charAt(0).toUpperCase() + op.slice(1)} ${tableName}`;
     const schema = this.getInputSchema(op, tableName, table);
-    const task = CadenzaService.createThrottledTask(
-      taskName,
-      async (context, emit) => {
+    const databaseTaskFunction = registration.actor.task(
+      async ({ input, emit }) => {
+        let context = { ...input };
+        let payloadModifiedByTriggers = false;
         for (const action of Object.keys(table.customSignals?.triggers ?? {})) {
-          const triggerConditions = (
-            // @ts-ignore
-            table.customSignals?.triggers?.[action].filter(
-              (trigger) => trigger.condition
-            )
-          );
-          for (const triggerCondition of triggerConditions ?? []) {
-            if (triggerCondition.condition && !triggerCondition.condition(context)) {
+          const triggerDefinitions = table.customSignals?.triggers?.[action];
+          for (const trigger of triggerDefinitions ?? []) {
+            if (typeof trigger === "string") {
+              continue;
+            }
+            if (trigger.condition && !trigger.condition(context)) {
               return {
                 failed: true,
-                error: `Condition for signal trigger failed: ${triggerCondition.signal}`
+                __success: false,
+                __error: `Condition for signal trigger failed: ${trigger.signal}`
               };
             }
-          }
-          const triggerQueryData = (
-            // @ts-ignore
-            table.customSignals?.triggers?.[action].filter(
-              (trigger) => trigger.queryData
-            )
-          );
-          for (const queryData of triggerQueryData ?? []) {
-            if (context.queryData) {
+            if (trigger.queryData) {
               context.queryData = {
-                ...context.queryData,
-                ...queryData
-              };
-            } else {
-              context = {
-                ...context,
-                ...queryData
+                ...context.queryData ?? {},
+                ...trigger.queryData
               };
+              payloadModifiedByTriggers = true;
             }
           }
         }
-        try {
-          const result = await queryFunction(
-            tableName,
-            context.queryData ?? context
-          );
-          context = {
-            ...context,
-            ...result
-          };
-        } catch (e) {
-          CadenzaService.log(
-            "Database task errored.",
-            { taskName, error: e },
-            "error"
-          );
-          throw e;
+        const operationPayload = typeof context.queryData === "object" && context.queryData ? context.queryData : context;
+        this.validateOperationPayload(
+          registration,
+          op,
+          tableName,
+          table,
+          operationPayload,
+          {
+            enforceFieldAllowlist: registration.options.securityProfile === "low" || payloadModifiedByTriggers
+          }
+        );
+        let result;
+        if (op === "query") {
+          result = await this.queryFunction(registration, tableName, operationPayload);
+        } else if (op === "insert") {
+          result = await this.insertFunction(registration, tableName, operationPayload);
+        } else if (op === "update") {
+          result = await this.updateFunction(registration, tableName, operationPayload);
+        } else {
+          result = await this.deleteFunction(registration, tableName, operationPayload);
         }
+        context = {
+          ...context,
+          ...result
+        };
         if (!context.errored) {
           for (const signal of table.customSignals?.emissions?.[op] ?? []) {
+            if (typeof signal === "string") {
+              emit(signal, context);
+              continue;
+            }
             if (signal.condition && !signal.condition(context)) {
               continue;
             }
-            emit(signal.signal ?? signal, context);
+            emit(signal.signal, context);
           }
         }
         if (tableName !== "system_log" && context.errored) {
@@ -6259,49 +6399,263 @@ var DatabaseController = class _DatabaseController {
         delete context.offset;
         return context;
       },
+      { mode: op === "query" ? "read" : "write" }
+    );
+    const task = CadenzaService.createThrottledTask(
+      taskName,
+      databaseTaskFunction,
       (context) => context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? "default",
-      `Auto-generated ${op} task for ${tableName}`,
+      `Auto-generated ${op} task for ${tableName} (PostgresActor)`,
       {
-        isMeta: options.isMeta,
-        isSubMeta: options.isMeta,
-        validateInputContext: options.securityProfile !== "low",
+        isMeta: registration.options.isMeta,
+        isSubMeta: registration.options.isMeta,
+        validateInputContext: registration.options.securityProfile !== "low",
         inputSchema: schema
       }
     ).doOn(
-      ...table.customSignals?.triggers?.[op]?.map((signal) => {
-        return typeof signal === "string" ? signal : signal.signal;
-      }) ?? []
+      ...table.customSignals?.triggers?.[op]?.map(
+        (signal) => typeof signal === "string" ? signal : signal.signal
+      ) ?? []
     ).emits(defaultSignal).attachSignal(
-      ...table.customSignals?.emissions?.[op]?.map((signal) => {
-        return typeof signal === "string" ? signal : signal.signal;
-      }) ?? []
+      ...table.customSignals?.emissions?.[op]?.map(
+        (signal) => typeof signal === "string" ? signal : signal.signal
+      ) ?? []
     );
-    if (op === "query") {
-      const { intents, warnings } = resolveTableQueryIntents(
-        CadenzaService.serviceRegistry?.serviceName,
-        tableName,
-        table,
-        schema
-      );
-      for (const warning of warnings) {
-        CadenzaService.log(
-          "Skipped custom query intent registration.",
-          {
-            tableName,
-            warning
-          },
-          "warning"
+    const { intents } = resolveTableOperationIntents(
+      registration.actorName,
+      tableName,
+      table,
+      op,
+      schema
+    );
+    for (const intent of intents) {
+      if (registration.intentNames.has(intent.name)) {
+        throw new Error(
+          `Duplicate auto/custom intent '${intent.name}' detected while generating ${op} task for table '${tableName}' in actor '${registration.actorName}'`
         );
       }
-      for (const intent of intents) {
-        CadenzaService.defineIntent({
-          name: intent.name,
-          description: intent.description,
-          input: intent.input
-        });
+      registration.intentNames.add(intent.name);
+      CadenzaService.defineIntent({
+        name: intent.name,
+        description: intent.description,
+        input: intent.input
+      });
+    }
+    task.respondsTo(...intents.map((intent) => intent.name));
+  }
+  validateOperationPayload(registration, operation, tableName, table, payload, options) {
+    const allowedFields = new Set(Object.keys(table.fields));
+    const resolvedMode = payload.queryMode ?? "rows";
+    if (!["rows", "count", "exists", "one", "aggregate"].includes(resolvedMode)) {
+      throw new Error(`Unsupported queryMode '${String(payload.queryMode)}'`);
+    }
+    const assertAllowedField = (fieldName, label) => {
+      if (!allowedFields.has(fieldName)) {
+        throw new Error(
+          `Invalid field '${fieldName}' in ${label} for ${operation} on ${tableName}`
+        );
+      }
+    };
+    const aggregateDefinitions = Array.isArray(payload.aggregates) ? payload.aggregates : [];
+    const aggregateSortAllowlist = /* @__PURE__ */ new Set();
+    if (resolvedMode === "aggregate") {
+      if (aggregateDefinitions.length === 0) {
+        throw new Error(
+          `Aggregate queryMode requires at least one aggregate on table '${tableName}'`
+        );
+      }
+      for (const groupField of payload.groupBy ?? []) {
+        assertAllowedField(groupField, "groupBy");
+        aggregateSortAllowlist.add(groupField);
+      }
+      for (const [index, aggregate] of aggregateDefinitions.entries()) {
+        if (!isSupportedAggregateFunction(aggregate.fn)) {
+          throw new Error(
+            `Unsupported aggregate function '${String(aggregate.fn)}' on table '${tableName}'`
+          );
+        }
+        if (aggregate.fn !== "count" && !aggregate.field) {
+          throw new Error(
+            `Aggregate '${aggregate.fn}' requires field on table '${tableName}'`
+          );
+        }
+        if (aggregate.field) {
+          assertAllowedField(aggregate.field, "aggregates.field");
+        }
+        aggregateSortAllowlist.add(buildAggregateAlias(aggregate, index));
+      }
+    } else if (aggregateDefinitions.length > 0 || (payload.groupBy ?? []).length > 0) {
+      throw new Error(
+        `aggregates/groupBy payload requires queryMode='aggregate' on table '${tableName}'`
+      );
+    }
+    if (options.enforceFieldAllowlist) {
+      if (payload.fields) {
+        for (const field of payload.fields) {
+          assertAllowedField(field, "fields");
+        }
+      }
+      if (payload.filter) {
+        for (const field of Object.keys(payload.filter)) {
+          assertAllowedField(field, "filter");
+        }
+      }
+      if (payload.data) {
+        const rows = resolveDataRows(payload.data);
+        for (const row of rows) {
+          for (const field of Object.keys(row)) {
+            assertAllowedField(field, "data");
+          }
+        }
+      }
+    }
+    if (payload.sort) {
+      for (const field of Object.keys(payload.sort)) {
+        if (resolvedMode === "aggregate" && aggregateSortAllowlist.has(field)) {
+          continue;
+        }
+        assertAllowedField(field, "sort");
+      }
+    }
+    if (payload.onConflict) {
+      for (const conflictField of payload.onConflict.target ?? []) {
+        assertAllowedField(conflictField, "onConflict.target");
+      }
+      for (const setField of Object.keys(payload.onConflict.action?.set ?? {})) {
+        assertAllowedField(setField, "onConflict.action.set");
+      }
+    }
+    if (payload.joins) {
+      this.validateJoinPayload(registration.schema, payload.joins);
+    }
+  }
+  validateJoinPayload(schema, joins) {
+    for (const [joinTableName, joinDefinition] of Object.entries(joins)) {
+      if (!schema.tables[joinTableName]) {
+        throw new Error(`Invalid join table '${joinTableName}'. Table does not exist in schema.`);
+      }
+      const joinTable = schema.tables[joinTableName];
+      for (const field of joinDefinition.fields ?? []) {
+        if (!joinTable.fields[field]) {
+          throw new Error(
+            `Invalid join field '${field}' on joined table '${joinTableName}'`
+          );
+        }
+      }
+      if (joinDefinition.filter) {
+        for (const filterField of Object.keys(joinDefinition.filter)) {
+          if (!joinTable.fields[filterField]) {
+            throw new Error(
+              `Invalid join filter field '${filterField}' on joined table '${joinTableName}'`
+            );
+          }
+        }
+      }
+      if (joinDefinition.joins) {
+        this.validateJoinPayload(schema, joinDefinition.joins);
+      }
+    }
+  }
+  toCamelCase(rows) {
+    return rows.map((row) => {
+      const camelCasedRow = {};
+      for (const [key, value] of Object.entries(row)) {
+        camelCasedRow[camelCase(key)] = value;
+      }
+      return camelCasedRow;
+    });
+  }
+  buildWhereClause(filter, params) {
+    const conditions = [];
+    for (const [key, value] of Object.entries(filter)) {
+      if (value !== void 0) {
+        if (Array.isArray(value)) {
+          const placeholders = value.map((entry) => {
+            params.push(entry);
+            return `$${params.length}`;
+          }).join(", ");
+          conditions.push(`${snakeCase(key)} IN (${placeholders})`);
+        } else {
+          params.push(value);
+          conditions.push(`${snakeCase(key)} = $${params.length}`);
+        }
+      }
+    }
+    return conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  }
+  buildJoinClause(joins) {
+    let joinSql = "";
+    for (const [table, join] of Object.entries(joins)) {
+      const alias = join.alias ? ` ${join.alias}` : "";
+      joinSql += ` LEFT JOIN ${snakeCase(table)}${alias} ON ${join.on}`;
+      if (join.joins) joinSql += " " + this.buildJoinClause(join.joins);
+    }
+    return joinSql;
+  }
+  async resolveNestedData(registration, data, tableName) {
+    if (Array.isArray(data)) {
+      return Promise.all(
+        data.map((entry) => this.resolveNestedData(registration, entry, tableName))
+      );
+    }
+    if (typeof data !== "object" || data === null) {
+      return data;
+    }
+    const resolved = { ...data };
+    for (const [key, value] of Object.entries(data)) {
+      if (typeof value === "object" && value !== null && "subOperation" in value) {
+        const subOperation = value;
+        resolved[key] = await this.executeSubOperation(registration, subOperation);
+      } else if (typeof value === "string" && ["increment", "decrement", "set"].includes(value)) {
+        resolved[key] = { __effect: value };
+      } else if (typeof value === "object" && value !== null) {
+        resolved[key] = await this.resolveNestedData(registration, value, tableName);
       }
-      task.respondsTo(...intents.map((intent) => intent.name));
     }
+    return resolved;
+  }
+  async executeSubOperation(registration, operation) {
+    const targetTableName = operation.table;
+    if (!registration.schema.tables[targetTableName]) {
+      throw new Error(
+        `Sub-operation table '${targetTableName}' does not exist in actor schema`
+      );
+    }
+    const pool = this.getPoolOrThrow(registration);
+    const safetyPolicy = this.resolveSafetyPolicy(registration);
+    return this.executeWithTransaction(pool, true, async (client) => {
+      if (operation.subOperation === "insert") {
+        const resolvedData = await this.resolveNestedData(
+          registration,
+          operation.data,
+          operation.table
+        );
+        const row = ensurePlainObject(resolvedData, "sub-operation insert data");
+        const keys = Object.keys(row);
+        const params = Object.values(row);
+        const sql2 = `INSERT INTO ${operation.table} (${keys.map((key) => snakeCase(key)).join(", ")}) VALUES (${params.map((_, index) => `$${index + 1}`).join(", ")}) ON CONFLICT DO NOTHING RETURNING ${operation.return ?? "*"}`;
+        const result2 = await this.withTimeout(
+          () => client.query(sql2, params),
+          safetyPolicy.statementTimeoutMs,
+          `Sub-operation insert timeout on table ${operation.table}`
+        );
+        const returnKey2 = operation.return ?? "uuid";
+        if (result2.rows[0]?.[returnKey2] !== void 0) {
+          return result2.rows[0][returnKey2];
+        }
+        return row[returnKey2] ?? row.uuid ?? {};
+      }
+      const queryParams = [];
+      const whereClause = this.buildWhereClause(operation.filter || {}, queryParams);
+      const sql = `SELECT ${(operation.fields ?? ["*"]).map((field) => field === "*" ? field : snakeCase(field)).join(", ")} FROM ${operation.table} ${whereClause} LIMIT 1`;
+      const result = await this.withTimeout(
+        () => client.query(sql, queryParams),
+        safetyPolicy.statementTimeoutMs,
+        `Sub-operation query timeout on table ${operation.table}`
+      );
+      const returnKey = operation.return ?? "uuid";
+      return result.rows[0]?.[returnKey] ?? {};
+    });
   }
   getInputSchema(op, tableName, table) {
     const inputSchema = {
@@ -6320,66 +6674,43 @@ var DatabaseController = class _DatabaseController {
     }
     inputSchema.properties.transaction = getTransactionSchema();
     inputSchema.properties.queryData.properties.transaction = inputSchema.properties.transaction;
-    switch (op) {
-      case "insert":
-        inputSchema.properties.data = getInsertDataSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.data = inputSchema.properties.data;
-        inputSchema.properties.batch = getQueryBatchSchemaFromTable();
-        inputSchema.properties.queryData.properties.batch = inputSchema.properties.batch;
-        inputSchema.properties.onConflict = getQueryOnConflictSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.onConflict = inputSchema.properties.onConflict;
-        break;
-      case "query":
-        inputSchema.properties.filter = getQueryFilterSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.filter = inputSchema.properties.filter;
-        inputSchema.properties.fields = getQueryFieldsSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.fields = inputSchema.properties.fields;
-        inputSchema.properties.joins = getQueryJoinsSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.joins = inputSchema.properties.joins;
-        inputSchema.properties.sort = getQuerySortSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.sort = inputSchema.properties.sort;
-        inputSchema.properties.limit = getQueryLimitSchemaFromTable();
-        inputSchema.properties.queryData.properties.limit = inputSchema.properties.limit;
-        inputSchema.properties.offset = getQueryOffsetSchemaFromTable();
-        inputSchema.properties.queryData.properties.offset = inputSchema.properties.offset;
-        break;
-      case "update":
-        inputSchema.properties.filter = getQueryFilterSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.filter = inputSchema.properties.filter;
-        inputSchema.properties.fields = getQueryFieldsSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.fields = inputSchema.properties.fields;
-        break;
-      case "delete":
-        inputSchema.properties.filter = getQueryFilterSchemaFromTable(
-          table,
-          tableName
-        );
-        inputSchema.properties.queryData.properties.filter = inputSchema.properties.filter;
-        break;
+    if (op === "insert" || op === "update") {
+      inputSchema.properties.data = getInsertDataSchemaFromTable(table, tableName);
+      inputSchema.properties.queryData.properties.data = inputSchema.properties.data;
+    }
+    if (op === "insert") {
+      inputSchema.properties.batch = getQueryBatchSchemaFromTable();
+      inputSchema.properties.queryData.properties.batch = inputSchema.properties.batch;
+      inputSchema.properties.onConflict = getQueryOnConflictSchemaFromTable(
+        table,
+        tableName
+      );
+      inputSchema.properties.queryData.properties.onConflict = inputSchema.properties.onConflict;
+    }
+    if (op === "query" || op === "update" || op === "delete") {
+      inputSchema.properties.filter = getQueryFilterSchemaFromTable(table, tableName);
+      inputSchema.properties.queryData.properties.filter = inputSchema.properties.filter;
+    }
+    if (op === "query") {
+      inputSchema.properties.queryMode = getQueryModeSchema();
+      inputSchema.properties.queryData.properties.queryMode = inputSchema.properties.queryMode;
+      inputSchema.properties.fields = getQueryFieldsSchemaFromTable(table, tableName);
+      inputSchema.properties.queryData.properties.fields = inputSchema.properties.fields;
+      inputSchema.properties.joins = getQueryJoinsSchemaFromTable(table, tableName);
+      inputSchema.properties.queryData.properties.joins = inputSchema.properties.joins;
+      inputSchema.properties.sort = getQuerySortSchemaFromTable(table, tableName);
+      inputSchema.properties.queryData.properties.sort = inputSchema.properties.sort;
+      inputSchema.properties.aggregates = getQueryAggregatesSchemaFromTable(
+        table,
+        tableName
+      );
+      inputSchema.properties.queryData.properties.aggregates = inputSchema.properties.aggregates;
+      inputSchema.properties.groupBy = getQueryGroupBySchemaFromTable(table, tableName);
+      inputSchema.properties.queryData.properties.groupBy = inputSchema.properties.groupBy;
+      inputSchema.properties.limit = getQueryLimitSchemaFromTable();
+      inputSchema.properties.queryData.properties.limit = inputSchema.properties.limit;
+      inputSchema.properties.offset = getQueryOffsetSchemaFromTable();
+      inputSchema.properties.queryData.properties.offset = inputSchema.properties.offset;
     }
     return inputSchema;
   }
@@ -6389,13 +6720,13 @@ function getInsertDataSchemaFromTable(table, tableName) {
     type: "object",
     properties: {
       ...Object.fromEntries(
-        Object.entries(table.fields).map((field) => {
+        Object.entries(table.fields).map(([fieldName, field]) => {
           return [
-            field[0],
+            fieldName,
             {
               value: {
-                type: tableFieldTypeToSchemaType(field[1].type),
-                description: `Inferred from field '${field[0]}' of type [${field[1].type}] on table ${tableName}.`
+                type: tableFieldTypeToSchemaType(field.type),
+                description: `Inferred from field '${fieldName}' of type [${field.type}] on table ${tableName}.`
               },
               effect: {
                 type: "string",
@@ -6444,7 +6775,7 @@ function getInsertDataSchemaFromTable(table, tableName) {
         })
       )
     },
-    required: Object.entries(table.fields).filter((field) => field[1].required || field[1].primary).map((field) => field[0]),
+    required: Object.entries(table.fields).filter(([, field]) => field.required || field.primary).map(([fieldName]) => fieldName),
     strict: true
   };
   return {
@@ -6460,18 +6791,18 @@ function getQueryFilterSchemaFromTable(table, tableName) {
     type: "object",
     properties: {
       ...Object.fromEntries(
-        Object.entries(table.fields).map((field) => {
+        Object.entries(table.fields).map(([fieldName, field]) => {
           return [
-            field[0],
+            fieldName,
             {
               value: {
-                type: tableFieldTypeToSchemaType(field[1].type),
-                description: `Inferred from field '${field[0]}' of type [${field[1].type}] on table ${tableName}.`
+                type: tableFieldTypeToSchemaType(field.type),
+                description: `Inferred from field '${fieldName}' of type [${field.type}] on table ${tableName}.`
               },
               in: {
                 type: "array",
                 items: {
-                  type: tableFieldTypeToSchemaType(field[1].type)
+                  type: tableFieldTypeToSchemaType(field.type)
                 }
               }
             }
@@ -6480,7 +6811,7 @@ function getQueryFilterSchemaFromTable(table, tableName) {
       )
     },
     strict: true,
-    description: `Inferred from table '${tableName}' on database service ${CadenzaService.serviceRegistry?.serviceName ?? "unknown-service"}.`
+    description: `Inferred from table '${tableName}' on postgres actor table contract.`
   };
 }
 function getQueryFieldsSchemaFromTable(table, tableName) {
@@ -6492,106 +6823,100 @@ function getQueryFieldsSchemaFromTable(table, tableName) {
         oneOf: Object.keys(table.fields)
       }
     },
-    description: `Inferred from table '${tableName}' on database service ${CadenzaService.serviceRegistry?.serviceName ?? "unknown-service"}.`
+    description: `Inferred field projection from table '${tableName}'.`
   };
 }
-function getQueryJoinsSchemaFromTable(table, tableName) {
+function getQueryModeSchema() {
   return {
-    type: "object",
-    properties: {
-      ...Object.fromEntries(
-        Object.entries(table.fields).map((field) => {
-          return [
-            field[0],
-            {
-              type: "object",
-              properties: {
-                on: {
-                  type: "string"
-                },
-                fields: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                },
-                filter: {
-                  type: "object"
-                },
-                returnAs: {
-                  type: "string",
-                  constraints: {
-                    oneOf: ["array", "object"]
-                  }
-                },
-                alias: {
-                  type: "string"
-                },
-                joins: {
-                  type: "object"
-                }
-              },
-              required: ["on", "fields"],
-              strict: true
-            }
-          ];
-        })
-      )
+    type: "string",
+    constraints: {
+      oneOf: ["rows", "count", "exists", "one", "aggregate"]
+    }
+  };
+}
+function getQueryAggregatesSchemaFromTable(table, tableName) {
+  return {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        fn: {
+          type: "string",
+          constraints: {
+            oneOf: ["count", "sum", "avg", "min", "max"]
+          }
+        },
+        field: {
+          type: "string",
+          constraints: {
+            oneOf: Object.keys(table.fields)
+          }
+        },
+        as: {
+          type: "string"
+        },
+        distinct: {
+          type: "boolean"
+        }
+      },
+      required: ["fn"],
+      strict: true
     },
-    strict: true,
-    description: `Inferred from table '${tableName}' on database service ${CadenzaService.serviceRegistry?.serviceName ?? "unknown-service"}.`
+    description: `Aggregate definitions inferred from table '${tableName}'.`
   };
 }
-function getQuerySortSchemaFromTable(table, tableName) {
+function getQueryGroupBySchemaFromTable(table, tableName) {
   return {
-    type: "object",
-    properties: {
-      ...Object.fromEntries(
-        Object.entries(table.fields).map((field) => {
-          return [
-            field[0],
-            {
-              type: "string",
-              constraints: {
-                oneOf: ["asc", "desc"]
-              }
-            }
-          ];
-        })
-      )
+    type: "array",
+    items: {
+      type: "string",
+      constraints: {
+        oneOf: Object.keys(table.fields)
+      }
     },
-    strict: true,
-    description: `Inferred from table '${tableName}' on database service ${CadenzaService.serviceRegistry?.serviceName ?? "unknown-service"}.`
+    description: `Group by fields inferred from table '${tableName}'.`
+  };
+}
+function getQueryJoinsSchemaFromTable(_table, tableName) {
+  return {
+    type: "object",
+    description: `Join definitions for table '${tableName}'.`
+  };
+}
+function getQuerySortSchemaFromTable(_table, tableName) {
+  return {
+    type: "object",
+    strict: false,
+    description: `Sort definition for table '${tableName}'. Keys are validated at runtime against allowlists and aggregate aliases.`
   };
 }
 function getQueryLimitSchemaFromTable() {
   return {
     type: "number",
     constraints: {
-      min: 1
-    },
-    description: "Limit for query results"
+      min: 0,
+      max: 1e3
+    }
   };
 }
 function getQueryOffsetSchemaFromTable() {
   return {
     type: "number",
     constraints: {
-      min: 0
-    },
-    description: "Offset for query results"
+      min: 0,
+      max: 1e6
+    }
   };
 }
-function getTransactionSchema() {
+function getQueryBatchSchemaFromTable() {
   return {
-    type: "boolean",
-    description: "Whether to run the query in a transaction"
+    type: "boolean"
   };
 }
-function getQueryBatchSchemaFromTable() {
+function getTransactionSchema() {
   return {
     type: "boolean",
-    description: "Whether to run the query in batch mode"
+    description: "Execute the operation in a transaction."
   };
 }
 function getQueryOnConflictSchemaFromTable(table, tableName) {
@@ -6617,55 +6942,43 @@ function getQueryOnConflictSchemaFromTable(table, tableName) {
             }
           },
           set: {
-            type: "object",
-            properties: {
-              ...Object.fromEntries(
-                Object.entries(table.fields).map((field) => {
-                  return [
-                    field[0],
-                    {
-                      type: tableFieldTypeToSchemaType(field[1].type),
-                      description: `Inferred from field '${field[0]}' of type [${field[1].type}] on table ${tableName}.`
-                    }
-                  ];
-                })
-              )
-            }
+            type: "object"
           },
           where: {
             type: "string"
           }
-        },
-        required: ["do"]
+        }
       }
     },
-    required: ["target", "action"],
-    strict: true
+    strict: true,
+    description: `Conflict strategy for inserts on table '${tableName}'.`
   };
 }
 function tableFieldTypeToSchemaType(type) {
   switch (type) {
     case "varchar":
     case "text":
-    case "jsonb":
     case "uuid":
+    case "timestamp":
     case "date":
     case "geo_point":
-    case "bytea":
       return "string";
     case "int":
     case "bigint":
     case "decimal":
-    case "timestamp":
       return "number";
     case "boolean":
       return "boolean";
     case "array":
       return "array";
     case "object":
+    case "jsonb":
       return "object";
+    case "bytea":
+      return "string";
+    default:
+      return "any";
   }
-  return "any";
 }
 
 // src/Cadenza.ts
@@ -8241,16 +8554,16 @@ var CadenzaService = class {
     this.createCadenzaService(serviceName, description, options);
   }
   /**
-   * Creates and initializes a database service with the provided name, schema, and configuration options.
-   * This method is not supported in a browser environment and will log a warning if called in such an environment.
+   * Creates and initializes a PostgresActor-backed database service.
+   * This is the canonical API for schema-driven postgres setup in cadenza-service.
    *
-   * @param {string} name - The name of the database service to be created.
-   * @param {DatabaseSchemaDefinition} schema - The schema definition for the database service.
-   * @param {string} [description=""] - An optional description of the database service.
-   * @param {ServerOptions & DatabaseOptions} [options={}] - Optional configuration settings for the database and server.
-   * @return {void} This method does not return a value.
+   * @param {string} name - Logical actor/service name.
+   * @param {DatabaseSchemaDefinition} schema - Database schema definition.
+   * @param {string} [description=""] - Optional human-readable description.
+   * @param {ServerOptions & DatabaseOptions} [options={}] - Server/database runtime options.
+   * @return {void}
    */
-  static createDatabaseService(name, schema, description = "", options = {}) {
+  static createPostgresActor(name, schema, description = "", options = {}) {
     if (isBrowser) {
       console.warn(
         "Database service creation is not supported in the browser. Use the CadenzaDB service instead."
@@ -8260,7 +8573,7 @@ var CadenzaService = class {
     if (this.serviceCreated) return;
     this.bootstrap();
     this.serviceRegistry.serviceName = name;
-    DatabaseController.instance;
+    const databaseController = DatabaseController.instance;
     options = {
       loadBalance: true,
       useSocket: true,
@@ -8281,14 +8594,23 @@ var CadenzaService = class {
       isDatabase: true,
       ...options
     };
-    console.log("Creating database service", options);
+    const registration = databaseController.createPostgresActor(
+      name,
+      schema,
+      options
+    );
+    console.log("Creating PostgresActor", {
+      serviceName: name,
+      actorName: registration.actorName,
+      options
+    });
     this.emit("meta.database_init_requested", {
       schema,
       databaseName: options.databaseName,
       options
     });
     this.createMetaTask("Set database connection", () => {
-      this.createMetaTask("Insert database service", (_, emit) => {
+      this.createMetaTask("Insert database service bridge", (_, emit) => {
         emit("global.meta.created_database_service", {
           data: {
             service_name: name,
@@ -8299,12 +8621,33 @@ var CadenzaService = class {
         });
         this.log("Database service created", {
           name,
-          isMeta: options.isMeta
+          isMeta: options.isMeta,
+          actorName: registration.actorName
         });
       }).doOn("meta.service_registry.service_inserted");
       this.createCadenzaService(name, description, options);
     }).doOn("meta.database.setup_done");
   }
+  /**
+   * Creates a meta PostgresActor service.
+   *
+   * @param {string} name - Logical actor/service name.
+   * @param {DatabaseSchemaDefinition} schema - Database schema definition.
+   * @param {string} [description=""] - Optional description.
+   * @param {ServerOptions & DatabaseOptions} [options={}] - Optional server/database options.
+   * @return {void}
+   */
+  static createMetaPostgresActor(name, schema, description = "", options = {}) {
+    this.bootstrap();
+    options.isMeta = true;
+    this.createPostgresActor(name, schema, description, options);
+  }
+  /**
+   * Legacy compatibility wrapper. Prefer {@link createPostgresActor}.
+   */
+  static createDatabaseService(name, schema, description = "", options = {}) {
+    this.createPostgresActor(name, schema, description, options);
+  }
   /**
    * Creates a meta database service with the specified configuration.
    *
@@ -8315,9 +8658,7 @@ var CadenzaService = class {
    * @return {void} - This method does not return a value.
    */
   static createMetaDatabaseService(name, schema, description = "", options = {}) {
-    this.bootstrap();
-    options.isMeta = true;
-    this.createDatabaseService(name, schema, description, options);
+    this.createMetaPostgresActor(name, schema, description, options);
   }
   static createActor(spec, options = {}) {
     this.bootstrap();