gencow 0.1.240 → 0.1.241

package/core/index.js

@@ -813,449 +813,98 @@ function verifyRealtimeChannelToken(token, input) {
   };
 }
 
-// ../core/src/realtime-channel-registry.ts
-if (!globalThis.__gencow_realtimeChannelRegistry) {
-  globalThis.__gencow_realtimeChannelRegistry = /* @__PURE__ */ new Map();
-}
-var realtimeChannelRegistry = globalThis.__gencow_realtimeChannelRegistry;
-function defineRealtimeChannels(channels) {
-  for (const [name, def] of Object.entries(channels)) {
-    realtimeChannelRegistry.set(name, {
-      name,
-      argsSchema: def.args,
-      channelKey: def.channelKey,
-      authorize: def.authorize
-    });
+// ../core/src/v.ts
+var GencowValidationError = class extends Error {
+  statusCode = 400;
+  constructor(message) {
+    super(message);
+    this.name = "GencowValidationError";
   }
-  return channels;
-}
-function getRealtimeChannelDef(name) {
-  return realtimeChannelRegistry.get(name);
+};
+var GENCOW_OPTIONAL_INNER = /* @__PURE__ */ Symbol.for("gencow.v.optionalInner");
+function assertStandardResult(value) {
+  return { value };
 }
-function getRegisteredRealtimeChannels() {
-  return [...realtimeChannelRegistry.keys()];
+function failStandardResult(message) {
+  return { issues: [{ message }] };
 }
-function resolveRealtimeChannelKey(params) {
-  if (params.result === false || params.result === null) return null;
-  if (typeof params.result === "string") return params.result.length > 0 ? params.result : null;
-  if (params.result && typeof params.result === "object" && "channelKey" in params.result) {
-    const channelKey2 = params.result.channelKey;
-    if (channelKey2 !== void 0) return typeof channelKey2 === "string" && channelKey2.length > 0 ? channelKey2 : null;
-  }
-  const def = getRealtimeChannelDef(params.channel);
-  const channelKey = def?.channelKey?.(params.args);
-  if (channelKey !== void 0) return typeof channelKey === "string" && channelKey.length > 0 ? channelKey : null;
-  return buildRealtimeChannelKey(params.channel, params.args);
+function readJsonSchemaFragment(validator) {
+  const opt = validator[GENCOW_OPTIONAL_INNER];
+  const target = opt ?? validator;
+  const raw = target["~standard"]?.jsonSchema;
+  if (raw === void 0) return {};
+  return raw.output({ target: "draft-2020-12" });
 }
-function resetRealtimeChannelRegistryForTests() {
-  realtimeChannelRegistry.clear();
+function isOptionalValidator(validator) {
+  return !!validator && Object.prototype.hasOwnProperty.call(validator, GENCOW_OPTIONAL_INNER);
 }
-
-// ../core/src/reactive-realtime.ts
-var SUBSCRIPTION_KEY_SEPARATOR = "::";
-function createRealtimeEventId() {
-  const randomUUID = globalThis.crypto?.randomUUID;
-  if (typeof randomUUID === "function") return `evt_${randomUUID.call(globalThis.crypto)}`;
-  return `evt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+function readGencowStandardJsonSchema(schema) {
+  if (!schema || typeof schema !== "object" || !("~standard" in schema)) return void 0;
+  const props = schema["~standard"];
+  if (!props || props.vendor !== "gencow") return void 0;
+  const raw = props.jsonSchema;
+  if (raw === void 0) return void 0;
+  return raw.output({ target: "draft-2020-12" });
 }
-function normalizeForStableJson3(value) {
-  if (value === void 0) return void 0;
-  if (value === null) return null;
-  if (value instanceof Date) return value.toISOString();
-  if (Array.isArray(value)) return value.map((item) => normalizeForStableJson3(item));
-  if (typeof value === "object") {
-    const source = value;
-    const sorted = {};
-    for (const key of Object.keys(source).sort()) {
-      const normalized = normalizeForStableJson3(source[key]);
-      if (normalized !== void 0) sorted[key] = normalized;
-    }
-    return sorted;
-  }
-  return value;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isEmptyPlainObject3(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+function isAllOptionalObjectSchema(schema) {
+  const jsonSchema = readGencowStandardJsonSchema(schema);
+  if (!isRecord(jsonSchema) || jsonSchema.type !== "object") return false;
+  const required = jsonSchema.required;
+  return required === void 0 || Array.isArray(required) && required.length === 0;
 }
-function buildQuerySubscriptionKey(queryKey, args) {
-  const normalized = normalizeForStableJson3(args);
-  if (normalized === void 0 || isEmptyPlainObject3(normalized)) return queryKey;
-  return `${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}${JSON.stringify(normalized)}`;
+function normalizeMissingOptionalObjectInput(schema, value) {
+  if (value !== void 0) return value;
+  return isAllOptionalObjectSchema(schema) ? {} : value;
 }
-function subscriptionKeyMatchesQueryKey(subscriptionKey, queryKey) {
-  return subscriptionKey === queryKey || subscriptionKey.startsWith(`${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}`);
+function matchesMimeType(fileType, pattern) {
+  const normalizedFileType = fileType.split(";")[0].trim().toLowerCase();
+  const normalizedPattern = pattern.trim().toLowerCase();
+  if (normalizedPattern === "*/*") return true;
+  if (normalizedPattern.endsWith("/*")) {
+    const prefix = normalizedPattern.slice(0, -1);
+    return normalizedFileType.startsWith(prefix);
+  }
+  return normalizedFileType === normalizedPattern;
 }
-function buildRealtimeCtx(options) {
-  const pendingEmits = /* @__PURE__ */ new Map();
-  const pendingEvents = [];
-  const _pendingRefresh = [];
-  let _hasEmitted = false;
-  function dispatchEvent(event) {
-    if (options.deferFanout) {
-      pendingEvents.push(event);
-      return;
+function buildObjectJsonSchema(fields) {
+  const properties = {};
+  const required = [];
+  for (const key of Object.keys(fields)) {
+    const field = fields[key];
+    properties[key] = readJsonSchemaFragment(field);
+    if (!isOptionalValidator(field)) {
+      required.push(key);
     }
-    void options.fanout.notify(event);
   }
   return {
-    emit(queryKey, data) {
-      _hasEmitted = true;
-      if (options.deferFanout) {
-        pendingEvents.push({ type: "emit", queryKey, data });
-        return;
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function createValidator(config) {
+  const { parse, _type, jsonSchema } = config;
+  const standard = {
+    version: 1,
+    vendor: "gencow",
+    types: {},
+    validate: async (value) => {
+      try {
+        return assertStandardResult(parse(value));
+      } catch (e) {
+        const message = e instanceof Error ? e.message : "Validation failed";
+        return failStandardResult(message);
       }
-      const existing = pendingEmits.get(queryKey);
-      if (existing) clearTimeout(existing.timer);
-      const timer = setTimeout(() => {
-        pendingEmits.delete(queryKey);
-        dispatchEvent({ type: "emit", queryKey, data });
-      }, 50);
-      pendingEmits.set(queryKey, { data, timer });
-    },
-    invalidate(queryKey) {
-      _hasEmitted = true;
-      const queryKeys = Array.isArray(queryKey) ? [...new Set(queryKey)] : [queryKey];
-      dispatchEvent({ type: "invalidate", queryKeys });
     },
-    refresh(queryKey) {
-      _hasEmitted = true;
-      if (!_pendingRefresh.includes(queryKey)) {
-        _pendingRefresh.push(queryKey);
+    ...jsonSchema !== void 0 ? {
+      jsonSchema: {
+        input: () => jsonSchema,
+        output: () => jsonSchema
       }
-    },
-    channel(channel, args) {
-      const channelKey = resolveRealtimeChannelKey({ channel, args });
-      if (!channelKey) throw new Error(`Realtime channel "${channel}" resolved to an invalid channelKey`);
-      return {
-        authorize(authOptions) {
-          if (!options.appName || !options.channelTokenSecret || !options.auth) {
-            throw new Error("Authorized realtime channel token signer is not configured");
-          }
-          const user = options.auth.requireAuth();
-          const nowMs = authOptions?.nowMs ?? Date.now();
-          const rawTtl = authOptions?.ttlSeconds;
-          const ttlSeconds = Number.isFinite(rawTtl) && rawTtl > 0 ? Math.min(rawTtl, 3600) : 300;
-          const epoch = normalizeRealtimeChannelEpoch(authOptions?.epoch);
-          return {
-            token: createRealtimeChannelToken({
-              appName: options.appName,
-              channel,
-              channelKey,
-              args,
-              userId: user.id,
-              secret: options.channelTokenSecret,
-              ttlSeconds,
-              nowMs,
-              nonce: authOptions?.nonce,
-              epoch
-            }),
-            channel,
-            channelKey,
-            userId: user.id,
-            expiresAt: nowMs + Math.floor(ttlSeconds * 1e3),
-            ...epoch ? { epoch } : {}
-          };
-        },
-        publish(data, publishOptions) {
-          _hasEmitted = true;
-          dispatchEvent({
-            type: "channel_publish",
-            channelKey,
-            data,
-            eventId: publishOptions?.eventId ?? createRealtimeEventId()
-          });
-        },
-        invalidate() {
-          _hasEmitted = true;
-          dispatchEvent({ type: "channel_invalidate", channelKey });
-        },
-        revoke(revokeOptions) {
-          _hasEmitted = true;
-          const epoch = normalizeRealtimeChannelEpoch(revokeOptions?.epoch);
-          const reason = typeof revokeOptions?.reason === "string" && revokeOptions.reason.length > 0 ? revokeOptions.reason : void 0;
-          dispatchEvent({
-            type: "channel_revoke",
-            channelKey,
-            ...epoch ? { epoch } : {},
-            ...reason ? { reason } : {}
-          });
-        }
-      };
-    },
-    query(query2, args) {
-      const subscriptionKey = resolveRealtimeQuerySubscriptionKey({ query: query2, args });
-      if (!subscriptionKey)
-        throw new Error(`Realtime query "${query2}" resolved to an invalid subscriptionKey`);
-      const scopeHash = resolveRealtimeQueryScopeHash({ query: query2, args, subscriptionKey });
-      return {
-        authorize(authOptions) {
-          if (!options.appName || !options.channelTokenSecret || !options.auth) {
-            throw new Error("Authorized realtime query token signer is not configured");
-          }
-          const user = options.auth.requireAuth();
-          const nowMs = authOptions?.nowMs ?? Date.now();
-          const rawTtl = authOptions?.ttlSeconds;
-          const ttlSeconds = Number.isFinite(rawTtl) && rawTtl > 0 ? Math.min(rawTtl, 3600) : 300;
-          const epoch = normalizeRealtimeQuerySubscriptionEpoch(authOptions?.epoch);
-          return {
-            token: createRealtimeQuerySubscriptionToken({
-              appName: options.appName,
-              query: query2,
-              subscriptionKey,
-              args,
-              scopeHash,
-              policy: "authorized",
-              userId: user.id,
-              secret: options.channelTokenSecret,
-              ttlSeconds,
-              nowMs,
-              nonce: authOptions?.nonce,
-              epoch
-            }),
-            query: query2,
-            subscriptionKey,
-            policy: "authorized",
-            userId: user.id,
-            expiresAt: nowMs + Math.floor(ttlSeconds * 1e3),
-            ...epoch ? { epoch } : {}
-          };
-        },
-        invalidate(invalidateOptions) {
-          _hasEmitted = true;
-          dispatchEvent({
-            type: "query_invalidate",
-            query: query2,
-            subscriptionKey,
-            scopeHash,
-            eventId: invalidateOptions?.eventId ?? createRealtimeEventId()
-          });
-        },
-        revoke(revokeOptions) {
-          _hasEmitted = true;
-          const epoch = normalizeRealtimeQuerySubscriptionEpoch(revokeOptions?.epoch);
-          const reason = typeof revokeOptions?.reason === "string" && revokeOptions.reason.length > 0 ? revokeOptions.reason : void 0;
-          dispatchEvent({
-            type: "query_revoke",
-            query: query2,
-            subscriptionKey,
-            scopeHash,
-            ...epoch ? { epoch } : {},
-            ...reason ? { reason } : {}
-          });
-        }
-      };
-    },
-    invalidateScoped(input) {
-      _hasEmitted = true;
-      const subscriptionKey = input.subscriptionKey ?? resolveRealtimeQuerySubscriptionKey({ query: input.query, args: input.args });
-      if (!subscriptionKey)
-        throw new Error(`Realtime query "${input.query}" resolved to an invalid subscriptionKey`);
-      const scopeHash = input.scopeHash ?? resolveRealtimeQueryScopeHash({
-        query: input.query,
-        args: input.args,
-        subscriptionKey
-      });
-      dispatchEvent({
-        type: "query_invalidate",
-        query: input.query,
-        subscriptionKey,
-        scopeHash,
-        eventId: input.eventId ?? createRealtimeEventId()
-      });
-    },
-    invalidateCrudQuery(input) {
-      _hasEmitted = true;
-      const subscriptionKey = input.subscriptionKey ?? resolveRealtimeQuerySubscriptionKey({ query: input.query, args: input.args });
-      if (!subscriptionKey)
-        throw new Error(`Realtime query "${input.query}" resolved to an invalid subscriptionKey`);
-      const scopeHash = input.scopeHash ?? resolveRealtimeQueryScopeHash({
-        query: input.query,
-        args: input.args,
-        subscriptionKey
-      });
-      dispatchEvent({
-        type: "query_invalidate",
-        query: input.query,
-        subscriptionKey,
-        scopeHash,
-        eventId: input.eventId ?? createRealtimeEventId(),
-        legacyQueryKey: input.legacyQueryKey,
-        crudRealtimeEmitMode: input.crudRealtimeEmitMode ?? options.generatedCrudRealtimeEmitMode ?? "dual"
-      });
-    },
-    get _hasEmitted() {
-      return _hasEmitted;
-    },
-    get _pendingRefresh() {
-      return [..._pendingRefresh];
-    },
-    async _flushRefresh() {
-      if (_pendingRefresh.length === 0) return;
-      const qMap = options.queryMap ?? queryRegistry;
-      for (const key of _pendingRefresh) {
-        const legacyDef = qMap.get(key);
-        const procedureDef = legacyDef ? void 0 : options.getProcedureQuery?.(key);
-        if (!legacyDef && !procedureDef) {
-          console.warn(`[gencow] refresh("${key}"): query not found in registry. Skipping.`);
-          continue;
-        }
-        if (procedureDef?.inputSchema) {
-          options.fanout.notify({ type: "invalidate", queryKeys: [key] });
-          continue;
-        }
-        try {
-          if (!options.buildCtxForRefresh) {
-            console.warn(
-              `[gencow] \u26A0\uFE0F  refresh("${key}"): buildCtxForRefresh not provided. Query handler will receive an empty ctx \u2014 ctx.db will be undefined. This is a framework configuration error. \u{1F4A1} Ensure buildRealtimeCtx() receives a buildCtxForRefresh callback.`
-            );
-          }
-          const refreshCtx = options.buildCtxForRefresh?.() ?? {};
-          const result = legacyDef ? await legacyDef.handler(refreshCtx, {}) : await procedureDef.handler(refreshCtx, {});
-          dispatchEvent({ type: "emit", queryKey: key, data: result });
-        } catch (e) {
-          console.warn(`[gencow] refresh("${key}") failed:`, e instanceof Error ? e.message : e);
-        }
-      }
-      _pendingRefresh.length = 0;
-    },
-    async _flushRealtimeEvents() {
-      while (pendingEvents.length > 0) {
-        const event = pendingEvents.shift();
-        await options.fanout.notify(event);
-      }
-    }
-  };
-}
-
-// ../core/src/reactive-mutation.ts
-if (!globalThis.__gencow_mutationRegistry) globalThis.__gencow_mutationRegistry = [];
-var mutationRegistry = globalThis.__gencow_mutationRegistry;
-var mutationCounter = 0;
-function mutation(nameOrInvalidatesOrDef, handlerOrDef, name) {
-  let argsSchema;
-  let actualHandler;
-  let mutName;
-  let isPublic = false;
-  if (typeof nameOrInvalidatesOrDef === "string") {
-    mutName = nameOrInvalidatesOrDef;
-    const def2 = handlerOrDef;
-    actualHandler = def2.handler;
-    argsSchema = def2.args;
-    isPublic = def2.public === true;
-  } else if (Array.isArray(nameOrInvalidatesOrDef)) {
-    actualHandler = handlerOrDef;
-    mutName = name || `mutation_${++mutationCounter}`;
-  } else {
-    actualHandler = nameOrInvalidatesOrDef.handler;
-    argsSchema = nameOrInvalidatesOrDef.args;
-    isPublic = nameOrInvalidatesOrDef.public === true;
-    mutName = nameOrInvalidatesOrDef.name || (typeof name === "string" ? name : "") || `mutation_${++mutationCounter}`;
-  }
-  if (mutName.startsWith("mutation_")) {
-    console.warn(
-      `[gencow] mutation registered without explicit name \u2192 "${mutName}". Use mutation("myMutation", { handler }) for better debugging.`
-    );
-  }
-  const def = {
-    name: mutName,
-    handler: actualHandler,
-    argsSchema,
-    isPublic
-  };
-  mutationRegistry.push(def);
-  return def;
-}
-function getRegisteredMutations() {
-  return [...mutationRegistry];
-}
-
-// ../core/src/v.ts
-var GencowValidationError = class extends Error {
-  statusCode = 400;
-  constructor(message) {
-    super(message);
-    this.name = "GencowValidationError";
-  }
-};
-var GENCOW_OPTIONAL_INNER = /* @__PURE__ */ Symbol.for("gencow.v.optionalInner");
-function assertStandardResult(value) {
-  return { value };
-}
-function failStandardResult(message) {
-  return { issues: [{ message }] };
-}
-function readJsonSchemaFragment(validator) {
-  const opt = validator[GENCOW_OPTIONAL_INNER];
-  const target = opt ?? validator;
-  const raw = target["~standard"]?.jsonSchema;
-  if (raw === void 0) return {};
-  return typeof raw === "function" ? raw() : raw;
-}
-function isOptionalValidator(validator) {
-  return !!validator && Object.prototype.hasOwnProperty.call(validator, GENCOW_OPTIONAL_INNER);
-}
-function readGencowStandardJsonSchema(schema) {
-  if (!schema || typeof schema !== "object" || !("~standard" in schema)) return void 0;
-  const props = schema["~standard"];
-  if (!props || props.vendor !== "gencow") return void 0;
-  const raw = props.jsonSchema;
-  if (raw === void 0) return void 0;
-  return typeof raw === "function" ? raw() : raw;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isAllOptionalObjectSchema(schema) {
-  const jsonSchema = readGencowStandardJsonSchema(schema);
-  if (!isRecord(jsonSchema) || jsonSchema.type !== "object") return false;
-  const required = jsonSchema.required;
-  return required === void 0 || Array.isArray(required) && required.length === 0;
-}
-function normalizeMissingOptionalObjectInput(schema, value) {
-  if (value !== void 0) return value;
-  return isAllOptionalObjectSchema(schema) ? {} : value;
-}
-function matchesMimeType(fileType, pattern) {
-  const normalizedFileType = fileType.split(";")[0].trim().toLowerCase();
-  const normalizedPattern = pattern.trim().toLowerCase();
-  if (normalizedPattern === "*/*") return true;
-  if (normalizedPattern.endsWith("/*")) {
-    const prefix = normalizedPattern.slice(0, -1);
-    return normalizedFileType.startsWith(prefix);
-  }
-  return normalizedFileType === normalizedPattern;
-}
-function buildObjectJsonSchema(fields) {
-  const properties = {};
-  const required = [];
-  for (const key of Object.keys(fields)) {
-    const field = fields[key];
-    properties[key] = readJsonSchemaFragment(field);
-    if (!isOptionalValidator(field)) {
-      required.push(key);
-    }
-  }
-  return {
-    type: "object",
-    properties,
-    ...required.length > 0 ? { required } : {}
-  };
-}
-function createValidator(config) {
-  const { parse, _type, jsonSchema } = config;
-  const standard = {
-    version: 1,
-    vendor: "gencow",
-    types: {},
-    validate: async (value) => {
-      try {
-        return assertStandardResult(parse(value));
-      } catch (e) {
-        const message = e instanceof Error ? e.message : "Validation failed";
-        return failStandardResult(message);
-      }
-    },
-    ...jsonSchema !== void 0 ? { jsonSchema } : {}
+    } : {}
   };
   return {
     parse,
@@ -1264,6 +913,16 @@ function createValidator(config) {
   };
 }
 var v = {
+  literal(expected) {
+    return createValidator({
+      parse: (value) => {
+        if (value !== expected) throw new Error(`Expected literal ${JSON.stringify(expected)}`);
+        return expected;
+      },
+      _type: expected,
+      jsonSchema: { const: expected, enum: [expected] }
+    });
+  },
   string() {
     return createValidator({
       parse: (val) => {
@@ -1439,239 +1098,843 @@ function parseArgs(schema, args) {
   return args;
 }
 
-// ../core/src/procedure.ts
+// ../core/src/realtime-channel-definition.ts
+var RealtimeChannelBuilderImpl = class _RealtimeChannelBuilderImpl {
+  constructor(channelName, inputValidator, eventValidator, keyBuilder) {
+    this.channelName = channelName;
+    this.inputValidator = inputValidator;
+    this.eventValidator = eventValidator;
+    this.keyBuilder = keyBuilder;
+  }
+  channelName;
+  inputValidator;
+  eventValidator;
+  keyBuilder;
+  name(name) {
+    return new _RealtimeChannelBuilderImpl(
+      name,
+      this.inputValidator,
+      this.eventValidator,
+      this.keyBuilder
+    );
+  }
+  input(schema) {
+    return new _RealtimeChannelBuilderImpl(
+      this.channelName,
+      schema,
+      this.eventValidator,
+      this.keyBuilder
+    );
+  }
+  event(schema) {
+    return new _RealtimeChannelBuilderImpl(
+      this.channelName,
+      this.inputValidator,
+      schema,
+      this.keyBuilder
+    );
+  }
+  channelKey(build) {
+    return new _RealtimeChannelBuilderImpl(
+      this.channelName,
+      this.inputValidator,
+      this.eventValidator,
+      build
+    );
+  }
+  authorize(handler) {
+    if (!this.channelName?.trim()) throw new Error("Realtime channel name is required before authorize()");
+    return Object.freeze({
+      kind: "realtime_channel",
+      name: this.channelName,
+      ...this.inputValidator ? { inputSchema: this.inputValidator } : {},
+      ...this.eventValidator ? { eventSchema: this.eventValidator } : {},
+      ...this.keyBuilder ? { channelKey: this.keyBuilder } : {},
+      authorize: handler
+    });
+  }
+};
+function createGencowRealtimeChannelBuilder() {
+  return new RealtimeChannelBuilderImpl();
+}
 function hasStandardSchema2(schema) {
-  return !!schema && typeof schema === "object" && "~standard" in schema && !!schema["~standard"] && typeof schema["~standard"].validate === "function";
+  return !!schema && typeof schema === "object" && typeof schema["~standard"]?.validate === "function";
 }
-async function validateWithSchema(schema, value, options) {
+async function parseStandardSchema(schema, value) {
   if (!schema) return value;
-  const valueToValidate = options?.normalizeMissingOptionalObject ? normalizeMissingOptionalObjectInput(schema, value) : value;
-  if (hasStandardSchema2(schema)) {
-    const result = await schema["~standard"].validate(valueToValidate);
-    if ("issues" in result && result.issues.length > 0) {
-      throw new Error(result.issues[0]?.message ?? "Validation failed");
-    }
-    if ("value" in result) {
-      return result.value;
-    }
-    throw new Error("Validation failed");
+  if (!hasStandardSchema2(schema)) {
+    throw new Error("Realtime channels require a Standard Schema v1 validator");
   }
-  throw new Error("procedure.query / procedure.mutation / procedure.internal only supports Standard Schema v1 validators");
-}
-function composeMiddlewares(middlewares, handler, inputSchema, outputSchema, inputValidationIndex, outputValidationIndex) {
-  return async (initialContext, initialInput) => {
-    let idx = -1;
-    const boundedInputValidationIndex = Math.min(Math.max(0, inputValidationIndex), middlewares.length);
-    const boundedOutputValidationIndex = Math.min(Math.max(0, outputValidationIndex), middlewares.length);
-    const run = async (currentIdx, context, input) => {
-      if (currentIdx <= idx) {
-        throw new Error("next() called multiple times in the same middleware");
-      }
-      idx = currentIdx;
-      let currentInput = input;
-      if (currentIdx === boundedInputValidationIndex) {
-        currentInput = await validateWithSchema(inputSchema, currentInput, {
-          normalizeMissingOptionalObject: true
-        });
-      }
-      if (currentIdx === middlewares.length) {
-        const output2 = await handler({ context, input: currentInput });
-        if (currentIdx === boundedOutputValidationIndex) {
-          return await validateWithSchema(outputSchema, output2);
-        }
-        return output2;
-      }
-      const middleware = middlewares[currentIdx];
-      const output = await middleware({
-        context,
-        input: currentInput,
-        next: async (overrides) => {
-          return await run(
-            currentIdx + 1,
-            overrides?.context ?? context,
-            overrides?.input ?? currentInput
-          );
-        }
-      });
-      if (currentIdx === boundedOutputValidationIndex) {
-        return await validateWithSchema(outputSchema, output);
-      }
-      return output;
-    };
-    return await run(0, initialContext, initialInput);
-  };
+  const normalized = normalizeMissingOptionalObjectInput(schema, value);
+  const result = await schema["~standard"].validate(normalized);
+  if ("issues" in result && result.issues?.length) {
+    throw new GencowValidationError(result.issues[0]?.message ?? "Validation failed");
+  }
+  if ("value" in result) return result.value;
+  throw new GencowValidationError("Validation failed");
 }
-var GencowProcedureBuilderImpl = class _GencowProcedureBuilderImpl {
-  constructor(kind, procedureName, middlewares = [], inputSchema, outputSchema, inputValidationIndex = -1, outputValidationIndex = -1, anonymousAllowed = false) {
-    this.kind = kind;
-    this.procedureName = procedureName;
-    this.middlewares = middlewares;
-    this.inputSchema = inputSchema;
-    this.outputSchema = outputSchema;
-    this.inputValidationIndex = inputValidationIndex;
-    this.outputValidationIndex = outputValidationIndex;
-    this.anonymousAllowed = anonymousAllowed;
+var RealtimeChannelEventValidationError = class extends GencowValidationError {
+  code = "REALTIME_CHANNEL_EVENT_INVALID";
+  constructor(message) {
+    super(message);
+    this.name = "RealtimeChannelEventValidationError";
   }
-  kind;
-  procedureName;
-  middlewares;
-  inputSchema;
-  outputSchema;
-  inputValidationIndex;
-  outputValidationIndex;
-  anonymousAllowed;
-  name(name) {
-    return new _GencowProcedureBuilderImpl(
-      this.kind,
-      name,
-      this.middlewares,
-      this.inputSchema,
-      this.outputSchema,
-      this.inputValidationIndex,
-      this.outputValidationIndex,
-      this.anonymousAllowed
-    );
+};
+async function parseRealtimeChannelEvent(schema, value) {
+  try {
+    return await parseStandardSchema(schema, value);
+  } catch (error) {
+    if (error instanceof GencowValidationError) {
+      throw new RealtimeChannelEventValidationError(error.message);
+    }
+    throw error;
   }
-  allowAnonymous() {
-    return new _GencowProcedureBuilderImpl(
-      this.kind,
-      this.procedureName,
-      this.middlewares,
-      this.inputSchema,
-      this.outputSchema,
-      this.inputValidationIndex,
-      this.outputValidationIndex,
-      true
-    );
+}
+function assertJsonWireValue(value, seen) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) return;
+    throw new RealtimeChannelEventValidationError("Realtime channel events must use finite JSON numbers");
   }
-  use(middleware) {
-    return new _GencowProcedureBuilderImpl(
-      this.kind,
-      this.procedureName,
-      [...this.middlewares, middleware],
-      this.inputSchema,
-      this.outputSchema,
-      this.inputValidationIndex,
-      this.outputValidationIndex,
-      this.anonymousAllowed
+  if (typeof value !== "object") {
+    throw new RealtimeChannelEventValidationError(
+      "Realtime channel events must be JSON-serializable wire values"
     );
   }
-  input(schema) {
-    const nextInputValidationIndex = this.middlewares.length < 0 ? 0 : this.middlewares.length;
-    return new _GencowProcedureBuilderImpl(
-      this.kind,
-      this.procedureName,
-      this.middlewares,
-      schema,
-      this.outputSchema,
-      nextInputValidationIndex,
-      this.outputValidationIndex,
-      this.anonymousAllowed
-    );
+  if (seen.has(value)) {
+    throw new RealtimeChannelEventValidationError("Realtime channel events must not contain circular values");
   }
-  output(schema) {
-    const nextOutputValidationIndex = this.middlewares.length < 0 ? 0 : this.middlewares.length;
-    return new _GencowProcedureBuilderImpl(
-      this.kind,
-      this.procedureName,
-      this.middlewares,
-      this.inputSchema,
-      schema,
-      this.inputValidationIndex,
-      nextOutputValidationIndex,
-      this.anonymousAllowed
-    );
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (const item of value) assertJsonWireValue(item, seen);
+  } else {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new RealtimeChannelEventValidationError("Realtime channel events must use plain JSON objects");
+    }
+    for (const child of Object.values(value)) assertJsonWireValue(child, seen);
   }
-  handler(handler) {
-    if (!this.procedureName) {
-      throw new Error("Procedure name is required. Call .name(...) before .handler(...)");
+  seen.delete(value);
+}
+function normalizeRealtimeChannelEventWireValue(value) {
+  assertJsonWireValue(value, /* @__PURE__ */ new WeakSet());
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      throw new RealtimeChannelEventValidationError(
+        "Realtime channel events must be JSON-serializable wire values"
+      );
     }
-    const run = composeMiddlewares(
-      this.middlewares,
-      handler,
-      this.inputSchema,
-      this.outputSchema,
-      this.inputValidationIndex,
-      this.outputValidationIndex
+    return JSON.parse(serialized);
+  } catch (error) {
+    if (error instanceof RealtimeChannelEventValidationError) throw error;
+    throw new RealtimeChannelEventValidationError(
+      "Realtime channel events must be JSON-serializable wire values"
     );
-    return {
-      kind: this.kind,
-      name: this.procedureName,
-      allowAnonymous: this.kind === "internal" ? false : this.anonymousAllowed,
-      middlewares: [...this.middlewares],
-      inputSchema: this.inputSchema,
-      outputSchema: this.outputSchema,
-      inputValidationIndex: this.inputValidationIndex,
-      outputValidationIndex: this.outputValidationIndex,
-      handler: run
-    };
   }
-};
-function createGencowProcedureBuilders() {
-  return {
-    query: new GencowProcedureBuilderImpl("query"),
-    mutation: new GencowProcedureBuilderImpl("mutation"),
-    internal: new GencowProcedureBuilderImpl("internal")
-  };
+}
+function resolveExplicitRealtimeChannelKey(definition, input) {
+  const key = definition.channelKey?.(input) ?? buildRealtimeChannelKey(definition.name, input);
+  if (typeof key !== "string" || key.length === 0) {
+    throw new Error(`Realtime channel "${definition.name}" resolved to an invalid channelKey`);
+  }
+  return key;
 }
 
-// ../core/src/http-action.ts
-if (!globalThis.__gencow_httpActionRegistry) globalThis.__gencow_httpActionRegistry = [];
-var httpActionRegistry = globalThis.__gencow_httpActionRegistry;
-function httpAction(def) {
-  const actionDef = {
-    method: def.method,
-    path: def.path,
-    isPublic: def.public === true,
-    handler: def.handler
+// ../core/src/realtime-channel-publisher.ts
+function createExplicitRealtimeChannelPublisher(definition, args, runtime) {
+  async function resolveKey() {
+    const parsedArgs = await parseStandardSchema(definition.inputSchema, args);
+    return resolveExplicitRealtimeChannelKey(definition, parsedArgs);
+  }
+  return {
+    async publish(data, options) {
+      const channelKey = await resolveKey();
+      const parsedEvent = await parseRealtimeChannelEvent(definition.eventSchema, data);
+      const wireEvent = normalizeRealtimeChannelEventWireValue(parsedEvent);
+      runtime.markEmitted();
+      runtime.dispatch({
+        type: "channel_publish",
+        channelKey,
+        data: wireEvent,
+        eventId: options?.eventId ?? runtime.createEventId()
+      });
+    },
+    async invalidate() {
+      const channelKey = await resolveKey();
+      runtime.markEmitted();
+      runtime.dispatch({ type: "channel_invalidate", channelKey });
+    },
+    async revoke(options) {
+      const channelKey = await resolveKey();
+      const epoch = normalizeRealtimeChannelEpoch(options?.epoch);
+      const reason = typeof options?.reason === "string" && options.reason.length > 0 ? options.reason : void 0;
+      runtime.markEmitted();
+      runtime.dispatch({
+        type: "channel_revoke",
+        channelKey,
+        ...epoch ? { epoch } : {},
+        ...reason ? { reason } : {}
+      });
+    }
   };
-  httpActionRegistry.push(actionDef);
-  return actionDef;
-}
-function getRegisteredHttpActions() {
-  return [...httpActionRegistry];
 }
 
-// ../core/src/realtime-ticket.ts
-import { createHmac as createHmac3, randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual3 } from "crypto";
-var TICKET_PREFIX = "gencow_ws1";
-var DEFAULT_TTL_SECONDS3 = 60;
-var MAX_TTL_SECONDS3 = 120;
-var MAX_TICKET_LENGTH = 4096;
-function encodeBase64Url3(value) {
-  return Buffer.from(value, "utf8").toString("base64url");
+// ../core/src/reactive-realtime.ts
+var SUBSCRIPTION_KEY_SEPARATOR = "::";
+function createRealtimeEventId() {
+  const randomUUID = globalThis.crypto?.randomUUID;
+  if (typeof randomUUID === "function") return `evt_${randomUUID.call(globalThis.crypto)}`;
+  return `evt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
 }
-function decodeBase64Url3(value) {
-  try {
-    return Buffer.from(value, "base64url").toString("utf8");
-  } catch {
-    return null;
+function normalizeForStableJson3(value) {
+  if (value === void 0) return void 0;
+  if (value === null) return null;
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map((item) => normalizeForStableJson3(item));
+  if (typeof value === "object") {
+    const source = value;
+    const sorted = {};
+    for (const key of Object.keys(source).sort()) {
+      const normalized = normalizeForStableJson3(source[key]);
+      if (normalized !== void 0) sorted[key] = normalized;
+    }
+    return sorted;
   }
+  return value;
 }
-function signSegment3(segment, secret) {
-  return createHmac3("sha256", secret).update(segment).digest("base64url");
-}
-function safeEqual3(a, b) {
-  const left = Buffer.from(a);
-  const right = Buffer.from(b);
-  return left.length === right.length && timingSafeEqual3(left, right);
-}
-function validateRequiredString3(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`${label} required`);
-  }
+function isEmptyPlainObject3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
 }
-function resolveTtlMs3(ttlSeconds) {
-  const ttl = Number.isFinite(ttlSeconds) && ttlSeconds > 0 ? ttlSeconds : DEFAULT_TTL_SECONDS3;
-  return Math.floor(Math.min(ttl, MAX_TTL_SECONDS3) * 1e3);
+function buildQuerySubscriptionKey(queryKey, args) {
+  const normalized = normalizeForStableJson3(args);
+  if (normalized === void 0 || isEmptyPlainObject3(normalized)) return queryKey;
+  return `${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}${JSON.stringify(normalized)}`;
 }
-function randomNonce3() {
-  return randomBytes3(16).toString("base64url");
+function subscriptionKeyMatchesQueryKey(subscriptionKey, queryKey) {
+  return subscriptionKey === queryKey || subscriptionKey.startsWith(`${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}`);
 }
-function resolveRealtimeCapabilityNegotiation(value) {
-  const record = value && typeof value === "object" ? value : null;
-  return {
-    crudRealtimeMode: record?.crudRealtimeMode === "scoped" ? "scoped" : "legacy"
+function buildRealtimeCtx(options) {
+  const pendingEmits = /* @__PURE__ */ new Map();
+  const pendingEvents = [];
+  const _pendingRefresh = [];
+  let _hasEmitted = false;
+  function dispatchEvent(event) {
+    if (options.deferFanout) {
+      pendingEvents.push(event);
+      return;
+    }
+    void options.fanout.notify(event);
+  }
+  return {
+    emit(queryKey, data) {
+      _hasEmitted = true;
+      if (options.deferFanout) {
+        pendingEvents.push({ type: "emit", queryKey, data });
+        return;
+      }
+      const existing = pendingEmits.get(queryKey);
+      if (existing) clearTimeout(existing.timer);
+      const timer = setTimeout(() => {
+        pendingEmits.delete(queryKey);
+        dispatchEvent({ type: "emit", queryKey, data });
+      }, 50);
+      pendingEmits.set(queryKey, { data, timer });
+    },
+    invalidate(queryKey) {
+      _hasEmitted = true;
+      const queryKeys = Array.isArray(queryKey) ? [...new Set(queryKey)] : [queryKey];
+      dispatchEvent({ type: "invalidate", queryKeys });
+    },
+    refresh(queryKey) {
+      _hasEmitted = true;
+      if (!_pendingRefresh.includes(queryKey)) {
+        _pendingRefresh.push(queryKey);
+      }
+    },
+    channel: function(channel, args) {
+      if (typeof channel !== "string") {
+        const selected2 = options.realtimeChannelResolver?.get(channel.name);
+        if (options.realtimeChannelResolver && (!selected2 || selected2.source !== "explicit" || selected2.definition !== channel)) {
+          throw new Error(`REALTIME_CHANNEL_NOT_DECLARED: ${channel.name}`);
+        }
+        return createExplicitRealtimeChannelPublisher(channel, args, {
+          markEmitted: () => {
+            _hasEmitted = true;
+          },
+          dispatch: dispatchEvent,
+          createEventId: createRealtimeEventId
+        });
+      }
+      const selected = options.realtimeChannelResolver?.get(channel);
+      if (!options.realtimeChannelResolver) {
+        throw new Error(
+          "REALTIME_CHANNEL_CATALOG_REQUIRED: string realtime channels require an injected selected catalog"
+        );
+      }
+      if (selected?.source === "explicit") {
+        const publisher = createExplicitRealtimeChannelPublisher(selected.definition, args, {
+          markEmitted: () => {
+            _hasEmitted = true;
+          },
+          dispatch: dispatchEvent,
+          createEventId: createRealtimeEventId
+        });
+        return {
+          ...publisher,
+          authorize() {
+            const error = new Error(
+              "REALTIME_CHANNEL_EXPLICIT_SIGNER_UNSUPPORTED: explicit channels must be authorized by the subscription route"
+            );
+            error.code = "REALTIME_CHANNEL_EXPLICIT_SIGNER_UNSUPPORTED";
+            throw error;
+          }
+        };
+      }
+      if (!selected) throw new Error(`REALTIME_CHANNEL_NOT_DECLARED: ${channel}`);
+      const channelKey = selected.definition.channelKey?.(args) ?? buildRealtimeChannelKey(channel, args);
+      if (!channelKey) throw new Error(`Realtime channel "${channel}" resolved to an invalid channelKey`);
+      return {
+        authorize(authOptions) {
+          if (!options.appName || !options.channelTokenSecret || !options.auth) {
+            throw new Error("Authorized realtime channel token signer is not configured");
+          }
+          const user = options.auth.requireAuth();
+          const nowMs = authOptions?.nowMs ?? Date.now();
+          const rawTtl = authOptions?.ttlSeconds;
+          const ttlSeconds = Number.isFinite(rawTtl) && rawTtl > 0 ? Math.min(rawTtl, 3600) : 300;
+          const epoch = normalizeRealtimeChannelEpoch(authOptions?.epoch);
+          return {
+            token: createRealtimeChannelToken({
+              appName: options.appName,
+              channel,
+              channelKey,
+              args,
+              userId: user.id,
+              secret: options.channelTokenSecret,
+              ttlSeconds,
+              nowMs,
+              nonce: authOptions?.nonce,
+              epoch
+            }),
+            channel,
+            channelKey,
+            userId: user.id,
+            expiresAt: nowMs + Math.floor(ttlSeconds * 1e3),
+            ...epoch ? { epoch } : {}
+          };
+        },
+        publish(data, publishOptions) {
+          _hasEmitted = true;
+          dispatchEvent({
+            type: "channel_publish",
+            channelKey,
+            data,
+            eventId: publishOptions?.eventId ?? createRealtimeEventId()
+          });
+        },
+        invalidate() {
+          _hasEmitted = true;
+          dispatchEvent({ type: "channel_invalidate", channelKey });
+        },
+        revoke(revokeOptions) {
+          _hasEmitted = true;
+          const epoch = normalizeRealtimeChannelEpoch(revokeOptions?.epoch);
+          const reason = typeof revokeOptions?.reason === "string" && revokeOptions.reason.length > 0 ? revokeOptions.reason : void 0;
+          dispatchEvent({
+            type: "channel_revoke",
+            channelKey,
+            ...epoch ? { epoch } : {},
+            ...reason ? { reason } : {}
+          });
+        }
+      };
+    },
+    query(query2, args) {
+      const subscriptionKey = resolveRealtimeQuerySubscriptionKey({ query: query2, args });
+      if (!subscriptionKey)
+        throw new Error(`Realtime query "${query2}" resolved to an invalid subscriptionKey`);
+      const scopeHash = resolveRealtimeQueryScopeHash({ query: query2, args, subscriptionKey });
+      return {
+        authorize(authOptions) {
+          if (!options.appName || !options.channelTokenSecret || !options.auth) {
+            throw new Error("Authorized realtime query token signer is not configured");
+          }
+          const user = options.auth.requireAuth();
+          const nowMs = authOptions?.nowMs ?? Date.now();
+          const rawTtl = authOptions?.ttlSeconds;
+          const ttlSeconds = Number.isFinite(rawTtl) && rawTtl > 0 ? Math.min(rawTtl, 3600) : 300;
+          const epoch = normalizeRealtimeQuerySubscriptionEpoch(authOptions?.epoch);
+          return {
+            token: createRealtimeQuerySubscriptionToken({
+              appName: options.appName,
+              query: query2,
+              subscriptionKey,
+              args,
+              scopeHash,
+              policy: "authorized",
+              userId: user.id,
+              secret: options.channelTokenSecret,
+              ttlSeconds,
+              nowMs,
+              nonce: authOptions?.nonce,
+              epoch
+            }),
+            query: query2,
+            subscriptionKey,
+            policy: "authorized",
+            userId: user.id,
+            expiresAt: nowMs + Math.floor(ttlSeconds * 1e3),
+            ...epoch ? { epoch } : {}
+          };
+        },
+        invalidate(invalidateOptions) {
+          _hasEmitted = true;
+          dispatchEvent({
+            type: "query_invalidate",
+            query: query2,
+            subscriptionKey,
+            scopeHash,
+            eventId: invalidateOptions?.eventId ?? createRealtimeEventId()
+          });
+        },
+        revoke(revokeOptions) {
+          _hasEmitted = true;
+          const epoch = normalizeRealtimeQuerySubscriptionEpoch(revokeOptions?.epoch);
+          const reason = typeof revokeOptions?.reason === "string" && revokeOptions.reason.length > 0 ? revokeOptions.reason : void 0;
+          dispatchEvent({
+            type: "query_revoke",
+            query: query2,
+            subscriptionKey,
+            scopeHash,
+            ...epoch ? { epoch } : {},
+            ...reason ? { reason } : {}
+          });
+        }
+      };
+    },
+    invalidateScoped(input) {
+      _hasEmitted = true;
+      const subscriptionKey = input.subscriptionKey ?? resolveRealtimeQuerySubscriptionKey({ query: input.query, args: input.args });
+      if (!subscriptionKey)
+        throw new Error(`Realtime query "${input.query}" resolved to an invalid subscriptionKey`);
+      const scopeHash = input.scopeHash ?? resolveRealtimeQueryScopeHash({
+        query: input.query,
+        args: input.args,
+        subscriptionKey
+      });
+      dispatchEvent({
+        type: "query_invalidate",
+        query: input.query,
+        subscriptionKey,
+        scopeHash,
+        eventId: input.eventId ?? createRealtimeEventId()
+      });
+    },
+    invalidateCrudQuery(input) {
+      _hasEmitted = true;
+      const subscriptionKey = input.subscriptionKey ?? resolveRealtimeQuerySubscriptionKey({ query: input.query, args: input.args });
+      if (!subscriptionKey)
+        throw new Error(`Realtime query "${input.query}" resolved to an invalid subscriptionKey`);
+      const scopeHash = input.scopeHash ?? resolveRealtimeQueryScopeHash({
+        query: input.query,
+        args: input.args,
+        subscriptionKey
+      });
+      dispatchEvent({
+        type: "query_invalidate",
+        query: input.query,
+        subscriptionKey,
+        scopeHash,
+        eventId: input.eventId ?? createRealtimeEventId(),
+        legacyQueryKey: input.legacyQueryKey,
+        crudRealtimeEmitMode: input.crudRealtimeEmitMode ?? options.generatedCrudRealtimeEmitMode ?? "dual"
+      });
+    },
+    get _hasEmitted() {
+      return _hasEmitted;
+    },
+    get _pendingRefresh() {
+      return [..._pendingRefresh];
+    },
+    async _flushRefresh() {
+      if (_pendingRefresh.length === 0) return;
+      const qMap = options.queryMap ?? queryRegistry;
+      for (const key of _pendingRefresh) {
+        const legacyDef = qMap.get(key);
+        const procedureDef = legacyDef ? void 0 : options.getProcedureQuery?.(key);
+        if (!legacyDef && !procedureDef) {
+          console.warn(`[gencow] refresh("${key}"): query not found in registry. Skipping.`);
+          continue;
+        }
+        if (procedureDef?.inputSchema) {
+          options.fanout.notify({ type: "invalidate", queryKeys: [key] });
+          continue;
+        }
+        try {
+          if (!options.buildCtxForRefresh) {
+            console.warn(
+              `[gencow] \u26A0\uFE0F  refresh("${key}"): buildCtxForRefresh not provided. Query handler will receive an empty ctx \u2014 ctx.db will be undefined. This is a framework configuration error. \u{1F4A1} Ensure buildRealtimeCtx() receives a buildCtxForRefresh callback.`
+            );
+          }
+          const refreshCtx = options.buildCtxForRefresh?.() ?? {};
+          const result = legacyDef ? await legacyDef.handler(refreshCtx, {}) : await procedureDef.handler(refreshCtx, {});
+          dispatchEvent({ type: "emit", queryKey: key, data: result });
+        } catch (e) {
+          console.warn(`[gencow] refresh("${key}") failed:`, e instanceof Error ? e.message : e);
+        }
+      }
+      _pendingRefresh.length = 0;
+    },
+    async _flushRealtimeEvents() {
+      while (pendingEvents.length > 0) {
+        const event = pendingEvents.shift();
+        await options.fanout.notify(event);
+      }
+    }
+  };
+}
+
+// ../core/src/reactive-mutation.ts
+if (!globalThis.__gencow_mutationRegistry) globalThis.__gencow_mutationRegistry = [];
+var mutationRegistry = globalThis.__gencow_mutationRegistry;
+var mutationCounter = 0;
+function mutation(nameOrInvalidatesOrDef, handlerOrDef, name) {
+  let argsSchema;
+  let actualHandler;
+  let mutName;
+  let isPublic = false;
+  if (typeof nameOrInvalidatesOrDef === "string") {
+    mutName = nameOrInvalidatesOrDef;
+    const def2 = handlerOrDef;
+    actualHandler = def2.handler;
+    argsSchema = def2.args;
+    isPublic = def2.public === true;
+  } else if (Array.isArray(nameOrInvalidatesOrDef)) {
+    actualHandler = handlerOrDef;
+    mutName = name || `mutation_${++mutationCounter}`;
+  } else {
+    actualHandler = nameOrInvalidatesOrDef.handler;
+    argsSchema = nameOrInvalidatesOrDef.args;
+    isPublic = nameOrInvalidatesOrDef.public === true;
+    mutName = nameOrInvalidatesOrDef.name || (typeof name === "string" ? name : "") || `mutation_${++mutationCounter}`;
+  }
+  if (mutName.startsWith("mutation_")) {
+    console.warn(
+      `[gencow] mutation registered without explicit name \u2192 "${mutName}". Use mutation("myMutation", { handler }) for better debugging.`
+    );
+  }
+  const def = {
+    name: mutName,
+    handler: actualHandler,
+    argsSchema,
+    isPublic
+  };
+  mutationRegistry.push(def);
+  return def;
+}
+function getRegisteredMutations() {
+  return [...mutationRegistry];
+}
+
+// ../core/src/procedure.ts
+function hasStandardSchema3(schema) {
+  return !!schema && typeof schema === "object" && "~standard" in schema && !!schema["~standard"] && typeof schema["~standard"].validate === "function";
+}
+async function validateWithSchema(schema, value, options) {
+  if (!schema) return value;
+  const valueToValidate = options?.normalizeMissingOptionalObject ? normalizeMissingOptionalObjectInput(schema, value) : value;
+  if (hasStandardSchema3(schema)) {
+    const result = await schema["~standard"].validate(valueToValidate);
+    if ("issues" in result && result.issues.length > 0) {
+      throw new GencowValidationError(result.issues[0]?.message ?? "Validation failed");
+    }
+    if ("value" in result) {
+      return result.value;
+    }
+    throw new GencowValidationError("Validation failed");
+  }
+  throw new Error("procedure.query / procedure.mutation / procedure.internal only supports Standard Schema v1 validators");
+}
+function composeMiddlewares(middlewares, handler, inputSchema, outputSchema, inputValidationIndex, outputValidationIndex) {
+  return async (initialContext, initialInput) => {
+    let idx = -1;
+    const boundedInputValidationIndex = Math.min(Math.max(0, inputValidationIndex), middlewares.length);
+    const boundedOutputValidationIndex = Math.min(Math.max(0, outputValidationIndex), middlewares.length);
+    const run = async (currentIdx, context, input) => {
+      if (currentIdx <= idx) {
+        throw new Error("next() called multiple times in the same middleware");
+      }
+      idx = currentIdx;
+      let currentInput = input;
+      if (currentIdx === boundedInputValidationIndex) {
+        currentInput = await validateWithSchema(inputSchema, currentInput, {
+          normalizeMissingOptionalObject: true
+        });
+      }
+      if (currentIdx === middlewares.length) {
+        const output2 = await handler({ context, input: currentInput });
+        if (currentIdx === boundedOutputValidationIndex) {
+          return await validateWithSchema(outputSchema, output2);
+        }
+        return output2;
+      }
+      const middleware = middlewares[currentIdx];
+      const output = await middleware({
+        context,
+        input: currentInput,
+        next: async (overrides) => {
+          return await run(
+            currentIdx + 1,
+            overrides?.context ?? context,
+            overrides?.input ?? currentInput
+          );
+        }
+      });
+      if (currentIdx === boundedOutputValidationIndex) {
+        return await validateWithSchema(outputSchema, output);
+      }
+      return output;
+    };
+    return await run(0, initialContext, initialInput);
+  };
+}
+var GencowProcedureBuilderImpl = class _GencowProcedureBuilderImpl {
+  constructor(kind, procedureName, middlewares = [], inputSchema, outputSchema, inputValidationIndex = -1, outputValidationIndex = -1, anonymousAllowed = false) {
+    this.kind = kind;
+    this.procedureName = procedureName;
+    this.middlewares = middlewares;
+    this.inputSchema = inputSchema;
+    this.outputSchema = outputSchema;
+    this.inputValidationIndex = inputValidationIndex;
+    this.outputValidationIndex = outputValidationIndex;
+    this.anonymousAllowed = anonymousAllowed;
+  }
+  kind;
+  procedureName;
+  middlewares;
+  inputSchema;
+  outputSchema;
+  inputValidationIndex;
+  outputValidationIndex;
+  anonymousAllowed;
+  name(name) {
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      name,
+      this.middlewares,
+      this.inputSchema,
+      this.outputSchema,
+      this.inputValidationIndex,
+      this.outputValidationIndex,
+      this.anonymousAllowed
+    );
+  }
+  allowAnonymous() {
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      this.procedureName,
+      this.middlewares,
+      this.inputSchema,
+      this.outputSchema,
+      this.inputValidationIndex,
+      this.outputValidationIndex,
+      true
+    );
+  }
+  use(middleware) {
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      this.procedureName,
+      [...this.middlewares, middleware],
+      this.inputSchema,
+      this.outputSchema,
+      this.inputValidationIndex,
+      this.outputValidationIndex,
+      this.anonymousAllowed
+    );
+  }
+  input(schema) {
+    const nextInputValidationIndex = this.middlewares.length < 0 ? 0 : this.middlewares.length;
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      this.procedureName,
+      this.middlewares,
+      schema,
+      this.outputSchema,
+      nextInputValidationIndex,
+      this.outputValidationIndex,
+      this.anonymousAllowed
+    );
+  }
+  output(schema) {
+    const nextOutputValidationIndex = this.middlewares.length < 0 ? 0 : this.middlewares.length;
+    return new _GencowProcedureBuilderImpl(
+      this.kind,
+      this.procedureName,
+      this.middlewares,
+      this.inputSchema,
+      schema,
+      this.inputValidationIndex,
+      nextOutputValidationIndex,
+      this.anonymousAllowed
+    );
+  }
+  handler(handler) {
+    if (!this.procedureName) {
+      throw new Error("Procedure name is required. Call .name(...) before .handler(...)");
+    }
+    const run = composeMiddlewares(
+      this.middlewares,
+      handler,
+      this.inputSchema,
+      this.outputSchema,
+      this.inputValidationIndex,
+      this.outputValidationIndex
+    );
+    return {
+      kind: this.kind,
+      name: this.procedureName,
+      allowAnonymous: this.kind === "internal" ? false : this.anonymousAllowed,
+      middlewares: [...this.middlewares],
+      inputSchema: this.inputSchema,
+      outputSchema: this.outputSchema,
+      inputValidationIndex: this.inputValidationIndex,
+      outputValidationIndex: this.outputValidationIndex,
+      handler: run
+    };
+  }
+};
+function createGencowProcedureBuilders() {
+  return {
+    query: new GencowProcedureBuilderImpl("query"),
+    mutation: new GencowProcedureBuilderImpl("mutation"),
+    internal: new GencowProcedureBuilderImpl("internal")
+  };
+}
+
+// ../core/src/http-action.ts
+if (!globalThis.__gencow_httpActionRegistry) globalThis.__gencow_httpActionRegistry = [];
+var httpActionRegistry = globalThis.__gencow_httpActionRegistry;
+function httpAction(def) {
+  const actionDef = {
+    method: def.method,
+    path: def.path,
+    isPublic: def.public === true,
+    handler: def.handler
+  };
+  httpActionRegistry.push(actionDef);
+  return actionDef;
+}
+function getRegisteredHttpActions() {
+  return [...httpActionRegistry];
+}
+
+// ../core/src/realtime-channel-registry.ts
+if (!globalThis.__gencow_realtimeChannelRegistry) {
+  globalThis.__gencow_realtimeChannelRegistry = /* @__PURE__ */ new Map();
+}
+var realtimeChannelRegistry = globalThis.__gencow_realtimeChannelRegistry;
+var LEGACY_REGISTRATION_VERSION = /* @__PURE__ */ Symbol("gencow.realtimeChannelRegistrationVersion");
+var legacyRegistrationVersion = 0;
+function registrationVersion(definition) {
+  return definition[LEGACY_REGISTRATION_VERSION];
+}
+function copyLegacyDefinition(definition) {
+  const copy = { ...definition };
+  const version = registrationVersion(definition);
+  if (version !== void 0) {
+    Object.defineProperty(copy, LEGACY_REGISTRATION_VERSION, { value: version });
+  }
+  return copy;
+}
+function defineRealtimeChannels(channels) {
+  for (const [name, def] of Object.entries(channels)) {
+    const registered = {
+      name,
+      argsSchema: def.args,
+      channelKey: def.channelKey,
+      authorize: def.authorize
+    };
+    Object.defineProperty(registered, LEGACY_REGISTRATION_VERSION, { value: ++legacyRegistrationVersion });
+    realtimeChannelRegistry.set(name, registered);
+  }
+  return channels;
+}
+function getRealtimeChannelDef(name) {
+  return realtimeChannelRegistry.get(name);
+}
+function getRegisteredRealtimeChannels() {
+  return [...realtimeChannelRegistry.keys()];
+}
+function captureLegacyRealtimeChannels() {
+  return [...realtimeChannelRegistry.values()].map(copyLegacyDefinition);
+}
+function selectLegacyRealtimeChannelSnapshot(before, after) {
+  const prior = new Map(before.map((definition) => [definition.name, definition]));
+  return after.filter((definition) => {
+    const existing = prior.get(definition.name);
+    return !existing || registrationVersion(existing) !== registrationVersion(definition) || existing.authorize !== definition.authorize || existing.channelKey !== definition.channelKey;
+  });
+}
+function resolveRealtimeChannelKey(params) {
+  if (params.result === false || params.result === null) return null;
+  if (typeof params.result === "string") return params.result.length > 0 ? params.result : null;
+  if (params.result && typeof params.result === "object" && "channelKey" in params.result) {
+    const channelKey2 = params.result.channelKey;
+    if (channelKey2 !== void 0)
+      return typeof channelKey2 === "string" && channelKey2.length > 0 ? channelKey2 : null;
+  }
+  const def = getRealtimeChannelDef(params.channel);
+  const channelKey = def?.channelKey?.(params.args);
+  if (channelKey !== void 0)
+    return typeof channelKey === "string" && channelKey.length > 0 ? channelKey : null;
+  return buildRealtimeChannelKey(params.channel, params.args);
+}
+function resetRealtimeChannelRegistryForTests() {
+  realtimeChannelRegistry.clear();
+}
+
+// ../core/src/realtime-ticket.ts
+import { createHmac as createHmac3, randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual3 } from "crypto";
+var TICKET_PREFIX = "gencow_ws1";
+var DEFAULT_TTL_SECONDS3 = 60;
+var MAX_TTL_SECONDS3 = 120;
+var MAX_TICKET_LENGTH = 4096;
+function encodeBase64Url3(value) {
+  return Buffer.from(value, "utf8").toString("base64url");
+}
+function decodeBase64Url3(value) {
+  try {
+    return Buffer.from(value, "base64url").toString("utf8");
+  } catch {
+    return null;
+  }
+}
+function signSegment3(segment, secret) {
+  return createHmac3("sha256", secret).update(segment).digest("base64url");
+}
+function safeEqual3(a, b) {
+  const left = Buffer.from(a);
+  const right = Buffer.from(b);
+  return left.length === right.length && timingSafeEqual3(left, right);
+}
+function validateRequiredString3(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${label} required`);
+  }
+}
+function resolveTtlMs3(ttlSeconds) {
+  const ttl = Number.isFinite(ttlSeconds) && ttlSeconds > 0 ? ttlSeconds : DEFAULT_TTL_SECONDS3;
+  return Math.floor(Math.min(ttl, MAX_TTL_SECONDS3) * 1e3);
+}
+function randomNonce3() {
+  return randomBytes3(16).toString("base64url");
+}
+function resolveRealtimeCapabilityNegotiation(value) {
+  const record = value && typeof value === "object" ? value : null;
+  return {
+    crudRealtimeMode: record?.crudRealtimeMode === "scoped" ? "scoped" : "legacy"
   };
 }
 function createRealtimeTicket(input) {
@@ -1886,7 +2149,7 @@ function isJobAdmissionKillSwitchActive(env, scope) {
 }
 
 // ../core/src/workflow.ts
-import { sql as sql4 } from "drizzle-orm";
+import { sql as sql3 } from "drizzle-orm";
 
 // ../core/src/workflow-admission.ts
 import { sql } from "drizzle-orm";
@@ -2093,9 +2356,6 @@ function workflowJsonb(value) {
 var WORKFLOW_WAKE_SIGNAL_CHANNEL = "gencow_app_wake_v1";
 var WORKFLOW_WAKE_SIGNAL_PAYLOAD = JSON.stringify({ kind: "workflow" });
 
-// ../core/src/workflows-api.ts
-import { sql as sql3 } from "drizzle-orm";
-
 // ../core/src/workflow-payload-policy.ts
 var CHECKPOINT_MODE_ENV = "GENCOW_WORKFLOW_CHECKPOINT_LIMIT_MODE";
 var CHECKPOINT_SOFT_LIMIT_ENV = "GENCOW_WORKFLOW_CHECKPOINT_SOFT_LIMIT_BYTES";
@@ -2169,232 +2429,173 @@ function assertWorkflowPayloadWithinLimit(params) {
   return sizeBytes;
 }
 
-// ../core/src/workflow-types.ts
-function deriveWorkflowStatus(status, currentStep) {
-  if (status !== "pending") {
-    return status;
-  }
-  if (currentStep?.startsWith("sleep#")) {
-    return "sleeping";
-  }
-  if (currentStep?.startsWith("wait:")) {
-    return "waiting";
-  }
-  return "queued";
-}
-
-// ../core/src/workflows-api.ts
-var WORKFLOW_STATUSES = /* @__PURE__ */ new Set(["pending", "running", "completed", "failed"]);
-var WORKFLOW_DERIVED_PENDING_STATUSES = /* @__PURE__ */ new Set(["queued", "waiting", "sleeping"]);
-function rowsFromResult(result) {
-  if (Array.isArray(result)) return result;
-  if (result && typeof result === "object" && Array.isArray(result.rows)) {
-    return result.rows;
-  }
-  return [];
+// ../core/src/workflow.ts
+var workflowRegistry = globalThis.__gencow_workflowRegistry ??= /* @__PURE__ */ new Map();
+var WORKFLOW_DEFINITION_METADATA = /* @__PURE__ */ Symbol.for("@gencow/core/workflow-definition");
+var DEFAULT_WORKFLOW_MAX_DURATION_MS = 30 * 60 * 1e3;
+var DEFAULT_WORKFLOW_MAX_RETRIES = 3;
+var WORKFLOW_RESUME_ACTION_PREFIX = "__gencow.workflow.resume";
+var WORKFLOW_REALTIME_KEY_PREFIX = "__gencow.workflow.state";
+function isSerializedWorkflowValue(value) {
+  return !!value && typeof value === "object" && ("__gencowUndefined" in value || "value" in value);
 }
-function parseJsonField(value) {
-  if (typeof value !== "string") return value;
+function serializeWorkflowValue(value) {
+  const payload = value === void 0 ? { __gencowUndefined: true } : { value };
   try {
-    return JSON.parse(value);
-  } catch {
-    return value;
+    return JSON.parse(JSON.stringify(payload));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `workflow() only persists JSON-serializable values. Failed to serialize workflow payload: ${reason}`
+    );
   }
 }
-function toIsoString(value) {
-  if (value instanceof Date) return value.toISOString();
-  const parsed = new Date(value);
-  return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : String(value);
-}
-function toOptionalIsoString(value) {
-  return value ? toIsoString(value) : null;
-}
-function mapWorkflowSummary(row) {
-  return {
-    id: row.id,
-    name: row.name,
-    status: row.status,
-    derivedStatus: deriveWorkflowStatus(row.status, row.current_step),
-    currentStep: row.current_step,
-    error: row.error,
-    errorCode: row.error_code,
-    retryCount: row.retry_count,
-    maxRetries: row.max_retries,
-    maxDurationMs: Number(row.max_duration_ms),
-    startedAt: toIsoString(row.started_at),
-    updatedAt: toIsoString(row.updated_at),
-    completedAt: toOptionalIsoString(row.completed_at)
-  };
-}
-function mapWorkflowStep(row) {
-  return {
-    name: row.step_name,
-    status: row.status,
-    output: deserializeWorkflowValue(parseJsonField(row.output)),
-    error: row.error,
-    startedAt: toOptionalIsoString(row.started_at),
-    updatedAt: toIsoString(row.updated_at),
-    completedAt: toOptionalIsoString(row.completed_at)
-  };
+function deserializeWorkflowValue(value) {
+  if (!isSerializedWorkflowValue(value)) return value;
+  if ("__gencowUndefined" in value) return void 0;
+  return value.value;
 }
-function normalizeListLimit(limit) {
-  if (limit == null) return 20;
-  if (!Number.isFinite(limit)) {
-    throw new GencowValidationError(`Argument "limit": expected a finite number, got ${limit}`);
+function clampRetries(retries) {
+  if (retries == null) return DEFAULT_WORKFLOW_MAX_RETRIES;
+  if (!Number.isFinite(retries) || retries < 0) {
+    throw new Error(`workflow() retries must be a non-negative finite number, got "${retries}"`);
   }
-  return Math.max(1, Math.min(100, Math.floor(limit)));
+  return Math.floor(retries);
 }
-function normalizeStatus(status) {
-  if (status == null) return void 0;
-  if (!WORKFLOW_STATUSES.has(status)) {
-    throw new GencowValidationError(`Argument "status": expected one of pending, running, completed, failed`);
+function parseDurationString(raw, label) {
+  const normalized = raw.trim().toLowerCase();
+  const match = normalized.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match) {
+    throw new Error(`${label} must be a number of ms or a string like "30m", "90s", "1h" \u2014 got "${raw}"`);
   }
-  return status;
+  const value = Number(match[1]);
+  const unit = match[2];
+  const unitMs = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return value * unitMs;
 }
-function normalizeDerivedStatus(status) {
-  if (status == null) return void 0;
-  if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
-    return status;
+function parseWorkflowDurationMs(raw, label = "workflow duration") {
+  if (typeof raw === "number") {
+    if (!Number.isFinite(raw) || raw <= 0) {
+      throw new Error(`${label} must be a positive finite number, got "${raw}"`);
+    }
+    return Math.floor(raw);
   }
-  return normalizeStatus(status);
-}
-function toWorkflowStatusFilter(status) {
-  if (status == null) return void 0;
-  if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
-    return "pending";
+  if (typeof raw !== "string") {
+    throw new Error(
+      `${label} must be a positive finite number or a string like "30m", "90s", "1h" \u2014 got "${String(raw)}"`
+    );
   }
-  return status;
+  return parseDurationString(raw, label);
 }
-async function ensureWorkflowRealtimeToken(db, workflowId, currentToken) {
-  if (currentToken && currentToken.trim() !== "") return currentToken;
-  const nextToken = createWorkflowRealtimeToken();
-  const updateResult = await db.execute(sql3`
-        UPDATE _gencow_workflows
-        SET realtime_token = ${nextToken}
-        WHERE id = ${workflowId}
-          AND (realtime_token IS NULL OR realtime_token = '')
-        RETURNING realtime_token
-    `);
-  const updatedToken = rowsFromResult(updateResult)[0]?.realtime_token ?? null;
-  if (updatedToken && updatedToken.trim() !== "") return updatedToken;
-  const rereadResult = await db.execute(sql3`
-        SELECT realtime_token
-        FROM _gencow_workflows
-        WHERE id = ${workflowId}
-        LIMIT 1
-    `);
-  const rereadToken = rowsFromResult(rereadResult)[0]?.realtime_token ?? null;
-  return rereadToken && rereadToken.trim() !== "" ? rereadToken : null;
+function normalizeMaxDurationMs(maxDuration, label = "workflow() maxDuration") {
+  if (maxDuration == null) return DEFAULT_WORKFLOW_MAX_DURATION_MS;
+  return parseWorkflowDurationMs(maxDuration, label);
 }
-async function loadWorkflowSignalTarget(db, workflowId) {
-  const result = await db.execute(sql3`
-        SELECT
-            id,
-            name,
-            status,
-            current_step,
-            user_id
-        FROM _gencow_workflows
-        WHERE id = ${workflowId}
-        LIMIT 1
-  `);
-  return rowsFromResult(result)[0] ?? null;
+function normalizeOptionalDurationMs(duration, label) {
+  return duration == null ? null : parseWorkflowDurationMs(duration, label);
 }
-function isMissingWorkflowV2SignalSchemaError(error) {
-  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
-  const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
-  const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
-  const message = error instanceof Error ? error.message : String(error);
-  return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || (code === "23503" || causeCode === "23503") && message.includes("_gencow_workflow_signals_v2") || message.includes('relation "_gencow_workflow_signals_v2" does not exist') || message.includes("relation _gencow_workflow_signals_v2 does not exist") || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_outbox_v2" does not exist') || message.includes("relation _gencow_workflow_outbox_v2 does not exist") || message.includes('relation "_gencow_workflow_steps_v2" does not exist') || message.includes("relation _gencow_workflow_steps_v2 does not exist");
+function normalizeConcurrency(concurrency) {
+  if (concurrency == null) return null;
+  if (!Number.isFinite(concurrency) || concurrency <= 0) {
+    throw new Error(`workflow() concurrency must be a positive finite number, got "${concurrency}"`);
+  }
+  return Math.floor(concurrency);
 }
-function isMissingWorkflowV2PayloadSchemaError(error) {
+function isMissingWorkflowV2SchemaError2(error) {
   const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
   const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
   const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
   const message = error instanceof Error ? error.message : String(error);
-  return code === "42P01" || causeCode === "42P01" || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_steps_v2" does not exist') || message.includes("relation _gencow_workflow_steps_v2 does not exist");
+  return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_outbox_v2" does not exist') || message.includes("relation _gencow_workflow_outbox_v2 does not exist") || message.includes('column "max_active_duration_ms"') || message.includes('column "retry_count"') || message.includes('column "user_id"');
 }
-async function loadWorkflowV2PayloadSnapshot(db, workflowId) {
-  try {
-    const runResult = await db.execute(sql3`
-      SELECT args_json, result_json
-      FROM _gencow_workflow_runs_v2
-      WHERE id = ${workflowId}
-      LIMIT 1
-    `);
-    const run = rowsFromResult(runResult)[0];
-    if (!run) return null;
-    const stepResult = await db.execute(sql3`
-      SELECT step_key, output_json
-      FROM _gencow_workflow_steps_v2
-      WHERE run_id = ${workflowId}
-    `);
-    return {
-      run,
-      steps: new Map(
-        rowsFromResult(stepResult).map((step) => [
-          step.step_key,
-          parseJsonField(step.output_json)
-        ])
-      )
-    };
-  } catch (error) {
-    if (isMissingWorkflowV2PayloadSchemaError(error)) return null;
-    throw error;
+function rows2(result) {
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object" && Array.isArray(result.rows)) {
+    return result.rows;
   }
+  return [];
 }
-async function tryRecordWorkflowV2Signal(options) {
+function numberFrom2(value) {
+  const parsed = Number(value ?? 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+async function hasWorkflowV2StartSchema(db) {
+  const runColumns = [
+    "id",
+    "workflow_name",
+    "workflow_version",
+    "args_json",
+    "user_id",
+    "max_active_duration_ms",
+    "lifecycle_deadline_at",
+    "retry_count",
+    "max_retries",
+    "max_attempts"
+  ];
+  const outboxColumns = ["id", "run_id", "kind", "available_at", "status"];
+  const runColumnList = sql3.join(
+    runColumns.map((column) => sql3`${column}`),
+    sql3`, `
+  );
+  const outboxColumnList = sql3.join(
+    outboxColumns.map((column) => sql3`${column}`),
+    sql3`, `
+  );
+  const result = await db.execute(sql3`
+    SELECT
+      (
+        SELECT COUNT(*)::int
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = '_gencow_workflow_runs_v2'
+          AND column_name IN (${runColumnList})
+      ) AS run_column_count,
+      (
+        SELECT COUNT(*)::int
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = '_gencow_workflow_outbox_v2'
+          AND column_name IN (${outboxColumnList})
+      ) AS outbox_column_count
+  `);
+  const row = rows2(result)[0];
+  return numberFrom2(row?.run_column_count) === runColumns.length && numberFrom2(row?.outbox_column_count) === outboxColumns.length;
+}
+async function tryInsertWorkflowV2Run(options) {
   try {
+    if (!await hasWorkflowV2StartSchema(options.db)) return false;
     await options.db.execute(sql3`
-      WITH inserted AS (
-        INSERT INTO _gencow_workflow_signals_v2 (
-          id,
-          run_id,
-          event_name,
-          payload_json,
-          idempotency_key
-        )
-        VALUES (
-          ${crypto.randomUUID()},
-          ${options.workflowId},
-          ${options.event},
-          ${workflowJsonb(options.payload)},
-          ${crypto.randomUUID()}
-        )
-        RETURNING id, run_id
-      ),
-      inserted_legacy AS (
-        INSERT INTO _gencow_workflow_events (
+      WITH inserted_run AS (
+        INSERT INTO _gencow_workflow_runs_v2 (
           id,
-          workflow_id,
-          event_name,
-          payload
+          workflow_name,
+          workflow_version,
+          args_json,
+          user_id,
+          max_active_duration_ms,
+          lifecycle_deadline_at,
+          retry_count,
+          max_retries,
+          max_attempts
         )
         VALUES (
-          ${options.eventId},
           ${options.workflowId},
-          ${options.event},
-          NULL
+          ${options.workflowName},
+          ${options.workflowVersion ?? null},
+          ${workflowJsonb(options.args)},
+          ${options.userId},
+          ${options.maxActiveDurationMs},
+          CASE
+            WHEN ${options.lifecycleTimeoutMs}::bigint IS NULL THEN NULL
+            ELSE NOW() + (${options.lifecycleTimeoutMs}::bigint * INTERVAL '1 millisecond')
+          END,
+          0,
+          ${options.maxRetries},
+          ${options.maxRetries + 1}
         )
         RETURNING id
       ),
-      queued_run AS (
-        UPDATE _gencow_workflow_runs_v2 run
-        SET
-          status = 'queued',
-          runnable_at = NOW(),
-          lease_owner = NULL,
-          lease_expires_at = NULL,
-          heartbeat_at = NULL,
-          updated_at = NOW()
-        FROM inserted
-        WHERE run.id = inserted.run_id
-          AND run.status = 'waiting'
-          AND run.completed_at IS NULL
-          AND run.cancel_requested_at IS NULL
-        RETURNING run.id
-      ),
-      wake_outbox AS (
+      inserted_outbox AS (
         INSERT INTO _gencow_workflow_outbox_v2 (
           id,
           run_id,
@@ -2403,404 +2604,538 @@ async function tryRecordWorkflowV2Signal(options) {
           status
         )
         SELECT
-          'signal:' || inserted.id,
-          inserted.run_id,
-          'wake_signal',
+          'start:' || inserted_run.id,
+          inserted_run.id,
+          'wake_run',
           NOW(),
           'pending'
-        FROM inserted
-        JOIN queued_run ON queued_run.id = inserted.run_id
+        FROM inserted_run
         ON CONFLICT (id) DO NOTHING
         RETURNING id
       ),
       wake_notified AS (
         SELECT pg_notify(${WORKFLOW_WAKE_SIGNAL_CHANNEL}, ${WORKFLOW_WAKE_SIGNAL_PAYLOAD})
-        FROM wake_outbox
+        FROM inserted_outbox
       )
-      SELECT 1
-      FROM inserted
-      LEFT JOIN inserted_legacy ON TRUE
+      SELECT inserted_run.id
+      FROM inserted_run
       LEFT JOIN wake_notified ON TRUE
     `);
     return true;
   } catch (error) {
-    if (isMissingWorkflowV2SignalSchemaError(error)) return false;
+    if (isMissingWorkflowV2SchemaError2(error)) return false;
     throw error;
-  }
-}
-async function loadWorkflowSnapshot(db, workflowId, options) {
-  const workflowResult = await db.execute(sql3`
-        SELECT
-            id,
-            name,
-            args,
-            status,
-            current_step,
-            result,
-            error,
-            error_code,
-            retry_count,
-            max_retries,
-            max_duration_ms,
-            started_at,
-            updated_at,
-            completed_at,
-            realtime_token,
-            user_id
-        FROM _gencow_workflows
-        WHERE id = ${workflowId}
-        LIMIT 1
-    `);
-  const row = rowsFromResult(workflowResult)[0] ?? null;
-  if (!row) return null;
-  const viewerUserId = options?.viewerUserId ?? null;
-  if (options?.requireViewerMatch && row.user_id && row.user_id !== viewerUserId) {
-    return null;
-  }
-  const realtimeToken = await ensureWorkflowRealtimeToken(db, workflowId, row.realtime_token);
-  if (!realtimeToken) return null;
-  const v2Payload = await loadWorkflowV2PayloadSnapshot(db, workflowId);
-  const stepsResult = await db.execute(sql3`
-        SELECT
-            step_name,
-            status,
-            output,
-            error,
-            started_at,
-            updated_at,
-            completed_at
-        FROM _gencow_workflow_steps
-        WHERE workflow_id = ${workflowId}
-        ORDER BY COALESCE(started_at, updated_at) ASC, step_name ASC
-    `);
-  const steps = rowsFromResult(stepsResult).map((stepRow) => {
-    const mapped = mapWorkflowStep(stepRow);
-    return v2Payload?.steps.has(stepRow.step_name) ? { ...mapped, output: v2Payload.steps.get(stepRow.step_name) } : mapped;
-  });
-  return {
-    ...mapWorkflowSummary(row),
-    args: v2Payload ? deserializeWorkflowValue(parseJsonField(v2Payload.run.args_json)) : deserializeWorkflowValue(parseJsonField(row.args)),
-    result: v2Payload ? parseJsonField(v2Payload.run.result_json) : deserializeWorkflowValue(parseJsonField(row.result)),
-    steps,
-    realtimeKey: getWorkflowRealtimeKey(row.id, realtimeToken)
-  };
-}
-function registerWorkflowsApi() {
-  if (globalThis.__gencow_workflowsApiRegistered) return;
-  globalThis.__gencow_workflowsApiRegistered = true;
-  query("workflows.get", {
-    args: { id: v.string() },
-    public: true,
-    handler: async (ctx, args) => {
-      return loadWorkflowSnapshot(ctx.unsafeDb, args.id, {
-        viewerUserId: ctx.auth.getUserIdentity()?.id ?? null,
-        requireViewerMatch: true
-      });
-    }
-  });
-  mutation("workflows.signal", {
-    args: {
-      id: v.string(),
-      event: v.string(),
-      payload: v.optional(v.any())
-    },
-    public: true,
-    handler: async (ctx, args) => {
-      const normalizedEvent = args.event.trim();
-      if (!normalizedEvent) {
-        throw new GencowValidationError(`Argument "event": expected a non-empty string`);
-      }
-      const workflow2 = await loadWorkflowSignalTarget(ctx.unsafeDb, args.id);
-      const viewerUserId = ctx.auth.getUserIdentity()?.id ?? null;
-      if (!workflow2 || workflow2.user_id && workflow2.user_id !== viewerUserId) {
-        return {
-          ok: false,
-          workflowId: args.id,
-          event: normalizedEvent,
-          scheduledJobId: null
-        };
-      }
-      if (workflow2.status === "completed" || workflow2.status === "failed") {
-        return {
-          ok: false,
-          workflowId: workflow2.id,
-          event: normalizedEvent,
-          scheduledJobId: null
-        };
-      }
-      const persistedPayload = serializeWorkflowValue(args.payload);
-      assertWorkflowPayloadWithinLimit({
-        workflowName: workflow2.name,
-        kind: "signal",
-        serializedValue: persistedPayload
+  }
+}
+async function tryDeleteWorkflowV2Run(db, workflowId) {
+  try {
+    await db.execute(sql3`
+      DELETE FROM _gencow_workflow_runs_v2
+      WHERE id = ${workflowId}
+    `);
+  } catch (error) {
+    if (!isMissingWorkflowV2SchemaError2(error)) throw error;
+  }
+}
+function getWorkflowResumeActionName(name) {
+  return `${WORKFLOW_RESUME_ACTION_PREFIX}.${name}`;
+}
+function createWorkflowRealtimeToken() {
+  return crypto.randomUUID().replace(/-/g, "");
+}
+function getWorkflowRealtimeKey(workflowId, realtimeToken) {
+  return `${WORKFLOW_REALTIME_KEY_PREFIX}.${workflowId}.${realtimeToken}`;
+}
+function getWorkflowDef(name) {
+  return workflowRegistry.get(name);
+}
+function getRegisteredWorkflows() {
+  return Array.from(workflowRegistry.values());
+}
+function hasStandardSchema4(schema) {
+  return !!schema && typeof schema === "object" && "~standard" in schema && !!schema["~standard"] && typeof schema["~standard"].validate === "function";
+}
+async function validateWorkflowStartInput(schema, value) {
+  if (!schema) return value;
+  const result = await schema["~standard"].validate(normalizeMissingOptionalObjectInput(schema, value));
+  if ("issues" in result && result.issues.length > 0) {
+    throw new GencowValidationError(result.issues[0]?.message ?? "Validation failed");
+  }
+  if ("value" in result) return result.value;
+  throw new GencowValidationError("Validation failed");
+}
+function composeWorkflowStartMiddleware(options) {
+  return async (initialContext, initialInput) => {
+    let lastIndex = -1;
+    const validationIndex = Math.min(Math.max(0, options.inputValidationIndex), options.middlewares.length);
+    const run = async (index, context, input) => {
+      if (index <= lastIndex) throw new Error("next() called multiple times in the same middleware");
+      lastIndex = index;
+      const validatedInput = index === validationIndex ? await validateWorkflowStartInput(options.inputSchema, input) : input;
+      if (index === options.middlewares.length) return await options.handler(context, validatedInput);
+      return await options.middlewares[index]({
+        context,
+        input: validatedInput,
+        next: async (overrides) => await run(
+          index + 1,
+          overrides?.context ?? context,
+          overrides?.input ?? validatedInput
+        )
       });
-      const eventId = crypto.randomUUID();
-      const recordedV2 = await tryRecordWorkflowV2Signal({
-        db: ctx.unsafeDb,
-        workflowId: workflow2.id,
-        event: normalizedEvent,
-        eventId,
-        payload: persistedPayload
+    };
+    return await run(0, initialContext, initialInput);
+  };
+}
+async function startWorkflowRun(ctx, args, def) {
+  const workflowId = crypto.randomUUID();
+  const resumeAction = getWorkflowResumeActionName(def.name);
+  const ownerId = ctx.auth.getUserIdentity()?.id ?? null;
+  const persistedArgs = serializeWorkflowValue(args ?? {});
+  assertWorkflowPayloadWithinLimit({ workflowName: def.name, kind: "args", serializedValue: persistedArgs });
+  const realtimeToken = createWorkflowRealtimeToken();
+  let insertedWorkflowV2 = false;
+  try {
+    await runWorkflowAdmissionCriticalSection(ctx.unsafeDb, async (db) => {
+      await applyWorkflowStartAdmission({ db, workflowName: def.name, args: persistedArgs });
+      insertedWorkflowV2 = await tryInsertWorkflowV2Run({
+        db,
+        workflowId,
+        workflowName: def.name,
+        workflowVersion: def.version ?? null,
+        args: persistedArgs,
+        userId: ownerId,
+        maxActiveDurationMs: def.maxActiveDurationMs,
+        lifecycleTimeoutMs: def.lifecycleTimeoutMs,
+        maxRetries: def.maxRetries
       });
-      if (!recordedV2) {
-        await ctx.unsafeDb.execute(sql3`
-                INSERT INTO _gencow_workflow_events (
-                    id,
-                    workflow_id,
-                    event_name,
-                    payload
-                )
-                VALUES (
-                    ${eventId},
-                    ${workflow2.id},
-                    ${normalizedEvent},
-                  ${workflowJsonb(persistedPayload)}
-                )
-            `);
-      }
-      let scheduledJobId = null;
-      if (workflow2.status === "pending" && workflow2.current_step?.startsWith("wait:")) {
-        try {
-          scheduledJobId = ctx.scheduler.runAfter(0, getWorkflowResumeActionName(workflow2.name), {
-            workflowId: workflow2.id
-          });
-        } catch {
-          scheduledJobId = null;
-        }
-      }
-      return {
-        ok: true,
-        workflowId: workflow2.id,
-        event: normalizedEvent,
-        scheduledJobId
-      };
-    }
+      const legacyArgs = insertedWorkflowV2 ? serializeWorkflowValue(void 0) : persistedArgs;
+      await db.execute(sql3`
+        INSERT INTO _gencow_workflows (
+          id, name, args, realtime_token, status, retry_count, max_retries, max_duration_ms, user_id
+        ) VALUES (
+          ${workflowId}, ${def.name}, ${workflowJsonb(legacyArgs)}, ${realtimeToken}, 'pending', 0,
+          ${def.maxRetries}, ${def.maxActiveDurationMs}, ${ownerId}
+        )
+      `);
+    });
+    return {
+      id: workflowId,
+      name: def.name,
+      status: "pending",
+      scheduledJobId: insertedWorkflowV2 ? `start:${workflowId}` : ctx.scheduler.runAfter(0, resumeAction, { workflowId })
+    };
+  } catch (error) {
+    await ctx.unsafeDb.execute(sql3`DELETE FROM _gencow_workflows WHERE id = ${workflowId}`);
+    if (insertedWorkflowV2) await tryDeleteWorkflowV2Run(ctx.unsafeDb, workflowId);
+    throw error;
+  }
+}
+function createWorkflowMetadata(options) {
+  const { definition } = options;
+  const legacyStart = options.legacy ? {
+    name: definition.name,
+    argsSchema: definition.argsSchema,
+    isPublic: definition.isPublic,
+    handler: async (ctx, args) => await startWorkflowRun(ctx, args, definition)
+  } : void 0;
+  const middlewares = options.middlewares ?? [];
+  const explicitHandler = composeWorkflowStartMiddleware({
+    middlewares,
+    inputSchema: hasStandardSchema4(definition.argsSchema) ? definition.argsSchema : void 0,
+    inputValidationIndex: options.inputValidationIndex ?? 0,
+    handler: async (ctx, args) => await startWorkflowRun(ctx, args, definition)
   });
-  query("workflows.list", {
-    args: {
-      limit: v.optional(v.number()),
-      status: v.optional(v.string())
-    },
-    handler: async (ctx, args) => {
-      const userId = ctx.auth.requireAuth().id;
-      const limit = normalizeListLimit(args.limit);
-      const requestedStatus = normalizeDerivedStatus(args.status);
-      const status = toWorkflowStatusFilter(requestedStatus);
-      const result = status == null ? await ctx.unsafeDb.execute(sql3`
-                    SELECT
-                        id,
-                        name,
-                        args,
-                        status,
-                        current_step,
-                        result,
-                        error,
-                        error_code,
-                        retry_count,
-                        max_retries,
-                        max_duration_ms,
-                        started_at,
-                        updated_at,
-                        completed_at,
-                        user_id
-                    FROM _gencow_workflows
-                    WHERE user_id = ${userId}
-                    ORDER BY started_at DESC
-                    LIMIT ${limit}
-                `) : await ctx.unsafeDb.execute(sql3`
-                    SELECT
-                        id,
-                        name,
-                        args,
-                        status,
-                        current_step,
-                        result,
-                        error,
-                        error_code,
-                        retry_count,
-                        max_retries,
-                        max_duration_ms,
-                        started_at,
-                        updated_at,
-                        completed_at,
-                        user_id
-                    FROM _gencow_workflows
-                    WHERE user_id = ${userId}
-                      AND status = ${status}
-                    ORDER BY started_at DESC
-                    LIMIT ${limit}
-                `);
-      return rowsFromResult(result).map(mapWorkflowSummary).filter((row) => requestedStatus == null || row.derivedStatus === requestedStatus);
+  const explicitStart = {
+    kind: "mutation",
+    name: definition.name,
+    allowAnonymous: definition.isPublic,
+    middlewares: [...middlewares],
+    inputSchema: hasStandardSchema4(definition.argsSchema) ? definition.argsSchema : void 0,
+    outputSchema: void 0,
+    inputValidationIndex: options.inputValidationIndex ?? 0,
+    outputValidationIndex: 0,
+    handler: legacyStart ? async (ctx, args) => await legacyStart.handler(ctx, args) : async (ctx, args) => await explicitHandler(ctx, args)
+  };
+  const internalResume = {
+    kind: "internal",
+    name: getWorkflowResumeActionName(definition.name),
+    allowAnonymous: false,
+    middlewares: [],
+    inputValidationIndex: 0,
+    outputValidationIndex: 0,
+    handler: async () => {
+      throw new Error("Workflow resume is scheduler-owned and cannot be invoked directly.");
     }
+  };
+  const metadata = {
+    definition,
+    legacyStart,
+    explicitStart,
+    internalResume
+  };
+  for (const carrier of [definition, legacyStart].filter(Boolean)) {
+    Object.defineProperty(carrier, WORKFLOW_DEFINITION_METADATA, {
+      value: metadata,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+  }
+  if (legacyStart) return { metadata };
+  const pure = {};
+  Object.defineProperty(pure, WORKFLOW_DEFINITION_METADATA, {
+    value: metadata,
+    enumerable: false,
+    configurable: false,
+    writable: false
   });
+  return { metadata, pure };
+}
+function workflow(name, options) {
+  const maxActiveDurationMs = normalizeMaxDurationMs(
+    options.maxActiveDuration ?? options.maxDuration,
+    options.maxActiveDuration == null ? "workflow() maxDuration" : "workflow() maxActiveDuration"
+  );
+  const definition = {
+    name,
+    argsSchema: options.args,
+    isPublic: options.public === true,
+    version: options.version,
+    maxDurationMs: maxActiveDurationMs,
+    maxActiveDurationMs,
+    lifecycleTimeoutMs: normalizeOptionalDurationMs(options.lifecycleTimeout, "workflow() lifecycleTimeout"),
+    concurrency: normalizeConcurrency(options.concurrency),
+    maxRetries: clampRetries(options.retries),
+    handler: options.handler
+  };
+  workflowRegistry.set(name, definition);
+  const { metadata } = createWorkflowMetadata({ definition, legacy: true });
+  return metadata.legacyStart;
+}
+var GencowWorkflowBuilderImpl = class _GencowWorkflowBuilderImpl {
+  constructor(workflowName, middlewares = [], inputSchema, inputValidationIndex = -1, anonymousAllowed = false, workflowVersion, maxDurationValue, lifecycleTimeoutValue, concurrencyValue, retriesValue) {
+    this.workflowName = workflowName;
+    this.middlewares = middlewares;
+    this.inputSchema = inputSchema;
+    this.inputValidationIndex = inputValidationIndex;
+    this.anonymousAllowed = anonymousAllowed;
+    this.workflowVersion = workflowVersion;
+    this.maxDurationValue = maxDurationValue;
+    this.lifecycleTimeoutValue = lifecycleTimeoutValue;
+    this.concurrencyValue = concurrencyValue;
+    this.retriesValue = retriesValue;
+  }
+  workflowName;
+  middlewares;
+  inputSchema;
+  inputValidationIndex;
+  anonymousAllowed;
+  workflowVersion;
+  maxDurationValue;
+  lifecycleTimeoutValue;
+  concurrencyValue;
+  retriesValue;
+  copy(changes = {}) {
+    return new _GencowWorkflowBuilderImpl(
+      changes.workflowName ?? this.workflowName,
+      changes.middlewares ?? this.middlewares,
+      changes.inputSchema ?? this.inputSchema,
+      changes.inputValidationIndex ?? this.inputValidationIndex,
+      changes.anonymousAllowed ?? this.anonymousAllowed,
+      changes.workflowVersion ?? this.workflowVersion,
+      changes.maxDurationValue ?? this.maxDurationValue,
+      changes.lifecycleTimeoutValue ?? this.lifecycleTimeoutValue,
+      changes.concurrencyValue ?? this.concurrencyValue,
+      changes.retriesValue ?? this.retriesValue
+    );
+  }
+  name(name) {
+    return this.copy({ workflowName: name });
+  }
+  use(middleware) {
+    return this.copy({ middlewares: [...this.middlewares, middleware] });
+  }
+  input(schema) {
+    return this.copy({
+      inputSchema: schema,
+      inputValidationIndex: this.middlewares.length
+    });
+  }
+  allowAnonymous() {
+    return this.copy({ anonymousAllowed: true });
+  }
+  version(version) {
+    return this.copy({ workflowVersion: version });
+  }
+  maxDuration(duration) {
+    return this.copy({ maxDurationValue: duration });
+  }
+  lifecycleTimeout(duration) {
+    return this.copy({ lifecycleTimeoutValue: duration });
+  }
+  concurrency(limit) {
+    return this.copy({ concurrencyValue: limit });
+  }
+  retries(count) {
+    return this.copy({ retriesValue: count });
+  }
+  handler(handler) {
+    if (!this.workflowName)
+      throw new Error("Workflow name is required. Call .name(...) before .handler(...)");
+    const maxActiveDurationMs = normalizeMaxDurationMs(this.maxDurationValue, "workflow.maxDuration()");
+    const definition = {
+      name: this.workflowName,
+      argsSchema: this.inputSchema,
+      isPublic: this.anonymousAllowed,
+      version: this.workflowVersion,
+      maxDurationMs: maxActiveDurationMs,
+      maxActiveDurationMs,
+      lifecycleTimeoutMs: normalizeOptionalDurationMs(
+        this.lifecycleTimeoutValue,
+        "workflow.lifecycleTimeout()"
+      ),
+      concurrency: normalizeConcurrency(this.concurrencyValue),
+      maxRetries: clampRetries(this.retriesValue),
+      handler
+    };
+    return createWorkflowMetadata({
+      definition,
+      middlewares: this.middlewares,
+      inputValidationIndex: this.inputValidationIndex < 0 ? 0 : this.inputValidationIndex
+    }).pure;
+  }
+};
+function createGencowWorkflowBuilders() {
+  return new GencowWorkflowBuilderImpl();
 }
 
-// ../core/src/workflow.ts
-var workflowRegistry = globalThis.__gencow_workflowRegistry ??= /* @__PURE__ */ new Map();
-var DEFAULT_WORKFLOW_MAX_DURATION_MS = 30 * 60 * 1e3;
-var DEFAULT_WORKFLOW_MAX_RETRIES = 3;
-var WORKFLOW_RESUME_ACTION_PREFIX = "__gencow.workflow.resume";
-var WORKFLOW_REALTIME_KEY_PREFIX = "__gencow.workflow.state";
-function isSerializedWorkflowValue(value) {
-  return !!value && typeof value === "object" && ("__gencowUndefined" in value || "value" in value);
+// ../core/src/workflow-types.ts
+function deriveWorkflowStatus(status, currentStep) {
+  if (status !== "pending") {
+    return status;
+  }
+  if (currentStep?.startsWith("sleep#")) {
+    return "sleeping";
+  }
+  if (currentStep?.startsWith("wait:")) {
+    return "waiting";
+  }
+  return "queued";
 }
-function serializeWorkflowValue(value) {
-  const payload = value === void 0 ? { __gencowUndefined: true } : { value };
+
+// ../core/src/workflows-api.ts
+import { sql as sql4 } from "drizzle-orm";
+var WORKFLOW_STATUSES = /* @__PURE__ */ new Set(["pending", "running", "completed", "failed"]);
+var WORKFLOW_DERIVED_PENDING_STATUSES = /* @__PURE__ */ new Set(["queued", "waiting", "sleeping"]);
+function rowsFromResult(result) {
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object" && Array.isArray(result.rows)) {
+    return result.rows;
+  }
+  return [];
+}
+function parseJsonField(value) {
+  if (typeof value !== "string") return value;
   try {
-    return JSON.parse(JSON.stringify(payload));
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `workflow() only persists JSON-serializable values. Failed to serialize workflow payload: ${reason}`
-    );
+    return JSON.parse(value);
+  } catch {
+    return value;
   }
 }
-function deserializeWorkflowValue(value) {
-  if (!isSerializedWorkflowValue(value)) return value;
-  if ("__gencowUndefined" in value) return void 0;
-  return value.value;
+function toIsoString(value) {
+  if (value instanceof Date) return value.toISOString();
+  const parsed = new Date(value);
+  return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : String(value);
+}
+function toOptionalIsoString(value) {
+  return value ? toIsoString(value) : null;
+}
+function mapWorkflowSummary(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    status: row.status,
+    derivedStatus: deriveWorkflowStatus(row.status, row.current_step),
+    currentStep: row.current_step,
+    error: row.error,
+    errorCode: row.error_code,
+    retryCount: row.retry_count,
+    maxRetries: row.max_retries,
+    maxDurationMs: Number(row.max_duration_ms),
+    startedAt: toIsoString(row.started_at),
+    updatedAt: toIsoString(row.updated_at),
+    completedAt: toOptionalIsoString(row.completed_at)
+  };
+}
+function mapWorkflowStep(row) {
+  return {
+    name: row.step_name,
+    status: row.status,
+    output: deserializeWorkflowValue(parseJsonField(row.output)),
+    error: row.error,
+    startedAt: toOptionalIsoString(row.started_at),
+    updatedAt: toIsoString(row.updated_at),
+    completedAt: toOptionalIsoString(row.completed_at)
+  };
 }
-function clampRetries(retries) {
-  if (retries == null) return DEFAULT_WORKFLOW_MAX_RETRIES;
-  if (!Number.isFinite(retries) || retries < 0) {
-    throw new Error(`workflow() retries must be a non-negative finite number, got "${retries}"`);
+function normalizeListLimit(limit) {
+  if (limit == null) return 20;
+  if (!Number.isFinite(limit)) {
+    throw new GencowValidationError(`Argument "limit": expected a finite number, got ${limit}`);
   }
-  return Math.floor(retries);
+  return Math.max(1, Math.min(100, Math.floor(limit)));
 }
-function parseDurationString(raw, label) {
-  const normalized = raw.trim().toLowerCase();
-  const match = normalized.match(/^(\d+)(ms|s|m|h|d)$/);
-  if (!match) {
-    throw new Error(`${label} must be a number of ms or a string like "30m", "90s", "1h" \u2014 got "${raw}"`);
+function normalizeStatus(status) {
+  if (status == null) return void 0;
+  if (!WORKFLOW_STATUSES.has(status)) {
+    throw new GencowValidationError(`Argument "status": expected one of pending, running, completed, failed`);
   }
-  const value = Number(match[1]);
-  const unit = match[2];
-  const unitMs = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
-  return value * unitMs;
+  return status;
 }
-function parseWorkflowDurationMs(raw, label = "workflow duration") {
-  if (typeof raw === "number") {
-    if (!Number.isFinite(raw) || raw <= 0) {
-      throw new Error(`${label} must be a positive finite number, got "${raw}"`);
-    }
-    return Math.floor(raw);
+function normalizeDerivedStatus(status) {
+  if (status == null) return void 0;
+  if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
+    return status;
   }
-  if (typeof raw !== "string") {
-    throw new Error(
-      `${label} must be a positive finite number or a string like "30m", "90s", "1h" \u2014 got "${String(raw)}"`
-    );
+  return normalizeStatus(status);
+}
+function toWorkflowStatusFilter(status) {
+  if (status == null) return void 0;
+  if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
+    return "pending";
   }
-  return parseDurationString(raw, label);
+  return status;
 }
-function normalizeMaxDurationMs(maxDuration, label = "workflow() maxDuration") {
-  if (maxDuration == null) return DEFAULT_WORKFLOW_MAX_DURATION_MS;
-  return parseWorkflowDurationMs(maxDuration, label);
+async function ensureWorkflowRealtimeToken(db, workflowId, currentToken) {
+  if (currentToken && currentToken.trim() !== "") return currentToken;
+  const nextToken = createWorkflowRealtimeToken();
+  const updateResult = await db.execute(sql4`
+        UPDATE _gencow_workflows
+        SET realtime_token = ${nextToken}
+        WHERE id = ${workflowId}
+          AND (realtime_token IS NULL OR realtime_token = '')
+        RETURNING realtime_token
+    `);
+  const updatedToken = rowsFromResult(updateResult)[0]?.realtime_token ?? null;
+  if (updatedToken && updatedToken.trim() !== "") return updatedToken;
+  const rereadResult = await db.execute(sql4`
+        SELECT realtime_token
+        FROM _gencow_workflows
+        WHERE id = ${workflowId}
+        LIMIT 1
+    `);
+  const rereadToken = rowsFromResult(rereadResult)[0]?.realtime_token ?? null;
+  return rereadToken && rereadToken.trim() !== "" ? rereadToken : null;
 }
-function normalizeOptionalDurationMs(duration, label) {
-  return duration == null ? null : parseWorkflowDurationMs(duration, label);
+async function loadWorkflowSignalTarget(db, workflowId) {
+  const result = await db.execute(sql4`
+        SELECT
+            id,
+            name,
+            status,
+            current_step,
+            user_id
+        FROM _gencow_workflows
+        WHERE id = ${workflowId}
+        LIMIT 1
+  `);
+  return rowsFromResult(result)[0] ?? null;
 }
-function normalizeConcurrency(concurrency) {
-  if (concurrency == null) return null;
-  if (!Number.isFinite(concurrency) || concurrency <= 0) {
-    throw new Error(`workflow() concurrency must be a positive finite number, got "${concurrency}"`);
-  }
-  return Math.floor(concurrency);
+function isMissingWorkflowV2SignalSchemaError(error) {
+  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+  const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
+  const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || (code === "23503" || causeCode === "23503") && message.includes("_gencow_workflow_signals_v2") || message.includes('relation "_gencow_workflow_signals_v2" does not exist') || message.includes("relation _gencow_workflow_signals_v2 does not exist") || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_outbox_v2" does not exist') || message.includes("relation _gencow_workflow_outbox_v2 does not exist") || message.includes('relation "_gencow_workflow_steps_v2" does not exist') || message.includes("relation _gencow_workflow_steps_v2 does not exist");
 }
-function isMissingWorkflowV2SchemaError2(error) {
+function isMissingWorkflowV2PayloadSchemaError(error) {
   const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
   const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
   const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
   const message = error instanceof Error ? error.message : String(error);
-  return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_outbox_v2" does not exist') || message.includes("relation _gencow_workflow_outbox_v2 does not exist") || message.includes('column "max_active_duration_ms"') || message.includes('column "retry_count"') || message.includes('column "user_id"');
+  return code === "42P01" || causeCode === "42P01" || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_steps_v2" does not exist') || message.includes("relation _gencow_workflow_steps_v2 does not exist");
 }
-function rows2(result) {
-  if (Array.isArray(result)) return result;
-  if (result && typeof result === "object" && Array.isArray(result.rows)) {
-    return result.rows;
+async function loadWorkflowV2PayloadSnapshot(db, workflowId) {
+  try {
+    const runResult = await db.execute(sql4`
+      SELECT args_json, result_json
+      FROM _gencow_workflow_runs_v2
+      WHERE id = ${workflowId}
+      LIMIT 1
+    `);
+    const run = rowsFromResult(runResult)[0];
+    if (!run) return null;
+    const stepResult = await db.execute(sql4`
+      SELECT step_key, output_json
+      FROM _gencow_workflow_steps_v2
+      WHERE run_id = ${workflowId}
+    `);
+    return {
+      run,
+      steps: new Map(
+        rowsFromResult(stepResult).map((step) => [
+          step.step_key,
+          parseJsonField(step.output_json)
+        ])
+      )
+    };
+  } catch (error) {
+    if (isMissingWorkflowV2PayloadSchemaError(error)) return null;
+    throw error;
   }
-  return [];
-}
-function numberFrom2(value) {
-  const parsed = Number(value ?? 0);
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-async function hasWorkflowV2StartSchema(db) {
-  const runColumns = [
-    "id",
-    "workflow_name",
-    "workflow_version",
-    "args_json",
-    "user_id",
-    "max_active_duration_ms",
-    "lifecycle_deadline_at",
-    "retry_count",
-    "max_retries",
-    "max_attempts"
-  ];
-  const outboxColumns = ["id", "run_id", "kind", "available_at", "status"];
-  const runColumnList = sql4.join(
-    runColumns.map((column) => sql4`${column}`),
-    sql4`, `
-  );
-  const outboxColumnList = sql4.join(
-    outboxColumns.map((column) => sql4`${column}`),
-    sql4`, `
-  );
-  const result = await db.execute(sql4`
-    SELECT
-      (
-        SELECT COUNT(*)::int
-        FROM information_schema.columns
-        WHERE table_schema = 'public'
-          AND table_name = '_gencow_workflow_runs_v2'
-          AND column_name IN (${runColumnList})
-      ) AS run_column_count,
-      (
-        SELECT COUNT(*)::int
-        FROM information_schema.columns
-        WHERE table_schema = 'public'
-          AND table_name = '_gencow_workflow_outbox_v2'
-          AND column_name IN (${outboxColumnList})
-      ) AS outbox_column_count
-  `);
-  const row = rows2(result)[0];
-  return numberFrom2(row?.run_column_count) === runColumns.length && numberFrom2(row?.outbox_column_count) === outboxColumns.length;
 }
-async function tryInsertWorkflowV2Run(options) {
+async function tryRecordWorkflowV2Signal(options) {
   try {
-    if (!await hasWorkflowV2StartSchema(options.db)) return false;
     await options.db.execute(sql4`
-      WITH inserted_run AS (
-        INSERT INTO _gencow_workflow_runs_v2 (
+      WITH inserted AS (
+        INSERT INTO _gencow_workflow_signals_v2 (
           id,
-          workflow_name,
-          workflow_version,
-          args_json,
-          user_id,
-          max_active_duration_ms,
-          lifecycle_deadline_at,
-          retry_count,
-          max_retries,
-          max_attempts
+          run_id,
+          event_name,
+          payload_json,
+          idempotency_key
         )
         VALUES (
+          ${crypto.randomUUID()},
           ${options.workflowId},
-          ${options.workflowName},
-          ${options.workflowVersion ?? null},
-          ${workflowJsonb(options.args)},
-          ${options.userId},
-          ${options.maxActiveDurationMs},
-          CASE
-            WHEN ${options.lifecycleTimeoutMs}::bigint IS NULL THEN NULL
-            ELSE NOW() + (${options.lifecycleTimeoutMs}::bigint * INTERVAL '1 millisecond')
-          END,
-          0,
-          ${options.maxRetries},
-          ${options.maxRetries + 1}
+          ${options.event},
+          ${workflowJsonb(options.payload)},
+          ${crypto.randomUUID()}
+        )
+        RETURNING id, run_id
+      ),
+      inserted_legacy AS (
+        INSERT INTO _gencow_workflow_events (
+          id,
+          workflow_id,
+          event_name,
+          payload
+        )
+        VALUES (
+          ${options.eventId},
+          ${options.workflowId},
+          ${options.event},
+          NULL
         )
         RETURNING id
       ),
-      inserted_outbox AS (
+      queued_run AS (
+        UPDATE _gencow_workflow_runs_v2 run
+        SET
+          status = 'queued',
+          runnable_at = NOW(),
+          lease_owner = NULL,
+          lease_expires_at = NULL,
+          heartbeat_at = NULL,
+          updated_at = NOW()
+        FROM inserted
+        WHERE run.id = inserted.run_id
+          AND run.status = 'waiting'
+          AND run.completed_at IS NULL
+          AND run.cancel_requested_at IS NULL
+        RETURNING run.id
+      ),
+      wake_outbox AS (
         INSERT INTO _gencow_workflow_outbox_v2 (
           id,
           run_id,
@@ -2809,156 +3144,257 @@ async function tryInsertWorkflowV2Run(options) {
           status
         )
         SELECT
-          'start:' || inserted_run.id,
-          inserted_run.id,
-          'wake_run',
+          'signal:' || inserted.id,
+          inserted.run_id,
+          'wake_signal',
           NOW(),
           'pending'
-        FROM inserted_run
+        FROM inserted
+        JOIN queued_run ON queued_run.id = inserted.run_id
         ON CONFLICT (id) DO NOTHING
         RETURNING id
       ),
       wake_notified AS (
         SELECT pg_notify(${WORKFLOW_WAKE_SIGNAL_CHANNEL}, ${WORKFLOW_WAKE_SIGNAL_PAYLOAD})
-        FROM inserted_outbox
+        FROM wake_outbox
       )
-      SELECT inserted_run.id
-      FROM inserted_run
+      SELECT 1
+      FROM inserted
+      LEFT JOIN inserted_legacy ON TRUE
       LEFT JOIN wake_notified ON TRUE
     `);
     return true;
   } catch (error) {
-    if (isMissingWorkflowV2SchemaError2(error)) return false;
+    if (isMissingWorkflowV2SignalSchemaError(error)) return false;
     throw error;
   }
 }
-async function tryDeleteWorkflowV2Run(db, workflowId) {
-  try {
-    await db.execute(sql4`
-      DELETE FROM _gencow_workflow_runs_v2
-      WHERE id = ${workflowId}
+async function loadWorkflowSnapshot(db, workflowId, options) {
+  const workflowResult = await db.execute(sql4`
+        SELECT
+            id,
+            name,
+            args,
+            status,
+            current_step,
+            result,
+            error,
+            error_code,
+            retry_count,
+            max_retries,
+            max_duration_ms,
+            started_at,
+            updated_at,
+            completed_at,
+            realtime_token,
+            user_id
+        FROM _gencow_workflows
+        WHERE id = ${workflowId}
+        LIMIT 1
     `);
-  } catch (error) {
-    if (!isMissingWorkflowV2SchemaError2(error)) throw error;
+  const row = rowsFromResult(workflowResult)[0] ?? null;
+  if (!row) return null;
+  const viewerUserId = options?.viewerUserId ?? null;
+  if (options?.requireViewerMatch && row.user_id && row.user_id !== viewerUserId) {
+    return null;
   }
+  const realtimeToken = await ensureWorkflowRealtimeToken(db, workflowId, row.realtime_token);
+  if (!realtimeToken) return null;
+  const v2Payload = await loadWorkflowV2PayloadSnapshot(db, workflowId);
+  const stepsResult = await db.execute(sql4`
+        SELECT
+            step_name,
+            status,
+            output,
+            error,
+            started_at,
+            updated_at,
+            completed_at
+        FROM _gencow_workflow_steps
+        WHERE workflow_id = ${workflowId}
+        ORDER BY COALESCE(started_at, updated_at) ASC, step_name ASC
+    `);
+  const steps = rowsFromResult(stepsResult).map((stepRow) => {
+    const mapped = mapWorkflowStep(stepRow);
+    return v2Payload?.steps.has(stepRow.step_name) ? { ...mapped, output: v2Payload.steps.get(stepRow.step_name) } : mapped;
+  });
+  return {
+    ...mapWorkflowSummary(row),
+    args: v2Payload ? deserializeWorkflowValue(parseJsonField(v2Payload.run.args_json)) : deserializeWorkflowValue(parseJsonField(row.args)),
+    result: v2Payload ? parseJsonField(v2Payload.run.result_json) : deserializeWorkflowValue(parseJsonField(row.result)),
+    steps,
+    realtimeKey: getWorkflowRealtimeKey(row.id, realtimeToken)
+  };
 }
-function getWorkflowResumeActionName(name) {
-  return `${WORKFLOW_RESUME_ACTION_PREFIX}.${name}`;
-}
-function createWorkflowRealtimeToken() {
-  return crypto.randomUUID().replace(/-/g, "");
-}
-function getWorkflowRealtimeKey(workflowId, realtimeToken) {
-  return `${WORKFLOW_REALTIME_KEY_PREFIX}.${workflowId}.${realtimeToken}`;
-}
-function getWorkflowDef(name) {
-  return workflowRegistry.get(name);
-}
-function getRegisteredWorkflows() {
-  return Array.from(workflowRegistry.values());
-}
-function workflow(name, options) {
-  registerWorkflowsApi();
-  const maxActiveDurationMs = normalizeMaxDurationMs(
-    options.maxActiveDuration ?? options.maxDuration,
-    options.maxActiveDuration == null ? "workflow() maxDuration" : "workflow() maxActiveDuration"
-  );
-  const lifecycleTimeoutMs = normalizeOptionalDurationMs(
-    options.lifecycleTimeout,
-    "workflow() lifecycleTimeout"
-  );
-  const maxRetries = clampRetries(options.retries);
-  const def = {
-    name,
-    argsSchema: options.args,
-    isPublic: options.public === true,
-    version: options.version,
-    maxDurationMs: maxActiveDurationMs,
-    maxActiveDurationMs,
-    lifecycleTimeoutMs,
-    concurrency: normalizeConcurrency(options.concurrency),
-    maxRetries,
-    handler: options.handler
+function buildWorkflowBuiltinDefinitions() {
+  const get = {
+    key: "workflows.get",
+    argsSchema: { id: v.string() },
+    isPublic: true,
+    handler: async (ctx, args) => {
+      return loadWorkflowSnapshot(ctx.unsafeDb, args.id, {
+        viewerUserId: ctx.auth.getUserIdentity()?.id ?? null,
+        requireViewerMatch: true
+      });
+    }
   };
-  workflowRegistry.set(name, def);
-  return mutation(name, {
-    args: options.args,
-    public: options.public,
+  const signal = {
+    name: "workflows.signal",
+    argsSchema: {
+      id: v.string(),
+      event: v.string(),
+      payload: v.optional(v.any())
+    },
+    isPublic: true,
     handler: async (ctx, args) => {
-      const workflowId = crypto.randomUUID();
-      const resumeAction = getWorkflowResumeActionName(name);
-      const ownerId = ctx.auth.getUserIdentity()?.id ?? null;
-      const persistedArgs = serializeWorkflowValue(args ?? {});
+      const normalizedEvent = args.event.trim();
+      if (!normalizedEvent) {
+        throw new GencowValidationError(`Argument "event": expected a non-empty string`);
+      }
+      const workflow2 = await loadWorkflowSignalTarget(ctx.unsafeDb, args.id);
+      const viewerUserId = ctx.auth.getUserIdentity()?.id ?? null;
+      if (!workflow2 || workflow2.user_id && workflow2.user_id !== viewerUserId) {
+        return {
+          ok: false,
+          workflowId: args.id,
+          event: normalizedEvent,
+          scheduledJobId: null
+        };
+      }
+      if (workflow2.status === "completed" || workflow2.status === "failed") {
+        return {
+          ok: false,
+          workflowId: workflow2.id,
+          event: normalizedEvent,
+          scheduledJobId: null
+        };
+      }
+      const persistedPayload = serializeWorkflowValue(args.payload);
       assertWorkflowPayloadWithinLimit({
-        workflowName: name,
-        kind: "args",
-        serializedValue: persistedArgs
+        workflowName: workflow2.name,
+        kind: "signal",
+        serializedValue: persistedPayload
       });
-      const realtimeToken = createWorkflowRealtimeToken();
-      let insertedWorkflowV2 = false;
-      try {
-        await runWorkflowAdmissionCriticalSection(ctx.unsafeDb, async (db) => {
-          await applyWorkflowStartAdmission({
-            db,
-            workflowName: name,
-            args: persistedArgs
-          });
-          insertedWorkflowV2 = await tryInsertWorkflowV2Run({
-            db,
-            workflowId,
-            workflowName: name,
-            workflowVersion: options.version ?? null,
-            args: persistedArgs,
-            userId: ownerId,
-            maxActiveDurationMs,
-            lifecycleTimeoutMs,
-            maxRetries
+      const eventId = crypto.randomUUID();
+      const recordedV2 = await tryRecordWorkflowV2Signal({
+        db: ctx.unsafeDb,
+        workflowId: workflow2.id,
+        event: normalizedEvent,
+        eventId,
+        payload: persistedPayload
+      });
+      if (!recordedV2) {
+        await ctx.unsafeDb.execute(sql4`
+                INSERT INTO _gencow_workflow_events (
+                    id,
+                    workflow_id,
+                    event_name,
+                    payload
+                )
+                VALUES (
+                    ${eventId},
+                    ${workflow2.id},
+                    ${normalizedEvent},
+                  ${workflowJsonb(persistedPayload)}
+                )
+            `);
+      }
+      let scheduledJobId = null;
+      if (workflow2.status === "pending" && workflow2.current_step?.startsWith("wait:")) {
+        try {
+          scheduledJobId = ctx.scheduler.runAfter(0, getWorkflowResumeActionName(workflow2.name), {
+            workflowId: workflow2.id
           });
-          const legacyArgs = insertedWorkflowV2 ? serializeWorkflowValue(void 0) : persistedArgs;
-          await db.execute(sql4`
-                    INSERT INTO _gencow_workflows (
+        } catch {
+          scheduledJobId = null;
+        }
+      }
+      return {
+        ok: true,
+        workflowId: workflow2.id,
+        event: normalizedEvent,
+        scheduledJobId
+      };
+    }
+  };
+  const list = {
+    key: "workflows.list",
+    argsSchema: {
+      limit: v.optional(v.number()),
+      status: v.optional(v.string())
+    },
+    isPublic: false,
+    handler: async (ctx, args) => {
+      const userId = ctx.auth.requireAuth().id;
+      const limit = normalizeListLimit(args.limit);
+      const requestedStatus = normalizeDerivedStatus(args.status);
+      const status = toWorkflowStatusFilter(requestedStatus);
+      const result = status == null ? await ctx.unsafeDb.execute(sql4`
+                    SELECT
                         id,
                         name,
                         args,
-                        realtime_token,
                         status,
+                        current_step,
+                        result,
+                        error,
+                        error_code,
                         retry_count,
                         max_retries,
                         max_duration_ms,
+                        started_at,
+                        updated_at,
+                        completed_at,
                         user_id
-                    )
-                    VALUES (
-                        ${workflowId},
-                        ${name},
-                        ${workflowJsonb(legacyArgs)},
-                      ${realtimeToken},
-                      'pending',
-                      0,
-                      ${maxRetries},
-                      ${maxActiveDurationMs},
-                      ${ownerId}
-                    )
-                `);
-        });
-        const scheduledJobId = insertedWorkflowV2 ? `start:${workflowId}` : ctx.scheduler.runAfter(0, resumeAction, { workflowId });
-        return {
-          id: workflowId,
-          name,
-          status: "pending",
-          scheduledJobId
-        };
-      } catch (error) {
-        await ctx.unsafeDb.execute(sql4`
-                    DELETE FROM _gencow_workflows
-                    WHERE id = ${workflowId}
+                    FROM _gencow_workflows
+                    WHERE user_id = ${userId}
+                    ORDER BY started_at DESC
+                    LIMIT ${limit}
+                `) : await ctx.unsafeDb.execute(sql4`
+                    SELECT
+                        id,
+                        name,
+                        args,
+                        status,
+                        current_step,
+                        result,
+                        error,
+                        error_code,
+                        retry_count,
+                        max_retries,
+                        max_duration_ms,
+                        started_at,
+                        updated_at,
+                        completed_at,
+                        user_id
+                    FROM _gencow_workflows
+                    WHERE user_id = ${userId}
+                      AND status = ${status}
+                    ORDER BY started_at DESC
+                    LIMIT ${limit}
                 `);
-        if (insertedWorkflowV2) {
-          await tryDeleteWorkflowV2Run(ctx.unsafeDb, workflowId);
-        }
-        throw error;
-      }
+      return rowsFromResult(result).map(mapWorkflowSummary).filter((row) => requestedStatus == null || row.derivedStatus === requestedStatus);
     }
+  };
+  const definitions = Object.freeze({
+    get: Object.freeze(get),
+    list: Object.freeze(list),
+    signal: Object.freeze(signal)
   });
+  return definitions;
+}
+function createWorkflowBuiltinDefinitions() {
+  return buildWorkflowBuiltinDefinitions();
+}
+function registerWorkflowsApi() {
+  const registeredDefinitions = globalThis.__gencow_workflowsApiRegistered;
+  if (registeredDefinitions) return registeredDefinitions;
+  const definitions = buildWorkflowBuiltinDefinitions();
+  queryRegistry.set(definitions.get.key, definitions.get);
+  queryRegistry.set(definitions.list.key, definitions.list);
+  mutationRegistry.push(definitions.signal);
+  globalThis.__gencow_workflowsApiRegistered = definitions;
+  return definitions;
 }
 
 // ../core/src/retry.ts
@@ -3530,6 +3966,35 @@ var pgBaseTable = pgTable;
 // ../core/src/rls-db.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import { sql as sql7 } from "drizzle-orm";
+var TRANSACTION_ISOLATION_LEVELS = /* @__PURE__ */ new Set([
+  "read uncommitted",
+  "read committed",
+  "repeatable read",
+  "serializable"
+]);
+var TRANSACTION_ACCESS_MODES = /* @__PURE__ */ new Set(["read only", "read write"]);
+function transactionConfigSql(config) {
+  if (!config || typeof config !== "object") return null;
+  const value = config;
+  const chunks = [];
+  if (value.isolationLevel !== void 0) {
+    if (!TRANSACTION_ISOLATION_LEVELS.has(value.isolationLevel)) return null;
+    chunks.push(`isolation level ${value.isolationLevel}`);
+  }
+  if (value.accessMode !== void 0) {
+    if (!TRANSACTION_ACCESS_MODES.has(value.accessMode)) return null;
+    chunks.push(value.accessMode);
+  }
+  if (value.deferrable !== void 0) {
+    if (typeof value.deferrable !== "boolean") return null;
+    chunks.push(value.deferrable ? "deferrable" : "not deferrable");
+  }
+  return chunks.length > 0 ? sql7.raw(`SET TRANSACTION ${chunks.join(", ")}`) : null;
+}
+async function applyTransactionConfig(tx, config) {
+  const statement = transactionConfigSql(config);
+  if (statement) await tx.execute(statement);
+}
 function rlsSetConfigPairs(rls) {
   const pairs = [];
   for (const [sessionKey, value] of Object.entries(rls)) {
@@ -3569,8 +4034,16 @@ async function execSetConfig(client, name, value) {
 async function applyRlsSessionVars(client, rls) {
   await forEachSetConfig(rls, (name, value) => execSetConfig(client, name, value));
 }
-async function injectRlsVarsOnTx(tx, rls) {
-  await forEachSetConfig(rls, (name, value) => tx.execute(sql7`SELECT set_config(${name}, ${value}, true)`));
+async function injectRlsVarsOnTx(tx, rls, onTransactionContextFailure) {
+  try {
+    await forEachSetConfig(rls, (name, value) => tx.execute(sql7`SELECT set_config(${name}, ${value}, true)`));
+  } catch (error) {
+    try {
+      onTransactionContextFailure?.(error);
+    } catch {
+    }
+    throw error;
+  }
 }
 async function withRlsLeasedConnection(leased, rls, fn) {
   try {
@@ -3667,7 +4140,11 @@ function createBunSqlPreparedQueryClientExecutors(baseSession, prepareQuery, pre
 }
 function createPreparedQueryClientExecutors(params) {
   if (isBunSqlSession(params.baseSession)) {
-    return createBunSqlPreparedQueryClientExecutors(params.baseSession, params.prepareQuery, params.prepareArgs);
+    return createBunSqlPreparedQueryClientExecutors(
+      params.baseSession,
+      params.prepareQuery,
+      params.prepareArgs
+    );
   }
   return createGenericPreparedQueryClientExecutors(params.pq);
 }
@@ -3676,7 +4153,12 @@ async function runPreparedQueryWithRls(session, rls, reuseOuterConnection, runOn
   if (active) {
     return runOnClient(active, placeholderValues);
   }
-  return withRlsConnection(session, rls, reuseOuterConnection, (client) => runOnClient(client, placeholderValues));
+  return withRlsConnection(
+    session,
+    rls,
+    reuseOuterConnection,
+    (client) => runOnClient(client, placeholderValues)
+  );
 }
 function wrapPreparedQuery(pq, session, baseSession, prepareQuery, prepareArgs, rls, reuseOuterConnection) {
   const clientExecutors = createPreparedQueryClientExecutors({
@@ -3709,7 +4191,7 @@ function wrapSession(session, rls, reuseOuterConnection) {
     }
   });
 }
-function createRlsDb(db, rls) {
+function createRlsDb(db, rls, options = {}) {
   const reuseOuterConnection = isDrizzleTransactionDb(db);
   const baseSession = db.session;
   const wrappedSession = wrapSession(baseSession, rls, reuseOuterConnection);
@@ -3729,13 +4211,41 @@ function createRlsDb(db, rls) {
       }
       if (prop === "transaction") {
         return async (callback, ...rest) => {
-          return await target.transaction(
-            async (tx) => {
-              await injectRlsVarsOnTx(tx, rls);
-              return await callback(tx);
-            },
-            ...rest
-          );
+          let callbackStarted = false;
+          const configStatement = transactionConfigSql(rest[0]);
+          const transactionArgs = configStatement ? [] : rest;
+          try {
+            return await target.transaction(
+              async (tx) => {
+                if (configStatement) await tx.execute(configStatement);
+                await injectRlsVarsOnTx(tx, rls, options.onTransactionContextFailure);
+                callbackStarted = true;
+                return await callback(tx);
+              },
+              ...transactionArgs
+            );
+          } catch (error) {
+            const markedRlsContextFailure = error && typeof error === "object" && error.gencowRlsTransactionContextFailure === true;
+            if (!callbackStarted && !markedRlsContextFailure && error && typeof error === "object") {
+              try {
+                Object.defineProperty(error, "gencowTransactionSetupFailure", { value: true });
+              } catch {
+              }
+            }
+            throw error;
+          }
+        };
+      }
+      if (prop === "transactionWithCharacteristics") {
+        return async (characteristics, callback) => {
+          return await target.transaction(async (tx) => {
+            await applyTransactionConfig(tx, {
+              ...characteristics?.isolationLevel ? { isolationLevel: characteristics.isolationLevel } : {},
+              ...characteristics?.readOnly ? { accessMode: "read only" } : {}
+            });
+            await injectRlsVarsOnTx(tx, rls, options.onTransactionContextFailure);
+            return callback(tx);
+          });
         };
       }
       const value = Reflect.get(target, prop, receiver);
@@ -5137,6 +5647,7 @@ export {
   PLATFORM_CAPACITY_PRESETS,
   PLATFORM_CAPACITY_PROFILE_ENV,
   RLS_SESSION_KEY_RE,
+  RealtimeChannelEventValidationError,
   STORAGE_LIST_DEFAULT_LIMIT,
   STORAGE_LIST_MAX_LIMIT,
   StorageListUnsupportedError,
@@ -5157,16 +5668,20 @@ export {
   buildSearchIndexNames,
   buildWakeAppBootFailedResult,
   buildWakeAppSuccessResult,
+  captureLegacyRealtimeChannels,
   compareUnreadCursors,
   computeCronActionToken,
   countUnreadAfterCursor,
   createCrudFactory,
   createGencowHttpRouteBuilders,
   createGencowProcedureBuilders,
+  createGencowRealtimeChannelBuilder,
+  createGencowWorkflowBuilders,
   createRealtimeChannelToken,
   createRealtimeQuerySubscriptionToken,
   createRealtimeTicket,
   createRlsDb,
+  createWorkflowBuiltinDefinitions,
   createWorkflowRealtimeToken,
   cron,
   cronJobs,
@@ -5221,6 +5736,8 @@ export {
   ownerRls,
   parseArgs,
   parseFilterNode,
+  parseRealtimeChannelEvent,
+  parseStandardSchema,
   parseWorkflowDurationMs,
   pgBaseTable,
   query,
@@ -5228,8 +5745,10 @@ export {
   readNonNegativeIntegerEnv,
   readPositiveIntegerEnv,
   registerOwnerRls,
+  registerWorkflowsApi,
   resetRealtimeChannelRegistryForTests,
   resetRealtimeSubscriptionRegistryForTests,
+  resolveExplicitRealtimeChannelKey,
   resolvePlatformCapacityPreset,
   resolveRealtimeChannelKey,
   resolveRealtimeQueryScopeHash,
@@ -5237,6 +5756,7 @@ export {
   resolveWorkflowPayloadPolicyConfig,
   rlsContextKey,
   rlsContextKeys,
+  selectLegacyRealtimeChannelSnapshot,
   serializeWorkflowValue,
   sessionKeyToGucName,
   stringifySessionValue,