gencow 0.1.240 → 0.1.242

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) => {
@@ -1353,108 +1012,647 @@ var v = {
         for (const key in fields) {
           result[key] = fields[key].parse(val[key]);
         }
-        return result;
-      },
-      _type: {},
-      jsonSchema: buildObjectJsonSchema(fields)
-    });
-  },
-  array(inner) {
-    const items = readJsonSchemaFragment(inner);
-    return createValidator({
-      parse: (val) => {
-        if (!Array.isArray(val)) throw new Error("Expected array");
-        return val.map((item) => inner.parse(item));
-      },
-      _type: [],
-      jsonSchema: { type: "array", items }
-    });
-  },
-  /** Browser `File` / `Blob` for procedure multipart uploads. */
-  file() {
-    const base = createValidator({
-      parse: (val) => {
-        if (!(val instanceof Blob)) {
-          throw new Error(`Expected file, got ${typeof val}`);
+        return result;
+      },
+      _type: {},
+      jsonSchema: buildObjectJsonSchema(fields)
+    });
+  },
+  array(inner) {
+    const items = readJsonSchemaFragment(inner);
+    return createValidator({
+      parse: (val) => {
+        if (!Array.isArray(val)) throw new Error("Expected array");
+        return val.map((item) => inner.parse(item));
+      },
+      _type: [],
+      jsonSchema: { type: "array", items }
+    });
+  },
+  /** Browser `File` / `Blob` for procedure multipart uploads. */
+  file() {
+    const base = createValidator({
+      parse: (val) => {
+        if (!(val instanceof Blob)) {
+          throw new Error(`Expected file, got ${typeof val}`);
+        }
+        return val;
+      },
+      _type: null,
+      jsonSchema: { type: "string", format: "binary", "x-gencow-type": "file" }
+    });
+    return Object.assign(base, {
+      mime(mimeType) {
+        return createValidator({
+          parse: (val) => {
+            const blob = base.parse(val);
+            if (!matchesMimeType(blob.type, mimeType)) {
+              throw new Error(
+                `Expected a file of type ${mimeType} but got ${blob.type || "unknown"}`
+              );
+            }
+            return blob;
+          },
+          _type: null,
+          jsonSchema: {
+            type: "string",
+            format: "binary",
+            "x-gencow-type": "file",
+            "x-gencow-mime": mimeType
+          }
+        });
+      }
+    });
+  }
+};
+function parseArgs(schema, args) {
+  if (!schema) return args;
+  if (typeof schema.parse === "function") {
+    try {
+      return schema.parse(normalizeMissingOptionalObjectInput(schema, args));
+    } catch (e) {
+      throw new GencowValidationError(e.message);
+    }
+  }
+  if (typeof schema === "object" && schema !== null) {
+    const schemaKeys = Object.keys(schema);
+    if (schemaKeys.length === 0) return args;
+    if (typeof args !== "object" || args === null) {
+      throw new GencowValidationError("Expected an object for arguments");
+    }
+    const result = {};
+    for (const key of schemaKeys) {
+      const validator = schema[key];
+      if (validator && typeof validator.parse === "function") {
+        try {
+          result[key] = validator.parse(args[key]);
+        } catch (e) {
+          throw new GencowValidationError(`Argument "${key}": ${e.message}`);
+        }
+      } else {
+        result[key] = args[key];
+      }
+    }
+    return result;
+  }
+  return args;
+}
+
+// ../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" && typeof schema["~standard"]?.validate === "function";
+}
+async function parseStandardSchema(schema, value) {
+  if (!schema) return value;
+  if (!hasStandardSchema2(schema)) {
+    throw new Error("Realtime channels require a Standard Schema v1 validator");
+  }
+  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 RealtimeChannelEventValidationError = class extends GencowValidationError {
+  code = "REALTIME_CHANNEL_EVENT_INVALID";
+  constructor(message) {
+    super(message);
+    this.name = "RealtimeChannelEventValidationError";
+  }
+};
+async function parseRealtimeChannelEvent(schema, value) {
+  try {
+    return await parseStandardSchema(schema, value);
+  } catch (error) {
+    if (error instanceof GencowValidationError) {
+      throw new RealtimeChannelEventValidationError(error.message);
+    }
+    throw error;
+  }
+}
+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");
+  }
+  if (typeof value !== "object") {
+    throw new RealtimeChannelEventValidationError(
+      "Realtime channel events must be JSON-serializable wire values"
+    );
+  }
+  if (seen.has(value)) {
+    throw new RealtimeChannelEventValidationError("Realtime channel events must not contain circular values");
+  }
+  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);
+  }
+  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"
+      );
+    }
+    return JSON.parse(serialized);
+  } catch (error) {
+    if (error instanceof RealtimeChannelEventValidationError) throw error;
+    throw new RealtimeChannelEventValidationError(
+      "Realtime channel events must be JSON-serializable wire values"
+    );
+  }
+}
+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/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 } : {}
+      });
+    }
+  };
+}
+
+// ../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 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 isEmptyPlainObject3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).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 subscriptionKeyMatchesQueryKey(subscriptionKey, queryKey) {
+  return subscriptionKey === queryKey || subscriptionKey.startsWith(`${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}`);
+}
+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;
         }
