@resolveio/server-lib 22.3.124 → 22.3.126

package/src/util/aicoder-runner-v6.ts

@@ -0,0 +1,526 @@
+export type ResolveIOAICoderV6Lane =
+	| 'intake'
+	| 'plan'
+	| 'build'
+	| 'qa'
+	| 'repair'
+	| 'review'
+	| 'publish';
+
+export type ResolveIOAICoderV6StepType =
+	| 'intake'
+	| 'plan'
+	| 'task'
+	| 'build'
+	| 'qa'
+	| 'repair'
+	| 'review'
+	| 'test_deploy'
+	| 'live_deploy'
+	| 'publish'
+	| 'cleanup';
+
+export type ResolveIOAICoderV6Outcome =
+	| 'pass'
+	| 'needs_repair'
+	| 'retry_same_step'
+	| 'park_manual'
+	| 'budget_stop'
+	| 'infra_retry'
+	| 'ready_to_publish'
+	| 'published';
+
+export type ResolveIOAICoderV6RunKind = 'initial_builder' | 'terminal_helper';
+
+export interface ResolveIOAICoderV6Budget {
+	maxPromptTokensPerNonInitialStep: number;
+	maxTotalPromptTokens: number;
+	maxLoopsPerRun: number;
+	maxRepeatedNoProgress: number;
+	maxRuntimeMinutesPerLane: number;
+	softBudgetUsd: number;
+	hardBudgetUsd: number;
+	totalPromptTokenEstimate: number;
+	totalInputTokens: number;
+	totalCachedInputTokens: number;
+	totalOutputTokens: number;
+	totalRuntimeMs: number;
+	loopCount: number;
+}
+
+export interface ResolveIOAICoderV6LaneMemory {
+	lane: ResolveIOAICoderV6Lane;
+	model: string;
+	threadKey: string;
+	scopeSummary: string;
+	activeStep: ResolveIOAICoderV6StepType;
+	activeBlocker: string;
+	activeQaRow?: {
+		index?: number;
+		workflow?: string;
+		route?: string;
+		assertion?: string;
+		status?: string;
+	};
+	changedFiles: string[];
+	artifactPaths: string[];
+	latestPromptVersion?: string;
+	latestPromptTokenEstimate?: number;
+	updatedAt: string;
+}
+
+export interface ResolveIOAICoderV6SupervisorState {
+	version: 'v6';
+	runKind: ResolveIOAICoderV6RunKind;
+	status: 'active' | 'parked' | 'complete';
+	currentGoal: string;
+	approvedScope: string;
+	branchName: string;
+	activeLane: ResolveIOAICoderV6Lane;
+	activeStep: ResolveIOAICoderV6StepType;
+	activeBlocker: string;
+	lastGoodCheckpoint: string;
+	lastGoodCommit?: string;
+	testDeployStatus?: string;
+	liveDeployStatus?: string;
+	processLease?: {
+		runId?: string;
+		token?: string;
+		generation?: number;
+		workspace?: string;
+		lane?: string;
+	};
+	artifactLinks: string[];
+	updatedAt: string;
+}
+
+export interface ResolveIOAICoderV6StepRecord {
+	stepType: ResolveIOAICoderV6StepType;
+	outcome: ResolveIOAICoderV6Outcome;
+	lane: ResolveIOAICoderV6Lane;
+	model?: string;
+	threadKey?: string;
+	promptVersion?: string;
+	promptTokenEstimate?: number;
+	inputTokens?: number;
+	cachedInputTokens?: number;
+	outputTokens?: number;
+	runtimeMs?: number;
+	summary: string;
+	blocker?: string;
+	blockerFingerprint?: string;
+	changedFiles?: string[];
+	artifactPaths?: string[];
+	nextAction?: ResolveIOAICoderV6ContinuationDecision['action'];
+	recordedAt: string;
+}
+
+export interface ResolveIOAICoderV6RunnerIncident {
+	incidentClass: string;
+	summary: string;
+	stepType?: ResolveIOAICoderV6StepType;
+	lane?: ResolveIOAICoderV6Lane;
+	blockerFingerprint?: string;
+	artifactPaths?: string[];
+	recordedAt: string;
+}
+
+export interface ResolveIOAICoderV6StateBundle {
+	aiCoderRunnerVersion: 'v6';
+	aiCoderV6SupervisorState: ResolveIOAICoderV6SupervisorState;
+	aiCoderV6LaneMemory: Record<ResolveIOAICoderV6Lane, ResolveIOAICoderV6LaneMemory>;
+	aiCoderV6StepHistory: ResolveIOAICoderV6StepRecord[];
+	aiCoderV6Budget: ResolveIOAICoderV6Budget;
+	aiCoderV6RunnerIncidents: ResolveIOAICoderV6RunnerIncident[];
+}
+
+export interface ResolveIOAICoderV6InitializeInput {
+	runKind: ResolveIOAICoderV6RunKind;
+	jobId: string;
+	appId?: string;
+	conversationId?: string;
+	title?: string;
+	description?: string;
+	approvedScopeRequirements?: string[];
+	branchName?: string;
+	defaultModel?: string;
+	laneThreadKeys?: Partial<Record<ResolveIOAICoderV6Lane, string>>;
+	processLease?: ResolveIOAICoderV6SupervisorState['processLease'];
+	now?: Date | string;
+	existing?: Partial<ResolveIOAICoderV6StateBundle>;
+}
+
+export interface ResolveIOAICoderV6StepInput {
+	stepType: ResolveIOAICoderV6StepType;
+	outcome: ResolveIOAICoderV6Outcome;
+	lane: ResolveIOAICoderV6Lane;
+	model?: string;
+	threadKey?: string;
+	promptVersion?: string;
+	promptTokenEstimate?: number;
+	inputTokens?: number;
+	cachedInputTokens?: number;
+	outputTokens?: number;
+	runtimeMs?: number;
+	summary?: string;
+	blocker?: string;
+	changedFiles?: string[];
+	artifactPaths?: string[];
+	activeQaRow?: ResolveIOAICoderV6LaneMemory['activeQaRow'];
+	nextAction?: ResolveIOAICoderV6ContinuationDecision['action'];
+	now?: Date | string;
+}
+
+export interface ResolveIOAICoderV6ContinuationDecision {
+	action: 'continue' | 'retry_same_step' | 'switch_to_repair' | 'park' | 'budget_stop' | 'infra_retry' | 'ready_to_publish';
+	reason: string;
+	nextLane: ResolveIOAICoderV6Lane;
+	nextStep: ResolveIOAICoderV6StepType;
+	repeatedNoProgressCount: number;
+	budgetExceeded: boolean;
+}
+
+const LANES: ResolveIOAICoderV6Lane[] = ['intake', 'plan', 'build', 'qa', 'repair', 'review', 'publish'];
+
+function isoNow(value?: Date | string): string {
+	if (value instanceof Date) {
+		return value.toISOString();
+	}
+	const parsed = value ? new Date(value) : new Date();
+	if (Number.isFinite(parsed.getTime())) {
+		return parsed.toISOString();
+	}
+	return new Date().toISOString();
+}
+
+function cleanText(value: any, max = 2000): string {
+	return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
+}
+
+function cleanList(values: any, limit = 20, max = 500): string[] {
+	if (!Array.isArray(values)) {
+		return [];
+	}
+	const result: string[] = [];
+	for (const value of values) {
+		const normalized = cleanText(value, max);
+		if (normalized && !result.includes(normalized)) {
+			result.push(normalized);
+		}
+		if (result.length >= limit) {
+			break;
+		}
+	}
+	return result;
+}
+
+function cleanNumber(value: any): number {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
+}
+
+export function fingerprintResolveIOAICoderV6Blocker(value: any): string {
+	const text = cleanText(value, 4000)
+		.toLowerCase()
+		.replace(/[a-f0-9]{16,}/g, '<id>')
+		.replace(/\b\d{2,}\b/g, '<n>')
+		.replace(/\bline\s+<n>\b/g, 'line <n>')
+		.replace(/https?:\/\/\S+/g, '<url>');
+	let hash = 0;
+	for (let index = 0; index < text.length; index += 1) {
+		hash = ((hash << 5) - hash + text.charCodeAt(index)) | 0;
+	}
+	return `aicoder-v6-${Math.abs(hash).toString(36)}`;
+}
+
+export function buildResolveIOAICoderV6Budget(existing?: Partial<ResolveIOAICoderV6Budget>): ResolveIOAICoderV6Budget {
+	return {
+		maxPromptTokensPerNonInitialStep: Number(existing?.maxPromptTokensPerNonInitialStep || 4000),
+		maxTotalPromptTokens: Number(existing?.maxTotalPromptTokens || 120000),
+		maxLoopsPerRun: Number(existing?.maxLoopsPerRun || 24),
+		maxRepeatedNoProgress: Number(existing?.maxRepeatedNoProgress || 2),
+		maxRuntimeMinutesPerLane: Number(existing?.maxRuntimeMinutesPerLane || 30),
+		softBudgetUsd: Number(existing?.softBudgetUsd || 30),
+		hardBudgetUsd: Number(existing?.hardBudgetUsd || 60),
+		totalPromptTokenEstimate: cleanNumber(existing?.totalPromptTokenEstimate),
+		totalInputTokens: cleanNumber(existing?.totalInputTokens),
+		totalCachedInputTokens: cleanNumber(existing?.totalCachedInputTokens),
+		totalOutputTokens: cleanNumber(existing?.totalOutputTokens),
+		totalRuntimeMs: cleanNumber(existing?.totalRuntimeMs),
+		loopCount: cleanNumber(existing?.loopCount)
+	};
+}
+
+export function initializeResolveIOAICoderV6State(input: ResolveIOAICoderV6InitializeInput): ResolveIOAICoderV6StateBundle {
+	const now = isoNow(input.now);
+	const existing = input.existing || {};
+	const existingSupervisor = existing.aiCoderV6SupervisorState;
+	const existingLaneMemory = existing.aiCoderV6LaneMemory || {} as ResolveIOAICoderV6StateBundle['aiCoderV6LaneMemory'];
+	const scope = cleanList(input.approvedScopeRequirements, 24, 240).join(' | ')
+		|| cleanText(input.description, 1000)
+		|| cleanText(input.title, 300);
+	const runId = cleanText(input.conversationId || input.jobId || input.appId, 120);
+	const defaultModel = cleanText(input.defaultModel || 'gpt-5.3-codex', 80);
+	const buildLaneMemory = (lane: ResolveIOAICoderV6Lane): ResolveIOAICoderV6LaneMemory => {
+		const previous = existingLaneMemory[lane] || {} as Partial<ResolveIOAICoderV6LaneMemory>;
+		return {
+			lane,
+			model: cleanText(previous.model || defaultModel, 80),
+			threadKey: cleanText(input.laneThreadKeys?.[lane] || previous.threadKey || `aicoder:${input.runKind}:${runId}:${lane}`, 240),
+			scopeSummary: cleanText(previous.scopeSummary || scope, 1200),
+			activeStep: previous.activeStep || (lane === 'plan' ? 'plan' : lane === 'qa' ? 'qa' : lane === 'review' ? 'review' : lane === 'publish' ? 'publish' : 'task'),
+			activeBlocker: cleanText(previous.activeBlocker, 1200),
+			activeQaRow: previous.activeQaRow,
+			changedFiles: cleanList(previous.changedFiles, 80, 500),
+			artifactPaths: cleanList(previous.artifactPaths, 80, 500),
+			latestPromptVersion: cleanText(previous.latestPromptVersion, 120) || undefined,
+			latestPromptTokenEstimate: cleanNumber(previous.latestPromptTokenEstimate) || undefined,
+			updatedAt: previous.updatedAt || now
+		};
+	};
+	const laneMemory = LANES.reduce((accumulator, lane) => {
+		accumulator[lane] = buildLaneMemory(lane);
+		return accumulator;
+	}, {} as Record<ResolveIOAICoderV6Lane, ResolveIOAICoderV6LaneMemory>);
+	const activeLane = existingSupervisor?.activeLane || (input.runKind === 'initial_builder' ? 'plan' : 'build');
+	return {
+		aiCoderRunnerVersion: 'v6',
+		aiCoderV6SupervisorState: {
+			version: 'v6',
+			runKind: input.runKind,
+			status: existingSupervisor?.status || 'active',
+			currentGoal: cleanText(existingSupervisor?.currentGoal || `Run AICoder ${input.runKind} ${runId}`, 500),
+			approvedScope: cleanText(existingSupervisor?.approvedScope || scope, 1400),
+			branchName: cleanText(input.branchName || existingSupervisor?.branchName, 240),
+			activeLane,
+			activeStep: existingSupervisor?.activeStep || laneMemory[activeLane].activeStep,
+			activeBlocker: cleanText(existingSupervisor?.activeBlocker, 1200),
+			lastGoodCheckpoint: existingSupervisor?.lastGoodCheckpoint || 'v6_initialized',
+			lastGoodCommit: cleanText(existingSupervisor?.lastGoodCommit, 240) || undefined,
+			testDeployStatus: cleanText(existingSupervisor?.testDeployStatus, 120) || undefined,
+			liveDeployStatus: cleanText(existingSupervisor?.liveDeployStatus, 120) || undefined,
+			processLease: input.processLease || existingSupervisor?.processLease,
+			artifactLinks: cleanList(existingSupervisor?.artifactLinks, 80, 500),
+			updatedAt: now
+		},
+		aiCoderV6LaneMemory: laneMemory,
+		aiCoderV6StepHistory: Array.isArray(existing.aiCoderV6StepHistory)
+			? existing.aiCoderV6StepHistory.slice(-100)
+			: [],
+		aiCoderV6Budget: buildResolveIOAICoderV6Budget(existing.aiCoderV6Budget),
+		aiCoderV6RunnerIncidents: Array.isArray(existing.aiCoderV6RunnerIncidents)
+			? existing.aiCoderV6RunnerIncidents.slice(-100)
+			: []
+	};
+}
+
+export function recordResolveIOAICoderV6Step(
+	bundle: ResolveIOAICoderV6StateBundle,
+	step: ResolveIOAICoderV6StepInput
+): ResolveIOAICoderV6StateBundle {
+	const now = isoNow(step.now);
+	const promptTokens = cleanNumber(step.promptTokenEstimate);
+	const inputTokens = cleanNumber(step.inputTokens);
+	const cachedInputTokens = cleanNumber(step.cachedInputTokens);
+	const outputTokens = cleanNumber(step.outputTokens);
+	const runtimeMs = cleanNumber(step.runtimeMs);
+	const blocker = cleanText(step.blocker, 1200);
+	const record: ResolveIOAICoderV6StepRecord = {
+		stepType: step.stepType,
+		outcome: step.outcome,
+		lane: step.lane,
+		model: cleanText(step.model, 80) || undefined,
+		threadKey: cleanText(step.threadKey, 240) || undefined,
+		promptVersion: cleanText(step.promptVersion, 120) || undefined,
+		promptTokenEstimate: promptTokens || undefined,
+		inputTokens: inputTokens || undefined,
+		cachedInputTokens: cachedInputTokens || undefined,
+		outputTokens: outputTokens || undefined,
+		runtimeMs: runtimeMs || undefined,
+		summary: cleanText(step.summary || blocker || step.outcome, 1200),
+		blocker: blocker || undefined,
+		blockerFingerprint: blocker ? fingerprintResolveIOAICoderV6Blocker(blocker) : undefined,
+		changedFiles: cleanList(step.changedFiles, 80, 500),
+		artifactPaths: cleanList(step.artifactPaths, 80, 500),
+		nextAction: step.nextAction,
+		recordedAt: now
+	};
+	const previousLane = bundle.aiCoderV6LaneMemory[step.lane];
+	const laneMemory = {
+		...bundle.aiCoderV6LaneMemory,
+		[step.lane]: {
+			...previousLane,
+			model: record.model || previousLane.model,
+			threadKey: record.threadKey || previousLane.threadKey,
+			activeStep: step.stepType,
+			activeBlocker: record.blocker || previousLane.activeBlocker || '',
+			activeQaRow: step.activeQaRow || previousLane.activeQaRow,
+			changedFiles: record.changedFiles?.length ? record.changedFiles : previousLane.changedFiles,
+			artifactPaths: record.artifactPaths?.length ? record.artifactPaths : previousLane.artifactPaths,
+			latestPromptVersion: record.promptVersion || previousLane.latestPromptVersion,
+			latestPromptTokenEstimate: promptTokens || previousLane.latestPromptTokenEstimate,
+			updatedAt: now
+		}
+	};
+	const complete = step.outcome === 'published' || step.outcome === 'ready_to_publish';
+	const parked = step.outcome === 'park_manual' || step.outcome === 'budget_stop';
+	return {
+		...bundle,
+		aiCoderV6SupervisorState: {
+			...bundle.aiCoderV6SupervisorState,
+			status: complete ? 'complete' : (parked ? 'parked' : 'active'),
+			activeLane: step.lane,
+			activeStep: step.stepType,
+			activeBlocker: record.blocker || '',
+			lastGoodCheckpoint: step.outcome === 'pass' || complete ? step.stepType : bundle.aiCoderV6SupervisorState.lastGoodCheckpoint,
+			artifactLinks: Array.from(new Set([
+				...bundle.aiCoderV6SupervisorState.artifactLinks,
+				...(record.artifactPaths || [])
+			])).slice(-80),
+			updatedAt: now
+		},
+		aiCoderV6LaneMemory: laneMemory,
+		aiCoderV6StepHistory: [...bundle.aiCoderV6StepHistory, record].slice(-120),
+		aiCoderV6Budget: {
+			...bundle.aiCoderV6Budget,
+			totalPromptTokenEstimate: bundle.aiCoderV6Budget.totalPromptTokenEstimate + promptTokens,
+			totalInputTokens: bundle.aiCoderV6Budget.totalInputTokens + inputTokens,
+			totalCachedInputTokens: bundle.aiCoderV6Budget.totalCachedInputTokens + cachedInputTokens,
+			totalOutputTokens: bundle.aiCoderV6Budget.totalOutputTokens + outputTokens,
+			totalRuntimeMs: bundle.aiCoderV6Budget.totalRuntimeMs + runtimeMs,
+			loopCount: bundle.aiCoderV6Budget.loopCount + 1
+		}
+	};
+}
+
+export function decideResolveIOAICoderV6Continuation(bundle: ResolveIOAICoderV6StateBundle): ResolveIOAICoderV6ContinuationDecision {
+	const history = bundle.aiCoderV6StepHistory || [];
+	const budget = buildResolveIOAICoderV6Budget(bundle.aiCoderV6Budget);
+	const last = history[history.length - 1];
+	const lastFingerprint = fingerprintResolveIOAICoderV6Blocker(last?.blocker || last?.summary || '');
+	let repeatedNoProgressCount = 0;
+	for (let index = history.length - 1; index >= 0; index -= 1) {
+		const item = history[index];
+		if (item.outcome === 'pass' || item.outcome === 'ready_to_publish' || item.outcome === 'published') {
+			break;
+		}
+		if (item.stepType !== last?.stepType || item.lane !== last?.lane) {
+			break;
+		}
+		if (fingerprintResolveIOAICoderV6Blocker(item.blocker || item.summary || '') === lastFingerprint) {
+			repeatedNoProgressCount += 1;
+		}
+	}
+	const budgetExceeded = budget.loopCount >= budget.maxLoopsPerRun
+		|| budget.totalPromptTokenEstimate >= budget.maxTotalPromptTokens
+		|| (last?.promptTokenEstimate || 0) > budget.maxPromptTokensPerNonInitialStep * 2;
+	if (budgetExceeded) {
+		return {
+			action: 'budget_stop',
+			reason: 'aicoder_v6_budget_guard',
+			nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
+			nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
+			repeatedNoProgressCount,
+			budgetExceeded
+		};
+	}
+	if (repeatedNoProgressCount > budget.maxRepeatedNoProgress) {
+		return {
+			action: 'park',
+			reason: 'aicoder_v6_repeated_no_progress',
+			nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
+			nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
+			repeatedNoProgressCount,
+			budgetExceeded: false
+		};
+	}
+	if (last?.outcome === 'needs_repair') {
+		return {
+			action: last.lane === 'repair' ? 'retry_same_step' : 'switch_to_repair',
+			reason: 'aicoder_v6_repair_required',
+			nextLane: 'repair',
+			nextStep: 'repair',
+			repeatedNoProgressCount,
+			budgetExceeded: false
+		};
+	}
+	if (last?.outcome === 'infra_retry') {
+		return {
+			action: 'infra_retry',
+			reason: 'aicoder_v6_infra_retry',
+			nextLane: last.lane,
+			nextStep: last.stepType,
+			repeatedNoProgressCount,
+			budgetExceeded: false
+		};
+	}
+	if (last?.outcome === 'ready_to_publish') {
+		return {
+			action: 'ready_to_publish',
+			reason: 'aicoder_v6_ready_to_publish',
+			nextLane: 'publish',
+			nextStep: 'publish',
+			repeatedNoProgressCount,
+			budgetExceeded: false
+		};
+	}
+	return {
+		action: 'continue',
+		reason: 'aicoder_v6_continue',
+		nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
+		nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
+		repeatedNoProgressCount,
+		budgetExceeded: false
+	};
+}
+
+export function buildResolveIOAICoderV6DiagnoseFirstPrompt(lines: {
+	goal?: string;
+	approvedScope?: string[];
+	activeLane?: ResolveIOAICoderV6Lane;
+	activeStep?: ResolveIOAICoderV6StepType;
+	activeBlocker?: string;
+	laneSummary?: string;
+	currentQaRow?: ResolveIOAICoderV6LaneMemory['activeQaRow'];
+	artifactPaths?: string[];
+	changedFiles?: string[];
+}): string[] {
+	return [
+		'AICoder Runner V6 contract: use compact lane memory, diagnose first, then make the smallest proven next move.',
+		'Start with Diagnose First: observed evidence, likely cause, smallest next action, and expected proof.',
+		'Use current artifacts, changed files, and lane memory before asking for broad context.',
+		'Do not spawn duplicate build, QA, browser, server, Mongo, or Codex processes.',
+		'If repairing, inspect logs/artifacts/source/diff first; retest the failed check before advancing.',
+		'If the same blocker repeats without new proof, park with the exact blocker instead of burning more tokens.',
+		lines.goal ? `Goal: ${cleanText(lines.goal, 500)}` : '',
+		cleanList(lines.approvedScope, 12, 240).length ? `Approved scope: ${cleanList(lines.approvedScope, 12, 240).join(' | ')}` : '',
+		lines.activeLane ? `Active lane: ${lines.activeLane}` : '',
+		lines.activeStep ? `Active step: ${lines.activeStep}` : '',
+		lines.laneSummary ? `Lane memory: ${cleanText(lines.laneSummary, 700)}` : '',
+		lines.activeBlocker ? `Active blocker: ${cleanText(lines.activeBlocker, 800)}` : '',
+		lines.currentQaRow?.workflow ? `Current QA row: ${cleanText(lines.currentQaRow.workflow, 300)}` : '',
+		lines.currentQaRow?.route ? `Current QA route: ${cleanText(lines.currentQaRow.route, 300)}` : '',
+		cleanList(lines.changedFiles, 12, 200).length ? `Changed files: ${cleanList(lines.changedFiles, 12, 200).join(', ')}` : '',
+		cleanList(lines.artifactPaths, 12, 240).length ? `Artifacts: ${cleanList(lines.artifactPaths, 12, 240).join(', ')}` : ''
+	].filter(Boolean);
+}
+
+export function buildResolveIOAICoderV6Incident(input: {
+	incidentClass: string;
+	summary: string;
+	stepType?: ResolveIOAICoderV6StepType;
+	lane?: ResolveIOAICoderV6Lane;
+	blocker?: string;
+	artifactPaths?: string[];
+	now?: Date | string;
+}): ResolveIOAICoderV6RunnerIncident {
+	return {
+		incidentClass: cleanText(input.incidentClass, 120) || 'aicoder_v6_runner_incident',
+		summary: cleanText(input.summary, 1200),
+		stepType: input.stepType,
+		lane: input.lane,
+		blockerFingerprint: input.blocker ? fingerprintResolveIOAICoderV6Blocker(input.blocker) : undefined,
+		artifactPaths: cleanList(input.artifactPaths, 40, 500),
+		recordedAt: isoNow(input.now)
+	};
+}