@apifuse/provider-sdk 2.0.0-beta.1 → 2.1.0-beta.0

package/src/define.ts

@@ -1,40 +1,525 @@
-import type { ZodType } from "zod";
 import { ProviderError, ValidationError } from "./errors";
+import { safeParseSchemaSync } from "./schema";
 import type {
 	AuthConfig,
 	BrowserEngine,
+	ContextDeclaration,
+	CredentialDeclaration,
+	HealthCheckCase,
+	HealthCheckSuite,
+	HealthCheckUnsupported,
+	InferSchemaOutput,
 	OperationDefinition,
+	ProbeInterval,
 	ProviderDefinition,
+	ProviderHealthMonitorConfig,
+	ProviderReviewed,
+	ProviderSecretDeclaration,
+	SchemaLike,
 	StealthPlatform,
 } from "./types";
+import {
+	OPERATION_TIMEOUT_MS_MAX,
+	OPERATION_TIMEOUT_MS_MIN,
+	PROBE_INTERVALS,
+} from "./types";
 
 const CONNECTOR_ID_REGEX = /^[a-z][a-z0-9]*(-[a-z][a-z0-9]*)*$/;
+const OPERATION_ID_REGEX = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/;
+const VALID_RUNTIMES = ["standard", "shared", "browser"] as const;
+const VALID_AUTH_MODES = [
+	"none",
+	"platform-managed",
+	"credentials",
+	"oauth2",
+] as const;
+const RESERVED_OPERATION_IDS = new Set(["auth", "health"]);
 