-        return val;
-      },
-      _type: null,
-      jsonSchema: { type: "string", format: "binary", "x-gencow-type": "file" }
-    });
-    return Object.assign(base, {
-      mime(mimeType) {
-        return createValidator({
-          parse: (val) => {
-            const blob = base.parse(val);
-            if (!matchesMimeType(blob.type, mimeType)) {
-              throw new Error(
-                `Expected a file of type ${mimeType} but got ${blob.type || "unknown"}`
-              );
-            }
-            return blob;
-          },
-          _type: null,
-          jsonSchema: {
-            type: "string",
-            format: "binary",
-            "x-gencow-type": "file",
-            "x-gencow-mime": mimeType
-          }
-        });
-      }
-    });
-  }
-};
-function parseArgs(schema, args) {
-  if (!schema) return args;
-  if (typeof schema.parse === "function") {
-    try {
-      return schema.parse(normalizeMissingOptionalObjectInput(schema, args));
-    } catch (e) {
-      throw new GencowValidationError(e.message);
-    }
-  }
-  if (typeof schema === "object" && schema !== null) {
-    const schemaKeys = Object.keys(schema);
-    if (schemaKeys.length === 0) return args;
-    if (typeof args !== "object" || args === null) {
-      throw new GencowValidationError("Expected an object for arguments");
-    }
-    const result = {};
-    for (const key of schemaKeys) {
-      const validator = schema[key];
-      if (validator && typeof validator.parse === "function") {
         try {
-          result[key] = validator.parse(args[key]);
+          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) {
-          throw new GencowValidationError(`Argument "${key}": ${e.message}`);
+          console.warn(`[gencow] refresh("${key}") failed:`, e instanceof Error ? e.message : e);
         }
-      } else {
-        result[key] = args[key];
+      }
+      _pendingRefresh.length = 0;
+    },
+    async _flushRealtimeEvents() {
+      while (pendingEvents.length > 0) {
+        const event = pendingEvents.shift();
+        await options.fanout.notify(event);
       }
     }
-    return result;
+  };
+}
+
+// ../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}`;
   }
