@fragno-dev/workflows 0.0.1 → 0.0.3

package/dist/node/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","names":[],"sources":["../../src/routes.ts"],"sourcesContent":[],"mappings":";;;;;;;;;cAoOa,2CAAsB,aAAA,wBAAA,oBAAA,iBAAA,CAAA,uDAAA;oEAAA,yBAAA,CAAA,SAAA;;;;;AAAnC,CAAA,CAAA,CAAA,kCAgtBC,CAAA;EAhtBkC,QAAA,EAAA,GAAA,UAAA,KAAA,CAAA;EAAA,sBAAA,EAAA,CAAA,YAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA,EAAA,UAAA,CAAA,OAAA,CAAA;EAAA,cAAA,EAAA,CAAA,YAAA,EAAA,MAAA,EAAA,QAAA,EAAA"}
+{"version":3,"file":"routes.d.ts","names":[],"sources":["../../src/routes.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;cA4Ja,0CAAsB,aAAA,wBAAA,oBAAA,gBAAA,CAAA,sDAAA;4HAAA,wBAAA,CAAA,QAAA;;;;;;gDAAA;;IAAtB,MAAA,CAAA,EAAA,OAAA;EAAsB,CAAA,EAAA,4BAAA,CAAA;IAAA,EAAA,EAAA,MAAA;IAAA,OAAA,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAkjBq8N;;;;;;;;;QAAA,wBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAljBr8N,eAAA,CAAA,EAAA,oBAAA,GAAA,qBAAA,GAAA,yBAAA,EAAA,MAAA,yCAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkjBq8N,CAAA,eAAA,CAAA,CAAA;EAAA,MAAA,YAAA,YAAA,CAAA"}

package/dist/node/routes.js

@@ -1,43 +1,25 @@
+import { workflowsSchema } from "./schema.js";
 import { workflowsFragmentDefinition } from "./definition.js";
 import { defineRoutes } from "@fragno-dev/core";
 import { decodeCursor } from "@fragno-dev/db";
 import { z } from "zod";
 
 //#region src/routes.ts
-const workflowNameSchema = z.string().min(1).max(64);
-const identifierSchema = z.string().min(1).max(100).regex(/^[a-zA-Z0-9_][a-zA-Z0-9-_]*$/);
+const identifierSchema = z.string().min(1).max(128).regex(/^[a-zA-Z0-9_][a-zA-Z0-9-_]*$/);
 const instanceStatusSchema = z.enum([
-	"queued",
-	"running",
+	"active",
 	"paused",
 	"errored",
 	"terminated",
 	"complete",
-	"waiting",
-	"waitingForPause",
-	"unknown"
+	"waiting"
 ]);
 const listInstancesQuerySchema = z.object({
 	status: instanceStatusSchema.optional(),
 	pageSize: z.coerce.number().min(1).max(100).catch(25),
 	cursor: z.string().optional()
 });
-const historyQuerySchema = z.object({
-	runNumber: z.coerce.number().int().min(0).optional(),
-	pageSize: z.coerce.number().min(1).max(100).catch(25),
-	stepsCursor: z.string().optional(),
-	eventsCursor: z.string().optional(),
-	logsCursor: z.string().optional(),
-	includeLogs: z.enum(["true", "false"]).transform((value) => value === "true").optional(),
-	logLevel: z.enum([
-		"debug",
-		"info",
-		"warn",
-		"error"
-	]).optional(),
-	logCategory: z.string().optional(),
-	order: z.enum(["asc", "desc"]).optional()
-});
+const runNumberSchema = z.coerce.number().int().min(0);
 const createInstanceSchema = z.object({
 	id: identifierSchema.optional(),
 	params: z.unknown().optional()
@@ -50,10 +32,6 @@ const sendEventSchema = z.object({
 	type: identifierSchema,
 	payload: z.unknown().optional()
 });
-const runnerTickSchema = z.object({
-	maxInstances: z.coerce.number().int().positive().optional(),
-	maxSteps: z.coerce.number().int().positive().optional()
-}).default({});
 const instanceStatusOutputSchema = z.object({
 	status: instanceStatusSchema,
 	error: z.object({
@@ -82,7 +60,6 @@ const instanceMetaOutputSchema = z.object({
 	workflowName: z.string(),
 	runNumber: z.number(),
 	params: z.unknown(),
-	pauseRequested: z.boolean(),
 	createdAt: z.date(),
 	updatedAt: z.date(),
 	startedAt: z.date().nullable(),
@@ -119,22 +96,6 @@ const historyEventSchema = z.object({
 	deliveredAt: z.date().nullable(),
 	consumedByStepKey: z.string().nullable()
 });
-const historyLogSchema = z.object({
-	id: z.string(),
-	runNumber: z.number(),
-	stepKey: z.string().nullable(),
-	attempt: z.number().nullable(),
-	level: z.enum([
-		"debug",
-		"info",
-		"warn",
-		"error"
-	]),
-	category: z.string(),
-	message: z.string(),
-	data: z.unknown().nullable(),
-	createdAt: z.date()
-});
 const getWorkflowNames = (registry) => Object.values(registry ?? {}).map((entry) => entry.name);
 const parseCursor = (cursorParam) => {
 	if (!cursorParam) return;
@@ -144,27 +105,12 @@ const parseCursor = (cursorParam) => {
 		return;
 	}
 };
-const buildAuthContext = (context, input) => ({
-	method: context.method,
-	path: context.path,
-	pathParams: context.pathParams,
-	query: context.query,
-	headers: context.headers,
-	input
-});
-const authorize = async (hook, context) => {
-	if (!hook) return;
-	const result = await hook(context);
-	if (result instanceof Response) return result;
+const resolveInstanceStatus = (status) => {
+	const parsed = instanceStatusSchema.safeParse(status);
+	if (!parsed.success) throw new Error(`INSTANCE_STATUS_INVALID:${status}`);
+	return parsed.data;
 };
 const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(({ services, config, defineRoute }) => {
-	const knownWorkflowNames = new Set(getWorkflowNames(config.workflows));
-	const assertWorkflowName = (workflowName, error) => {
-		if (!workflowNameSchema.safeParse(workflowName).success || !knownWorkflowNames.has(workflowName)) return error({
-			message: "Workflow not found",
-			code: "WORKFLOW_NOT_FOUND"
-		}, 404);
-	};
 	const assertIdentifier = (value, code, error) => {
 		if (!identifierSchema.safeParse(value).success) return error({
 			message: "Invalid identifier",
@@ -173,6 +119,10 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 	};
 	const handleServiceError = (err, error) => {
 		if (!(err instanceof Error)) throw err;
+		if (err.message === "WORKFLOW_NOT_FOUND") return error({
+			message: "Workflow not found",
+			code: "WORKFLOW_NOT_FOUND"
+		}, 404);
 		if (err.message === "INSTANCE_NOT_FOUND") return error({
 			message: "Instance not found",
 			code: "INSTANCE_NOT_FOUND"
@@ -196,9 +146,7 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 			method: "GET",
 			path: "/",
 			outputSchema: z.object({ workflows: z.array(z.object({ name: z.string() })) }),
-			handler: async (context, { json }) => {
-				const authResponse = await authorize(config.authorizeRequest, buildAuthContext(context));
-				if (authResponse) return authResponse;
+			handler: async (_context, { json }) => {
 				return json({ workflows: getWorkflowNames(config.workflows).map((name) => ({ name })) });
 			}
 		}),
@@ -210,6 +158,7 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				"pageSize",
 				"cursor"
 			],
+			errorCodes: ["WORKFLOW_NOT_FOUND"],
 			outputSchema: z.object({
 				instances: z.array(z.object({
 					id: z.string(),
@@ -223,27 +172,27 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const { pathParams, query } = context;
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
-				const authResponse = await authorize(config.authorizeRequest, buildAuthContext(context));
-				if (authResponse) return authResponse;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				const params = listInstancesQuerySchema.parse({
 					status: query.get("status") || void 0,
 					pageSize: query.get("pageSize"),
 					cursor: query.get("cursor") || void 0
 				});
 				const cursor = parseCursor(params.cursor);
-				const result = await this.handlerTx().withServiceCalls(() => [services.listInstances({
-					workflowName,
-					status: params.status,
-					pageSize: params.pageSize,
-					cursor
-				})]).transform(({ serviceResult: [result$1] }) => result$1).execute();
-				return json({
-					instances: result.instances,
-					cursor: result.cursor?.encode(),
-					hasNextPage: result.hasNextPage
-				});
+				try {
+					const result = await this.handlerTx().withServiceCalls(() => [services.listInstances({
+						workflowName,
+						status: params.status,
+						pageSize: params.pageSize,
+						cursor
+					})]).transform(({ serviceResult: [result$1] }) => result$1).execute();
+					return json({
+						instances: result.instances,
+						cursor: result.cursor?.encode(),
+						hasNextPage: result.hasNextPage
+					});
+				} catch (err) {
+					return handleServiceError(err, errorResponder);
+				}
 			}
 		}),
 		defineRoute({
@@ -265,20 +214,6 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
 				const payload = await input.valid();
-				const authContext = buildAuthContext(context, payload);
-				const requestAuth = await authorize(config.authorizeRequest, authContext);
-				if (requestAuth) return requestAuth;
-				const creationAuth = await authorize(config.authorizeInstanceCreation, {
-					...authContext,
-					workflowName,
-					instances: [{
-						id: payload.id,
-						params: payload.params
-					}]
-				});
-				if (creationAuth) return creationAuth;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				if (payload.id) {
 					const idError = assertIdentifier(payload.id, "INVALID_INSTANCE_ID", errorResponder);
 					if (idError) return idError;
@@ -312,20 +247,6 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
 				const payload = await input.valid();
-				const authContext = buildAuthContext(context, payload);
-				const requestAuth = await authorize(config.authorizeRequest, authContext);
-				if (requestAuth) return requestAuth;
-				const creationAuth = await authorize(config.authorizeInstanceCreation, {
-					...authContext,
-					workflowName,
-					instances: payload.instances.map((instance) => ({
-						id: instance.id,
-						params: instance.params
-					}))
-				});
-				if (creationAuth) return creationAuth;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				for (const instance of payload.instances) {
 					const idError = assertIdentifier(instance.id, "INVALID_INSTANCE_ID", errorResponder);
 					if (idError) return idError;
@@ -336,8 +257,7 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 						id: instance.id,
 						params: await services.validateWorkflowParams(workflowName, instance.params)
 					})));
-					const serviceCall = services.createBatch(workflowName, validatedInstances);
-					return json({ instances: await this.handlerTx().withServiceCalls(() => [serviceCall]).transform(({ serviceResult: [result] }) => result).execute() });
+					return json({ instances: await this.handlerTx().withServiceCalls(() => [services.createBatch(workflowName, validatedInstances)]).transform(({ serviceResult: [result] }) => result).execute() });
 				} catch (err) {
 					return handleServiceError(err, errorResponder);
 				}
@@ -360,23 +280,55 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const { pathParams } = context;
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
-				const authResponse = await authorize(config.authorizeRequest, buildAuthContext(context));
-				if (authResponse) return authResponse;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
+				if (!getWorkflowNames(config.workflows).includes(workflowName)) return errorResponder({
+					message: "Workflow not found",
+					code: "WORKFLOW_NOT_FOUND"
+				}, 404);
 				const instanceId = pathParams.instanceId;
 				const idError = assertIdentifier(instanceId, "INVALID_INSTANCE_ID", errorResponder);
 				if (idError) return idError;
 				try {
-					const { details, meta } = await this.handlerTx().withServiceCalls(() => [services.getInstanceStatus(workflowName, instanceId), services.getInstanceMetadata(workflowName, instanceId)]).transform(({ serviceResult: [detailsResult, metaResult] }) => ({
-						details: detailsResult,
-						meta: metaResult
-					})).execute();
-					const currentStep = await this.handlerTx().withServiceCalls(() => [services.getInstanceCurrentStep({
-						workflowName,
-						instanceId,
-						runNumber: meta.runNumber
-					})]).transform(({ serviceResult: [result] }) => result).execute();
+					const { details, meta, currentStep } = await this.handlerTx().retrieve(({ forSchema }) => forSchema(workflowsSchema).findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_id", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("id", "=", instanceId)))).findWithCursor("workflow_step", (b) => b.whereIndex("idx_workflow_step_instanceRef_runNumber_createdAt", (eb) => eb("instanceRef", "=", instanceId)).orderByIndex("idx_workflow_step_instanceRef_runNumber_createdAt", "desc").pageSize(1))).transformRetrieve(([instance, steps]) => {
+						if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+						const details$1 = {
+							status: resolveInstanceStatus(instance.status),
+							error: instance.errorName || instance.errorMessage ? {
+								name: instance.errorName ?? "Error",
+								message: instance.errorMessage ?? ""
+							} : void 0,
+							output: instance.output ?? void 0
+						};
+						const meta$1 = {
+							workflowName: instance.workflowName,
+							runNumber: instance.runNumber,
+							params: instance.params ?? {},
+							createdAt: instance.createdAt,
+							updatedAt: instance.updatedAt,
+							startedAt: instance.startedAt,
+							completedAt: instance.completedAt
+						};
+						const latestStep = steps.items[0];
+						return {
+							details: details$1,
+							meta: meta$1,
+							currentStep: latestStep && latestStep.runNumber === instance.runNumber ? {
+								stepKey: latestStep.stepKey,
+								name: latestStep.name,
+								type: latestStep.type,
+								status: latestStep.status,
+								attempts: latestStep.attempts,
+								maxAttempts: latestStep.maxAttempts,
+								timeoutMs: latestStep.timeoutMs,
+								nextRetryAt: latestStep.nextRetryAt,
+								wakeAt: latestStep.wakeAt,
+								waitEventType: latestStep.waitEventType,
+								error: latestStep.errorName || latestStep.errorMessage ? {
+									name: latestStep.errorName ?? "Error",
+									message: latestStep.errorMessage ?? ""
+								} : void 0
+							} : void 0
+						};
+					}).execute();
 					return json({
 						id: instanceId,
 						details,
@@ -393,28 +345,10 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 		defineRoute({
 			method: "GET",
 			path: "/:workflowName/instances/:instanceId/history",
-			queryParameters: [
-				"runNumber",
-				"pageSize",
-				"stepsCursor",
-				"eventsCursor",
-				"logsCursor",
-				"includeLogs",
-				"logLevel",
-				"logCategory",
-				"order"
-			],
 			outputSchema: z.object({
 				runNumber: z.number(),
 				steps: z.array(historyStepSchema),
-				events: z.array(historyEventSchema),
-				stepsCursor: z.string().optional(),
-				stepsHasNextPage: z.boolean(),
-				eventsCursor: z.string().optional(),
-				eventsHasNextPage: z.boolean(),
-				logs: z.array(historyLogSchema).optional(),
-				logsCursor: z.string().optional(),
-				logsHasNextPage: z.boolean().optional()
+				events: z.array(historyEventSchema)
 			}),
 			errorCodes: [
 				"WORKFLOW_NOT_FOUND",
@@ -422,61 +356,64 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				"INSTANCE_NOT_FOUND"
 			],
 			handler: async function(context, { json, error }) {
-				const { pathParams, query } = context;
+				const { pathParams } = context;
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
-				const authResponse = await authorize(config.authorizeRequest, buildAuthContext(context));
-				if (authResponse) return authResponse;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				const instanceId = pathParams.instanceId;
 				const idError = assertIdentifier(instanceId, "INVALID_INSTANCE_ID", errorResponder);
 				if (idError) return idError;
-				const params = historyQuerySchema.parse({
-					runNumber: query.get("runNumber") || void 0,
-					pageSize: query.get("pageSize"),
-					stepsCursor: query.get("stepsCursor") || void 0,
-					eventsCursor: query.get("eventsCursor") || void 0,
-					logsCursor: query.get("logsCursor") || void 0,
-					includeLogs: query.get("includeLogs") || void 0,
-					logLevel: query.get("logLevel") || void 0,
-					logCategory: query.get("logCategory") || void 0,
-					order: query.get("order") || void 0
-				});
-				const stepsCursor = parseCursor(params.stepsCursor);
-				const eventsCursor = parseCursor(params.eventsCursor);
-				const logsCursor = parseCursor(params.logsCursor);
-				let resolvedRunNumber = params.runNumber;
-				if (resolvedRunNumber === void 0) try {
-					resolvedRunNumber = await this.handlerTx().withServiceCalls(() => [services.getInstanceRunNumber(workflowName, instanceId)]).transform(({ serviceResult: [result] }) => result).execute();
+				try {
+					const result = await this.handlerTx().withServiceCalls(() => [services.listHistory({
+						workflowName,
+						instanceId
+					})]).transform(({ serviceResult: [result$1] }) => result$1).execute();
+					return json({
+						runNumber: result.runNumber,
+						steps: result.steps,
+						events: result.events
+					});
 				} catch (err) {
 					return handleServiceError(err, errorResponder);
 				}
+			}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/:workflowName/instances/:instanceId/history/:run",
+			outputSchema: z.object({
+				runNumber: z.number(),
+				steps: z.array(historyStepSchema),
+				events: z.array(historyEventSchema)
+			}),
+			errorCodes: [
+				"WORKFLOW_NOT_FOUND",
+				"INVALID_INSTANCE_ID",
+				"INVALID_RUN_NUMBER",
+				"INSTANCE_NOT_FOUND"
+			],
+			handler: async function(context, { json, error }) {
+				const { pathParams } = context;
+				const errorResponder = error;
+				const workflowName = pathParams.workflowName;
+				const instanceId = pathParams.instanceId;
+				const idError = assertIdentifier(instanceId, "INVALID_INSTANCE_ID", errorResponder);
+				if (idError) return idError;
+				const parsedRun = runNumberSchema.safeParse(pathParams.run);
+				if (!parsedRun.success) return errorResponder({
+					message: "Invalid run number",
+					code: "INVALID_RUN_NUMBER"
+				}, 400);
+				const resolvedRunNumber = parsedRun.data;
 				try {
 					const result = await this.handlerTx().withServiceCalls(() => [services.listHistory({
 						workflowName,
 						instanceId,
-						runNumber: resolvedRunNumber,
-						pageSize: params.pageSize,
-						stepsCursor,
-						eventsCursor,
-						includeLogs: params.includeLogs,
-						logsCursor,
-						logLevel: params.logLevel,
-						logCategory: params.logCategory,
-						order: params.order
+						runNumber: resolvedRunNumber
 					})]).transform(({ serviceResult: [result$1] }) => result$1).execute();
 					return json({
 						runNumber: result.runNumber,
 						steps: result.steps,
-						events: result.events,
-						stepsCursor: result.stepsCursor?.encode(),
-						stepsHasNextPage: result.stepsHasNextPage,
-						eventsCursor: result.eventsCursor?.encode(),
-						eventsHasNextPage: result.eventsHasNextPage,
-						logs: result.logs,
-						logsCursor: result.logsCursor?.encode(),
-						logsHasNextPage: result.logsHasNextPage
+						events: result.events
 					});
 				} catch (err) {
 					return handleServiceError(err, errorResponder);
@@ -496,19 +433,7 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const { pathParams } = context;
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
-				const authContext = buildAuthContext(context);
-				const requestAuth = await authorize(config.authorizeRequest, authContext);
-				if (requestAuth) return requestAuth;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				const instanceId = pathParams.instanceId;
-				const managementAuth = await authorize(config.authorizeManagement, {
-					...authContext,
-					workflowName,
-					instanceId,
-					action: "pause"
-				});
-				if (managementAuth) return managementAuth;
 				const idError = assertIdentifier(instanceId, "INVALID_INSTANCE_ID", errorResponder);
 				if (idError) return idError;
 				try {
@@ -532,19 +457,7 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const { pathParams } = context;
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
-				const authContext = buildAuthContext(context);
-				const requestAuth = await authorize(config.authorizeRequest, authContext);
-				if (requestAuth) return requestAuth;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				const instanceId = pathParams.instanceId;
-				const managementAuth = await authorize(config.authorizeManagement, {
-					...authContext,
-					workflowName,
-					instanceId,
-					action: "resume"
-				});
-				if (managementAuth) return managementAuth;
 				const idError = assertIdentifier(instanceId, "INVALID_INSTANCE_ID", errorResponder);
 				if (idError) return idError;
 				try {
@@ -568,19 +481,7 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const { pathParams } = context;
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
-				const authContext = buildAuthContext(context);
-				const requestAuth = await authorize(config.authorizeRequest, authContext);
-				if (requestAuth) return requestAuth;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				const instanceId = pathParams.instanceId;
-				const managementAuth = await authorize(config.authorizeManagement, {
-					...authContext,
-					workflowName,
-					instanceId,
-					action: "terminate"
-				});
-				if (managementAuth) return managementAuth;
 				const idError = assertIdentifier(instanceId, "INVALID_INSTANCE_ID", errorResponder);
 				if (idError) return idError;
 				try {
@@ -604,19 +505,7 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const { pathParams } = context;
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
-				const authContext = buildAuthContext(context);
-				const requestAuth = await authorize(config.authorizeRequest, authContext);
-				if (requestAuth) return requestAuth;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				const instanceId = pathParams.instanceId;
-				const managementAuth = await authorize(config.authorizeManagement, {
-					...authContext,
-					workflowName,
-					instanceId,
-					action: "restart"
-				});
-				if (managementAuth) return managementAuth;
 				const idError = assertIdentifier(instanceId, "INVALID_INSTANCE_ID", errorResponder);
 				if (idError) return idError;
 				try {
@@ -644,20 +533,7 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 				const errorResponder = error;
 				const workflowName = pathParams.workflowName;
 				const payload = await input.valid();
-				const authContext = buildAuthContext(context, payload);
-				const requestAuth = await authorize(config.authorizeRequest, authContext);
-				if (requestAuth) return requestAuth;
-				const workflowError = assertWorkflowName(workflowName, errorResponder);
-				if (workflowError) return workflowError;
 				const instanceId = pathParams.instanceId;
-				const sendEventAuth = await authorize(config.authorizeSendEvent, {
-					...authContext,
-					workflowName,
-					instanceId,
-					eventType: payload.type,
-					payload: payload.payload
-				});
-				if (sendEventAuth) return sendEventAuth;
 				const idError = assertIdentifier(instanceId, "INVALID_INSTANCE_ID", errorResponder);
 				if (idError) return idError;
 				const typeError = assertIdentifier(payload.type, "INVALID_EVENT_TYPE", errorResponder);
@@ -671,39 +547,6 @@ const workflowsRoutesFactory = defineRoutes(workflowsFragmentDefinition).create(
 					return handleServiceError(err, errorResponder);
 				}
 			}
-		}),
-		defineRoute({
-			method: "POST",
-			path: "/_runner/tick",
-			inputSchema: runnerTickSchema,
-			outputSchema: z.object({ processed: z.number() }),
-			handler: async function(context, { json, error }) {
-				const { input } = context;
-				const payload = await input.valid();
-				const authContext = buildAuthContext(context, payload);
-				const requestAuth = await authorize(config.authorizeRequest, authContext);
-				if (requestAuth) return requestAuth;
-				const tickAuth = await authorize(config.authorizeRunnerTick, {
-					...authContext,
-					options: {
-						maxInstances: payload.maxInstances,
-						maxSteps: payload.maxSteps
-					}
-				});
-				if (tickAuth) return tickAuth;
-				if (!config.enableRunnerTick) return error({
-					message: "Runner tick disabled",
-					code: "RUNNER_TICK_DISABLED"
-				}, 403);
-				if (!config.runner?.tick) return error({
-					message: "Runner not available",
-					code: "RUNNER_NOT_AVAILABLE"
-				}, 503);
-				return json({ processed: await config.runner.tick({
-					maxInstances: payload.maxInstances,
-					maxSteps: payload.maxSteps
-				}) ?? 0 });
-			}
 		})
 	];
 });