-type ProviderOperation = OperationDefinition<ZodType, ZodType>;
+type ProviderOperation = OperationDefinition<SchemaLike, SchemaLike>;
+type OperationConfig<
+	TInput extends SchemaLike,
+	TOutput extends SchemaLike,
+> = Omit<OperationDefinition<TInput, TOutput>, "handler"> & {
+	handler(
+		ctx: Parameters<OperationDefinition<TInput, TOutput>["handler"]>[0],
+		input: InferSchemaOutput<TInput>,
+	): Promise<InferSchemaOutput<TOutput>>;
+};
+type OperationMapConfig<TOperations extends Record<string, ProviderOperation>> =
+	{
+		[K in keyof TOperations]: TOperations[K] extends OperationDefinition<
+			infer TInput,
+			infer TOutput
+		>
+			? OperationConfig<TInput, TOutput>
+			: never;
+	};
 
 export interface ProviderConfig<
 	TOperations extends Record<string, ProviderOperation>,
 > {
 	id: string;
 	version: string;
-	runtime: "standard" | "browser";
-	stealth?: {
-		profile: string;
-		platform: StealthPlatform;
-	};
+	runtime: "standard" | "shared" | "browser";
+	allowedHosts?: string[];
+	stealth?: { profile: string; platform: StealthPlatform };
 	proxy?: boolean;
-	browser?: {
-		engine: BrowserEngine;
-	};
+	browser?: { engine: BrowserEngine };
 	auth?: AuthConfig;
+	reviewed?: ProviderReviewed;
+	secrets?: ProviderSecretDeclaration[];
+	credential?: CredentialDeclaration;
+	context?: ContextDeclaration;
 	meta: {
 		displayName: string;
 		description?: string;
 		category: string;
 		tags?: string[];
 		icon?: string;
+		docTitle?: string;
+		docDescription?: string;
+		docSummary?: string;
+		normalizationNotes?: string[];
+		environment?: "staging";
+		purpose?: string;
 	};
-	operations: TOperations;
+	operations: OperationMapConfig<TOperations>;
+	healthMonitor?: ProviderHealthMonitorConfig;
+}
+
+/** Define one provider operation with schema-driven handler inference. */
+export function defineOperation<
+	TInput extends SchemaLike,
+	TOutput extends SchemaLike,
+>(
+	operation: OperationConfig<TInput, TOutput>,
+): OperationDefinition<TInput, TOutput> {
+	return operation;
+}
+
+function assertObjectConfig(
+	value: unknown,
+): asserts value is Record<string, unknown> {
+	if (!value || typeof value !== "object") {
+		throw new ProviderError(
+			"defineProvider config must be an object. Offending field: config",
+			{
+				fix: "Pass defineProvider({ id, version, runtime, meta, operations })",
+			},
+		);
+	}
+}
+function assertRequiredField(
+	config: Record<string, unknown>,
+	field: string,
+	providerId?: string,
+): void {
+	if (!Object.hasOwn(config, field) || config[field] === undefined) {
+		const prefix = providerId ? `Provider "${providerId}"` : "Provider config";
+		throw new ProviderError(`${prefix} is missing required field "${field}"`, {
+			fix: `Add ${field} to defineProvider({ ... })`,
+		});
+	}
+}
+function assertLiteralField<TValue extends string>(
+	value: string,
+	field: string,
+	validValues: readonly TValue[],
+	providerId: string,
+): asserts value is TValue {
+	if (!validValues.some((validValue) => validValue === value)) {
+		throw new ProviderError(
+			`Provider "${providerId}" has invalid ${field}: "${value}". Expected one of: ${validValues.join(", ")}`,
+			{
+				fix: `Set ${field} to one of ${validValues.map((item) => `"${item}"`).join(", ")}`,
+			},
+		);
+	}
+}
+function validateProviderShape(config: unknown): void {
+	assertObjectConfig(config);
+	assertRequiredField(config, "id");
+	assertRequiredField(config, "version", String(config.id));
+	assertRequiredField(config, "runtime", String(config.id));
+	assertRequiredField(config, "meta", String(config.id));
+	assertRequiredField(config, "operations", String(config.id));
+	if (typeof config.runtime === "string")
+		assertLiteralField(
+			config.runtime,
+			"runtime",
+			VALID_RUNTIMES,
+			String(config.id),
+		);
+	const auth = config.auth;
+	if (
+		auth &&
+		typeof auth === "object" &&
+		"mode" in auth &&
+		typeof auth.mode === "string"
+	)
+		assertLiteralField(
+			auth.mode,
+			"auth.mode",
+			VALID_AUTH_MODES,
+			String(config.id),
+		);
+}
+function validateOperationIds(
+	providerId: string,
+	operations: Record<string, ProviderOperation>,
+): void {
+	for (const operationName of Object.keys(operations)) {
+		if (!OPERATION_ID_REGEX.test(operationName))
+			throw new ProviderError(
+				`Provider "${providerId}" has invalid operations.${operationName}: operation ids must be URL-safe and cannot contain slashes.`,
+				{
+					fix: `Rename operations.${operationName} to a lowercase URL-safe id such as "search-items"`,
+				},
+			);
+		if (RESERVED_OPERATION_IDS.has(operationName))
+			throw new ProviderError(
+				`Provider "${providerId}" operation "${operationName}" conflicts with a reserved server path.`,
+				{
+					fix: `Rename operations.${operationName} to avoid /${operationName}`,
+				},
+			);
+	}
+}
+function validateOperationAnnotations(
+	providerId: string,
+	operations: Record<string, ProviderOperation>,
+): void {
+	for (const [operationName, operation] of Object.entries(operations)) {
+		const annotations = operation.annotations;
+		if (!annotations) continue;
+		const timeoutMs = annotations.timeoutMs;
+		if (timeoutMs === undefined) continue;
+		const field = `operations.${operationName}.annotations.timeoutMs`;
+		if (typeof timeoutMs !== "number" || !Number.isInteger(timeoutMs))
+			throw new ValidationError(
+				`Provider "${providerId}" has invalid ${field}: must be an integer number of milliseconds.`,
+				{
+					fix: `Set ${field} to an integer in [${OPERATION_TIMEOUT_MS_MIN}, ${OPERATION_TIMEOUT_MS_MAX}] (milliseconds).`,
+				},
+			);
+		if (
+			timeoutMs < OPERATION_TIMEOUT_MS_MIN ||
+			timeoutMs > OPERATION_TIMEOUT_MS_MAX
+		)
+			throw new ValidationError(
+				`Provider "${providerId}" has invalid ${field}: ${timeoutMs} is outside [${OPERATION_TIMEOUT_MS_MIN}, ${OPERATION_TIMEOUT_MS_MAX}] ms.`,
+				{
+					fix: `Set ${field} to an integer in [${OPERATION_TIMEOUT_MS_MIN}, ${OPERATION_TIMEOUT_MS_MAX}] ms (the upper bound stays below the gateway/ALB ceiling).`,
+				},
+			);
+	}
+}
+
+const HEALTH_CHECK_SUITE_FIELDS = new Set([
+	"interval",
+	"timeoutMs",
+	"cases",
+	"requiresConnection",
+]);
+const HEALTH_CHECK_CASE_FIELDS = new Set([
+	"name",
+	"description",
+	"input",
+	"assertions",
+	"degradedThresholdMs",
+	"expectedStatus",
+	"enabled",
+]);
+const HEALTH_CHECK_UNSUPPORTED_FIELDS = new Set(["reason", "trackedIn"]);
+const PROVIDER_HEALTH_MONITOR_FIELDS = new Set([
+	"requiredSecrets",
+	"serviceAccount",
+]);
+
+function levenshtein(a: string, b: string): number {
+	const m = a.length;
+	const n = b.length;
+	if (m === 0) return n;
+	if (n === 0) return m;
+	const prev = new Array<number>(n + 1);
+	const curr = new Array<number>(n + 1);
+	for (let j = 0; j <= n; j++) prev[j] = j;
+	for (let i = 1; i <= m; i++) {
+		curr[0] = i;
+		for (let j = 1; j <= n; j++) {
+			const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+			const deletion = (prev[j] ?? 0) + 1;
+			const insertion = (curr[j - 1] ?? 0) + 1;
+			const substitution = (prev[j - 1] ?? 0) + cost;
+			curr[j] = Math.min(deletion, insertion, substitution);
+		}
+		for (let j = 0; j <= n; j++) prev[j] = curr[j] ?? 0;
+	}
+	return prev[n] ?? 0;
+}
+
+function suggestField(
+	unknown: string,
+	candidates: ReadonlySet<string>,
+): string | undefined {
+	let best: string | undefined;
+	let bestDist = 3;
+	for (const candidate of candidates) {
+		const dist = levenshtein(unknown, candidate);
+		if (dist < bestDist) {
+			bestDist = dist;
+			best = candidate;
+		}
+	}
+	return best;
+}
+
+function rejectUnknownFields(
+	value: Record<string, unknown>,
+	allowed: ReadonlySet<string>,
+	fieldPath: string,
+): void {
+	for (const key of Object.keys(value)) {
+		if (allowed.has(key)) continue;
+		const hint = suggestField(key, allowed);
+		throw new ValidationError(
+			hint
+				? `Unknown field "${key}" on ${fieldPath}. Did you mean "${hint}"?`
+				: `Unknown field "${key}" on ${fieldPath}.`,
+			{ fix: `Remove ${fieldPath}.${key} or rename it.` },
+		);
+	}
+}
+
+function validateProviderHealthMonitor(
+	providerId: string,
+	healthMonitor: unknown,
+): void {
+	if (healthMonitor === undefined) return;
+	if (
+		!healthMonitor ||
+		typeof healthMonitor !== "object" ||
+		Array.isArray(healthMonitor)
+	)
+		throw new ValidationError(
+			`Provider "${providerId}" has invalid healthMonitor: must be an object.`,
+			{
+				fix: `Set healthMonitor to { requiredSecrets?: string[]; serviceAccount?: string }`,
+			},
+		);
+	rejectUnknownFields(
+		healthMonitor as Record<string, unknown>,
+		PROVIDER_HEALTH_MONITOR_FIELDS,
+		"healthMonitor",
+	);
+	const requiredSecrets = (healthMonitor as ProviderHealthMonitorConfig)
+		.requiredSecrets;
+	if (requiredSecrets !== undefined) {
+		if (!Array.isArray(requiredSecrets))
+			throw new ValidationError(
+				`Provider "${providerId}" has invalid healthMonitor.requiredSecrets: must be string[].`,
+			);
+		for (const [index, secret] of requiredSecrets.entries()) {
+			if (typeof secret !== "string" || secret.length === 0)
+				throw new ValidationError(
+					`Provider "${providerId}" has invalid healthMonitor.requiredSecrets[${index}]: must be a non-empty string.`,
+				);
+		}
+	}
+	const serviceAccount = (healthMonitor as ProviderHealthMonitorConfig)
+		.serviceAccount;
+	if (
+		serviceAccount !== undefined &&
+		(typeof serviceAccount !== "string" || serviceAccount.length === 0)
+	)
+		throw new ValidationError(
+			`Provider "${providerId}" has invalid healthMonitor.serviceAccount: must be a non-empty string.`,
+		);
+}
+
+function validateHealthCheckCase(
+	providerId: string,
+	operationName: string,
+	caseValue: unknown,
+	caseIndex: number,
+): void {
+	const fieldPath = `operations.${operationName}.healthCheck.cases[${caseIndex}]`;
+	if (!caseValue || typeof caseValue !== "object" || Array.isArray(caseValue))
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath} must be an object.`,
+		);
+	rejectUnknownFields(
+		caseValue as Record<string, unknown>,
+		HEALTH_CHECK_CASE_FIELDS,
+		fieldPath,
+	);
+	const c = caseValue as HealthCheckCase;
+	if (typeof c.name !== "string" || c.name.length === 0)
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.name must be a non-empty string.`,
+		);
+	if (typeof c.assertions !== "function")
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.assertions must be a function.`,
+			{
+				fix: `Set ${fieldPath}.assertions to (ctx) => { ... } that throws on failure.`,
+			},
+		);
+	if (
+		c.degradedThresholdMs !== undefined &&
+		(typeof c.degradedThresholdMs !== "number" ||
+			!Number.isFinite(c.degradedThresholdMs) ||
+			c.degradedThresholdMs <= 0)
+	)
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.degradedThresholdMs must be a positive number.`,
+		);
+	if (
+		c.expectedStatus !== undefined &&
+		c.expectedStatus !== "ok" &&
+		c.expectedStatus !== "degraded"
+	)
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.expectedStatus must be "ok" or "degraded".`,
+		);
+	if (c.enabled !== undefined && typeof c.enabled !== "function")
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.enabled must be a function returning boolean.`,
+		);
+}
+
+function validateHealthCheckSuite(
+	providerId: string,
+	operationName: string,
+	suite: unknown,
+): void {
+	const fieldPath = `operations.${operationName}.healthCheck`;
+	if (!suite || typeof suite !== "object" || Array.isArray(suite))
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath} must be an object.`,
+		);
+	rejectUnknownFields(
+		suite as Record<string, unknown>,
+		HEALTH_CHECK_SUITE_FIELDS,
+		fieldPath,
+	);
+	const s = suite as HealthCheckSuite;
+	if (
+		typeof s.interval !== "string" ||
+		!PROBE_INTERVALS.includes(s.interval as ProbeInterval)
+	)
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.interval must be one of ${PROBE_INTERVALS.join(", ")}.`,
+			{
+				fix: `Set ${fieldPath}.interval to a supported probe interval.`,
+			},
+		);
+	if (s.timeoutMs !== undefined) {
+		if (
+			typeof s.timeoutMs !== "number" ||
+			!Number.isInteger(s.timeoutMs) ||
+			s.timeoutMs <= 0
+		)
+			throw new ValidationError(
+				`Provider "${providerId}" ${fieldPath}.timeoutMs must be a positive integer (ms).`,
+			);
+	}
+	if (
+		s.requiresConnection !== undefined &&
+		typeof s.requiresConnection !== "boolean"
+	)
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.requiresConnection must be a boolean.`,
+		);
+	if (!Array.isArray(s.cases) || s.cases.length === 0)
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.cases must be a non-empty array.`,
+			{
+				fix: `Add at least one HealthCheckCase to ${fieldPath}.cases.`,
+			},
+		);
+	const seenNames = new Set<string>();
+	for (const [index, caseValue] of s.cases.entries()) {
+		validateHealthCheckCase(providerId, operationName, caseValue, index);
+		const name = (caseValue as HealthCheckCase).name;
+		if (seenNames.has(name))
+			throw new ValidationError(
+				`Provider "${providerId}" ${fieldPath}.cases has duplicate case name "${name}".`,
+				{
+					fix: `Rename one of the duplicate cases to be unique within the suite.`,
+				},
+			);
+		seenNames.add(name);
+	}
+}
+
+function validateHealthCheckUnsupported(
+	providerId: string,
+	operationName: string,
+	unsupported: unknown,
+): void {
+	const fieldPath = `operations.${operationName}.healthCheckUnsupported`;
+	if (
+		!unsupported ||
+		typeof unsupported !== "object" ||
+		Array.isArray(unsupported)
+	)
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath} must be an object.`,
+		);
+	rejectUnknownFields(
+		unsupported as Record<string, unknown>,
+		HEALTH_CHECK_UNSUPPORTED_FIELDS,
+		fieldPath,
+	);
+	const u = unsupported as HealthCheckUnsupported;
+	if (typeof u.reason !== "string" || u.reason.trim().length === 0)
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.reason must be a non-empty string.`,
+			{
+				fix: `Document why the operation cannot be probed (e.g., "Destructive mutation; cannot probe in production").`,
+			},
+		);
+	if (u.trackedIn !== undefined && typeof u.trackedIn !== "string")
+		throw new ValidationError(
+			`Provider "${providerId}" ${fieldPath}.trackedIn must be a string when present.`,
+		);
+}
+
+function validateOperationHealthChecks(
+	providerId: string,
+	operations: Record<string, ProviderOperation>,
+): void {
+	for (const [operationName, operation] of Object.entries(operations)) {
+		const hasCheck = operation.healthCheck !== undefined;
+		const hasUnsupported = operation.healthCheckUnsupported !== undefined;
+		if (hasCheck && hasUnsupported)
+			throw new ValidationError(
+				`Provider "${providerId}" operation "${operationName}" declares both healthCheck and healthCheckUnsupported. Choose exactly one.`,
+				{
+					fix: `Remove either operations.${operationName}.healthCheck or operations.${operationName}.healthCheckUnsupported.`,
+				},
+			);
+		if (hasCheck)
+			validateHealthCheckSuite(
+				providerId,
+				operationName,
+				operation.healthCheck,
+			);
+		if (hasUnsupported)
+			validateHealthCheckUnsupported(
+				providerId,
+				operationName,
+				operation.healthCheckUnsupported,
+			);
+		if (!hasCheck && !hasUnsupported)
+			throw new ValidationError(
+				`Provider "${providerId}" operation "${operationName}" declares neither healthCheck nor healthCheckUnsupported.`,
+				{
+					fix: `Add \`healthCheck: { interval, cases: [...] }\` or \`healthCheckUnsupported: { reason: "..." }\` to operations.${operationName}.`,
+				},
+			);
+	}
 }
 
 function validateOperationFixtures(
@@ -42,19 +527,20 @@ function validateOperationFixtures(
 	operations: Record<string, ProviderOperation>,
 ): void {
 	for (const [operationName, operation] of Object.entries(operations)) {
-		if (typeof operation.handler !== "function") {
+		if (typeof operation.handler !== "function")
 			throw new ValidationError(
 				`Operation handler must be defined for provider "${providerId}" operation "${operationName}"`,
 				{
 					fix: `Add operations.${operationName}.handler as an async function with signature (ctx, input) => Promise<output>`,
 				},
 			);
-		}
-
 		if (operation.fixtures?.request !== undefined) {
-			const result = operation.input.safeParse(operation.fixtures.request);
-
-			if (!result.success) {
+			const result = safeParseSchemaSync(
+				operation.input,
+				operation.fixtures.request,
+				`operations.${operationName}.fixtures.request`,
+			);
+			if (!result.success)
 				throw new ValidationError(
 					`Fixture request does not match input schema for provider "${providerId}" operation "${operationName}"`,
 					{
@@ -62,13 +548,14 @@ function validateOperationFixtures(
 						zodError: result.error,
 					},
 				);
-			}
 		}
-
 		if (operation.fixtures?.response !== undefined) {
-			const result = operation.output.safeParse(operation.fixtures.response);
-
-			if (!result.success) {
+			const result = safeParseSchemaSync(
+				operation.output,
+				operation.fixtures.response,
+				`operations.${operationName}.fixtures.response`,
+			);
+			if (!result.success)
 				throw new ValidationError(
 					`Fixture response does not match output schema for provider "${providerId}" operation "${operationName}"`,
 					{
@@ -76,7 +563,6 @@ function validateOperationFixtures(
 						zodError: result.error,
 					},
 				);
-			}
 		}
 	}
 }
@@ -85,53 +571,53 @@ export function defineProvider<
 	TOperations extends Record<string, ProviderOperation>,
 >(
 	config: ProviderConfig<TOperations>,
-): ProviderDefinition & { operations: TOperations } {
-	if (!CONNECTOR_ID_REGEX.test(config.id)) {
+): ProviderDefinition & { operations: OperationMapConfig<TOperations> } {
+	validateProviderShape(config);
+	if (!CONNECTOR_ID_REGEX.test(config.id))
 		throw new ProviderError(`Invalid provider id: "${config.id}"`, {
-			fix: 'Use lowercase alphanumeric with dashes, e.g., "coingecko-prices"',
+			fix: 'Use lowercase alphanumeric with dashes, e.g., "airkorea-realtime"',
 		});
-	}
-
-	if (Object.keys(config.operations).length === 0) {
+	if (Object.keys(config.operations).length === 0)
 		throw new ProviderError(
 			`Provider "${config.id}" must define at least one operation`,
 			{ fix: "Add at least one operation to the operations object" },
 		);
-	}
-
+	validateOperationIds(config.id, config.operations);
+	validateOperationAnnotations(config.id, config.operations);
+	validateOperationHealthChecks(config.id, config.operations);
+	validateProviderHealthMonitor(config.id, config.healthMonitor);
 	validateOperationFixtures(config.id, config.operations);
-
-	if (config.runtime === "browser" && !config.browser) {
+	if (config.runtime === "browser" && !config.browser)
 		throw new ProviderError(
 			`Provider "${config.id}" must define browser.engine when runtime is "browser"`,
 			{
 				fix: 'Add browser: { engine: "nodriver" } or another supported engine',
 			},
 		);
-	}
-
-	if (config.browser && config.runtime !== "browser") {
+	if (config.browser && config.runtime !== "browser")
 		throw new ProviderError(
 			`Provider "${config.id}" cannot define browser config unless runtime is "browser"`,
 			{ fix: 'Set runtime: "browser" or remove the browser config' },
 		);
-	}
-
-	if (config.proxy && !config.stealth) {
+	if (config.proxy && !config.stealth)
 		console.warn(
 			`[provider-sdk] Provider "${config.id}" enables proxy without a stealth profile.`,
 		);
-	}
-
 	return {
 		id: config.id,
 		version: config.version,
 		runtime: config.runtime,
+		allowedHosts: config.allowedHosts,
 		stealth: config.stealth,
 		proxy: config.proxy,
 		browser: config.browser,
 		auth: config.auth,
+		reviewed: config.reviewed,
+		secrets: config.secrets,
+		credential: config.credential,
+		context: config.context,
 		meta: config.meta,
 		operations: config.operations,
+		healthMonitor: config.healthMonitor,
 	};
 }

package/src/dev.ts

@@ -1,4 +1,4 @@
-import { createProviderServer } from "./serve";
+import { serve } from "./server/serve";
 import type { ProviderDefinition } from "./types";
 
 export interface DevServerOptions {
@@ -11,14 +11,10 @@ export function createDevServer(
 	options?: DevServerOptions,
 ): { start: () => void } {
 	const port = options?.port ?? 3900;
-	const server = createProviderServer(provider, {
-		port,
-		sessionDbPath: options?.sessionDbPath,
-	});
 
 	return {
 		start: () => {
-			server.start();
+			void serve(provider, { port });
 			console.log(
 				`[apifuse dev] ${provider.id}@${provider.version} running at http://localhost:${port}`,
 			);