-  return args;
+  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 hasStandardSchema2(schema) {
+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 (hasStandardSchema2(schema)) {
+  if (hasStandardSchema3(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");
+      throw new GencowValidationError(result.issues[0]?.message ?? "Validation failed");
     }
     if ("value" in result) {
       return result.value;
     }
-    throw new Error("Validation failed");
+    throw new GencowValidationError("Validation failed");
   }
   throw new Error("procedure.query / procedure.mutation / procedure.internal only supports Standard Schema v1 validators");
 }
@@ -1632,6 +1830,71 @@ 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";
@@ -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,601 @@ 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
+async function tryDeleteWorkflowV2Run(db, workflowId) {
+  try {
+    await db.execute(sql3`
+      DELETE FROM _gencow_workflow_runs_v2
+      WHERE id = ${workflowId}
     `);
-  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;
+  } catch (error) {
+    if (!isMissingWorkflowV2SchemaError2(error)) throw error;
   }
-  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
+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-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/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);
-}
-function serializeWorkflowValue(value) {
-  const payload = value === void 0 ? { __gencowUndefined: true } : { value };
+// ../core/src/workflows-api.ts
+import { sql as sql4 } from "drizzle-orm";
+
+// ../core/src/workflow-public-read-model.ts
+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 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.floor(retries);
+function toOptionalIsoString(value) {
+  return value ? toIsoString(value) : null;
 }
-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 publicV2Status(status) {
+  if (status === "completed" || status === "failed") return status;
+  if (status === "cancelled") return "failed";
+  if (status === "running") return "running";
+  return "pending";
+}
+function publicV2DerivedStatus(status) {
+  if (status === "queued" || status === "waiting" || status === "sleeping") return status;
+  return publicV2Status(status);
+}
+function mapV2WorkflowSummary(row) {
+  const error = parseJsonField(row.error_json);
+  return {
+    id: row.id,
+    name: row.workflow_name,
+    status: publicV2Status(row.status),
+    derivedStatus: publicV2DerivedStatus(row.status),
+    currentStep: row.current_step_key,
+    error: typeof error === "string" ? error : error && typeof error === "object" && "message" in error ? String(error.message) : null,
+    errorCode: row.status === "cancelled" ? "cancelled" : row.error_code,
+    retryCount: row.retry_count,
+    maxRetries: row.max_retries,
+    maxDurationMs: Number(row.max_active_duration_ms),
+    startedAt: toIsoString(row.created_at),
+    updatedAt: toIsoString(row.updated_at),
+    completedAt: toOptionalIsoString(row.completed_at)
+  };
+}
+function mapV2WorkflowStep(row) {
+  const error = parseJsonField(row.error_json);
+  return {
+    name: row.step_key,
+    status: row.status === "running" || row.status === "failed" || row.status === "completed" ? row.status : row.status === "skipped" ? "completed" : "pending",
+    output: parseJsonField(row.output_json),
+    error: typeof error === "string" ? error : error && typeof error === "object" && "message" in error ? String(error.message) : null,
+    startedAt: toOptionalIsoString(row.started_at),
+    updatedAt: toIsoString(row.updated_at),
+    completedAt: toOptionalIsoString(row.completed_at)
+  };
+}
+
+// ../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;
   }
-  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 [];
 }
-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 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 mapJoinedWorkflowSummary(row) {
+  if (!row.v2_id) return mapWorkflowSummary(row);
+  return mapV2WorkflowSummary({
+    id: row.v2_id,
+    workflow_name: row.v2_name,
+    status: row.v2_status,
+    args_json: null,
+    result_json: null,
+    error_json: row.v2_error_json,
+    error_code: row.v2_error_code,
+    current_step_key: row.v2_current_step,
+    retry_count: row.v2_retry_count,
+    max_retries: row.v2_max_retries,
+    max_active_duration_ms: row.v2_max_duration_ms,
+    created_at: row.v2_created_at,
+    updated_at: row.v2_updated_at,
+    completed_at: row.v2_completed_at,
+    user_id: null
+  });
+}
+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 normalizeListLimit(limit) {
+  if (limit == null) return 20;
+  if (!Number.isFinite(limit)) {
+    throw new GencowValidationError(`Argument "limit": expected a finite number, got ${limit}`);
   }
-  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 Math.max(1, Math.min(100, Math.floor(limit)));
+}
+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`);
   }
-  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);
+function normalizeDerivedStatus(status) {
+  if (status == null) return void 0;
+  if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
+    return status;
+  }
+  return normalizeStatus(status);
 }
-function normalizeOptionalDurationMs(duration, label) {
-  return duration == null ? null : parseWorkflowDurationMs(duration, 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 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}"`);
+async function loadWorkflowSignalTarget(db, workflowId) {
+  try {
+    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;
+  } catch (error) {
+    if (isMissingWorkflowV1Table(error)) return null;
+    throw error;
   }
-  return Math.floor(concurrency);
 }
-function isMissingWorkflowV2SchemaError2(error) {
+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" || 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"');
-}
-function rows2(result) {
-  if (Array.isArray(result)) return result;
-  if (result && typeof result === "object" && Array.isArray(result.rows)) {
-    return result.rows;
-  }
-  return [];
+  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 numberFrom2(value) {
-  const parsed = Number(value ?? 0);
-  return Number.isFinite(parsed) ? parsed : 0;
+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" || 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");
 }
-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`, `
+function isMissingWorkflowV1Table(error) {
+  const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
+  const message = `${error instanceof Error ? error.message : String(error)} ${cause instanceof Error ? cause.message : String(cause ?? "")}`;
+  return /relation "?_gencow_workflows"? does not exist|relation "?_gencow_workflow_steps"? does not exist|relation "?_gencow_workflow_events"? does not exist/.test(
+    message
   );
-  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 loadWorkflowV2Run(db, workflowId) {
+  try {
+    const result = await db.execute(sql4`
+      SELECT id, workflow_name, status, args_json, result_json, error_json, error_code,
+             current_step_key, retry_count, max_retries, max_active_duration_ms,
+             created_at, updated_at, completed_at, user_id
+      FROM _gencow_workflow_runs_v2
+      WHERE id = ${workflowId}
+      LIMIT 1
+    `);
+    return rowsFromResult(result)[0] ?? null;
+  } catch (error) {
+    if (isMissingWorkflowV2PayloadSchemaError(error)) return null;
+    throw error;
+  }
+}
+async function loadWorkflowV2Steps(db, workflowId) {
+  try {
+    const stepResult = await db.execute(sql4`
+      SELECT step_key, status, output_json, error_json, started_at, updated_at, completed_at
+      FROM _gencow_workflow_steps_v2
+      WHERE run_id = ${workflowId}
+      ORDER BY step_index ASC, COALESCE(started_at, updated_at) ASC, step_key ASC
+    `);
+    return rowsFromResult(stepResult);
+  } catch (error) {
+    if (isMissingWorkflowV2PayloadSchemaError(error)) return [];
+    throw error;
+  }
+}
+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 (
+    const result = await options.db.execute(sql4`
+      WITH eligible_run AS (
+        SELECT id
+        FROM _gencow_workflow_runs_v2
+        WHERE id = ${options.workflowId}
+          AND status IN ('queued', 'running', 'sleeping', 'waiting')
+          AND completed_at IS NULL
+          AND cancel_requested_at IS NULL
+        FOR UPDATE
+      ), 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
-        )
-        VALUES (
-          ${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}
+          run_id,
+          event_name,
+          payload_json,
+          idempotency_key
         )
-        RETURNING id
+        SELECT
+          ${options.signalId},
+          eligible_run.id,
+          ${options.event},
+          ${workflowJsonb(options.payload)},
+          ${options.signalId}
+        FROM eligible_run
+        RETURNING id, run_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 +3207,313 @@ 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 wake_notified ON TRUE
     `);
-    return true;
+    return rowsFromResult(result).length > 0 ? "accepted" : "rejected";
   } catch (error) {
-    if (isMissingWorkflowV2SchemaError2(error)) return false;
+    if (isMissingWorkflowV2SignalSchemaError(error)) return "absent";
     throw error;
   }
 }
-async function tryDeleteWorkflowV2Run(db, workflowId) {
+async function mirrorWorkflowV2SignalToV1(options) {
   try {
-    await db.execute(sql4`
-      DELETE FROM _gencow_workflow_runs_v2
-      WHERE id = ${workflowId}
+    await options.db.execute(sql4`
+      INSERT INTO _gencow_workflow_events (id, workflow_id, event_name, payload)
+      SELECT ${options.signalId}, workflow.id, ${options.event}, NULL
+      FROM _gencow_workflows workflow
+      WHERE workflow.id = ${options.workflowId}
+      ON CONFLICT (id) DO NOTHING
     `);
   } catch (error) {
-    if (!isMissingWorkflowV2SchemaError2(error)) throw error;
+    if (!isMissingWorkflowV1Table(error)) {
+      console.warn("Workflow V1 signal mirror failed", { signalId: options.signalId });
+    }
   }
 }
-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());
+async function loadWorkflowSnapshot(db, workflowId, options) {
+  const v2Run = await loadWorkflowV2Run(db, workflowId);
+  let workflowResult;
+  try {
+    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 (!v2Run || !isMissingWorkflowV1Table(error)) throw error;
+    workflowResult = [];
+  }
+  const row = rowsFromResult(workflowResult)[0] ?? null;
+  if (!v2Run && !row) return null;
+  const viewerUserId = options?.viewerUserId ?? null;
+  const ownerId = v2Run ? v2Run.user_id : row?.user_id;
+  if (options?.requireViewerMatch && ownerId && ownerId !== viewerUserId) {
+    return null;
+  }
+  const realtimeToken = row ? await ensureWorkflowRealtimeToken(db, workflowId, row.realtime_token) : v2Run?.id ?? null;
+  if (!realtimeToken) return null;
+  const v2Steps = v2Run ? await loadWorkflowV2Steps(db, workflowId) : [];
+  let steps = v2Steps.map(mapV2WorkflowStep);
+  if (steps.length === 0) {
+    let stepsResult;
+    try {
+      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
+      `);
+    } catch (error) {
+      if (!v2Run || !isMissingWorkflowV1Table(error)) throw error;
+      stepsResult = [];
+    }
+    steps = rowsFromResult(stepsResult).map(mapWorkflowStep);
+  }
+  return {
+    ...v2Run ? mapV2WorkflowSummary(v2Run) : mapWorkflowSummary(row),
+    args: deserializeWorkflowValue(parseJsonField(v2Run ? v2Run.args_json : row.args)),
+    result: v2Run ? parseJsonField(v2Run.result_json) : deserializeWorkflowValue(parseJsonField(row.result)),
+    steps,
+    realtimeKey: getWorkflowRealtimeKey(workflowId, realtimeToken)
+  };
 }
-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 v2Run = await loadWorkflowV2Run(ctx.unsafeDb, args.id);
+      const workflow2 = await loadWorkflowSignalTarget(ctx.unsafeDb, args.id);
+      const viewerUserId = ctx.auth.getUserIdentity()?.id ?? null;
+      const ownerId = v2Run ? v2Run.user_id : workflow2?.user_id;
+      if (!v2Run && !workflow2 || ownerId && ownerId !== viewerUserId) {
+        return {
+          ok: false,
+          workflowId: args.id,
+          event: normalizedEvent,
+          scheduledJobId: null
+        };
+      }
+      const workflowId = v2Run?.id ?? workflow2.id;
+      const workflowName = v2Run?.workflow_name ?? workflow2.name;
+      if (v2Run ? v2Run.status === "completed" || v2Run.status === "failed" || v2Run.status === "cancelled" || v2Run.completed_at !== null : workflow2.status === "completed" || workflow2.status === "failed") {
+        return {
+          ok: false,
+          workflowId,
+          event: normalizedEvent,
+          scheduledJobId: null
+        };
+      }
+      const persistedPayload = serializeWorkflowValue(args.payload);
       assertWorkflowPayloadWithinLimit({
-        workflowName: name,
-        kind: "args",
-        serializedValue: persistedArgs
+        workflowName,
+        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,
+      const signalId = crypto.randomUUID();
+      if (v2Run) {
+        const recordedV2 = await tryRecordWorkflowV2Signal({
+          db: ctx.unsafeDb,
+          workflowId,
+          event: normalizedEvent,
+          signalId,
+          payload: persistedPayload
+        });
+        if (recordedV2 !== "accepted") {
+          return { ok: false, workflowId, event: normalizedEvent, scheduledJobId: null };
+        }
+        if (workflow2) {
+          await mirrorWorkflowV2SignalToV1({
+            db: ctx.unsafeDb,
             workflowId,
-            workflowName: name,
-            workflowVersion: options.version ?? null,
-            args: persistedArgs,
-            userId: ownerId,
-            maxActiveDurationMs,
-            lifecycleTimeoutMs,
-            maxRetries
+            event: normalizedEvent,
+            signalId
           });
-          const legacyArgs = insertedWorkflowV2 ? serializeWorkflowValue(void 0) : persistedArgs;
-          await db.execute(sql4`
-                    INSERT INTO _gencow_workflows (
-                        id,
-                        name,
-                        args,
-                        realtime_token,
-                        status,
-                        retry_count,
-                        max_retries,
-                        max_duration_ms,
-                        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) {
+        }
+      } else {
         await ctx.unsafeDb.execute(sql4`
-                    DELETE FROM _gencow_workflows
-                    WHERE id = ${workflowId}
-                `);
-        if (insertedWorkflowV2) {
-          await tryDeleteWorkflowV2Run(ctx.unsafeDb, workflowId);
+                INSERT INTO _gencow_workflow_events (
+                    id,
+                    workflow_id,
+                    event_name,
+                    payload
+                )
+                VALUES (
+                    ${signalId},
+                    ${workflowId},
+                    ${normalizedEvent},
+                  ${workflowJsonb(persistedPayload)}
+                )
+            `);
+      }
+      let scheduledJobId = null;
+      if (workflow2?.status === "pending" && workflow2.current_step?.startsWith("wait:")) {
+        try {
+          scheduledJobId = ctx.scheduler.runAfter(0, getWorkflowResumeActionName(workflowName), {
+            workflowId
+          });
+        } catch {
+          scheduledJobId = null;
+        }
+      }
+      return {
+        ok: true,
+        workflowId,
+        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 v1Derived = sql4`CASE WHEN w.status = 'pending' AND w.current_step LIKE 'sleep#%' THEN 'sleeping'
+        WHEN w.status = 'pending' AND w.current_step LIKE 'wait:%' THEN 'waiting'
+        WHEN w.status = 'pending' THEN 'queued' ELSE w.status END`;
+      const effectiveStatus = sql4`CASE WHEN v.id IS NOT NULL THEN
+        CASE WHEN v.status = 'cancelled' THEN 'failed'
+             WHEN v.status IN ('queued', 'waiting', 'sleeping') THEN 'pending'
+             ELSE v.status END
+        ELSE w.status END`;
+      const effectiveDerived = sql4`CASE WHEN v.id IS NOT NULL THEN
+        CASE WHEN v.status = 'cancelled' THEN 'failed'
+             WHEN v.status IN ('queued', 'waiting', 'sleeping') THEN v.status
+             ELSE v.status END
+        ELSE ${v1Derived} END`;
+      const statusForFilter = requestedStatus === "pending" ? effectiveStatus : effectiveDerived;
+      const v1StatusForFilter = requestedStatus === "pending" ? sql4`w.status` : v1Derived;
+      try {
+        const result = await ctx.unsafeDb.execute(sql4`
+          SELECT w.*, v.id AS v2_id, v.workflow_name AS v2_name,
+                 v.status AS v2_status, v.error_json AS v2_error_json,
+                 v.error_code AS v2_error_code, v.current_step_key AS v2_current_step,
+                 v.retry_count AS v2_retry_count, v.max_retries AS v2_max_retries,
+                 v.max_active_duration_ms AS v2_max_duration_ms,
+                 v.created_at AS v2_created_at, v.updated_at AS v2_updated_at,
+                 v.completed_at AS v2_completed_at
+          FROM _gencow_workflows w
+          FULL OUTER JOIN _gencow_workflow_runs_v2 v ON v.id = w.id
+          WHERE (CASE WHEN v.id IS NOT NULL THEN v.user_id ELSE w.user_id END) = ${userId}
+            AND (${requestedStatus ?? null}::text IS NULL OR ${statusForFilter} = ${requestedStatus ?? null})
+          ORDER BY COALESCE(v.created_at, w.started_at) DESC, COALESCE(v.id, w.id) DESC
+          LIMIT ${limit}
+        `);
+        return rowsFromResult(result).map(mapJoinedWorkflowSummary);
+      } catch (error) {
+        if (isMissingWorkflowV1Table(error)) {
+          const v2StatusForFilter = requestedStatus === "pending" ? sql4`CASE WHEN status IN ('queued', 'waiting', 'sleeping') THEN 'pending'
+                       WHEN status = 'cancelled' THEN 'failed' ELSE status END` : sql4`CASE WHEN status = 'cancelled' THEN 'failed' ELSE status END`;
+          const result2 = await ctx.unsafeDb.execute(sql4`
+            SELECT id, workflow_name, status, args_json, result_json, error_json, error_code,
+                   current_step_key, retry_count, max_retries, max_active_duration_ms,
+                   created_at, updated_at, completed_at, user_id
+            FROM _gencow_workflow_runs_v2
+            WHERE user_id = ${userId}
+              AND (${requestedStatus ?? null}::text IS NULL OR ${v2StatusForFilter} = ${requestedStatus ?? null})
+            ORDER BY created_at DESC, id DESC
+            LIMIT ${limit}
+          `);
+          return rowsFromResult(result2).map(mapV2WorkflowSummary);
         }
-        throw error;
+        if (!isMissingWorkflowV2PayloadSchemaError(error)) throw error;
+        const result = await ctx.unsafeDb.execute(sql4`
+          SELECT w.* FROM _gencow_workflows w
+          WHERE w.user_id = ${userId}
+            AND (${requestedStatus ?? null}::text IS NULL OR ${v1StatusForFilter} = ${requestedStatus ?? null})
+          ORDER BY w.started_at DESC, w.id DESC
+          LIMIT ${limit}
+        `);
+        return rowsFromResult(result).map(mapWorkflowSummary);
       }
     }
+  };
+  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 +4085,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 +4153,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 +4259,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 +4272,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 +4310,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 +4330,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 +5766,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 +5787,20 @@ export {
   buildSearchIndexNames,
   buildWakeAppBootFailedResult,
   buildWakeAppSuccessResult,
+  captureLegacyRealtimeChannels,
   compareUnreadCursors,
   computeCronActionToken,
   countUnreadAfterCursor,
   createCrudFactory,
   createGencowHttpRouteBuilders,
   createGencowProcedureBuilders,
+  createGencowRealtimeChannelBuilder,
+  createGencowWorkflowBuilders,
   createRealtimeChannelToken,
   createRealtimeQuerySubscriptionToken,
   createRealtimeTicket,
   createRlsDb,
+  createWorkflowBuiltinDefinitions,
   createWorkflowRealtimeToken,
   cron,
   cronJobs,
@@ -5221,6 +5855,8 @@ export {
   ownerRls,
   parseArgs,
   parseFilterNode,
+  parseRealtimeChannelEvent,
+  parseStandardSchema,
   parseWorkflowDurationMs,
   pgBaseTable,
   query,
@@ -5228,8 +5864,10 @@ export {
   readNonNegativeIntegerEnv,
   readPositiveIntegerEnv,
   registerOwnerRls,
+  registerWorkflowsApi,
   resetRealtimeChannelRegistryForTests,
   resetRealtimeSubscriptionRegistryForTests,
+  resolveExplicitRealtimeChannelKey,
   resolvePlatformCapacityPreset,
   resolveRealtimeChannelKey,
   resolveRealtimeQueryScopeHash,
@@ -5237,6 +5875,7 @@ export {
   resolveWorkflowPayloadPolicyConfig,
   rlsContextKey,
   rlsContextKeys,
+  selectLegacyRealtimeChannelSnapshot,
   serializeWorkflowValue,
   sessionKeyToGucName,
   stringifySessionValue,