@interactive-inc/claude-funnel 0.67.0 → 0.68.1

package/dist/{schedule-connector-teeDMHUe.js → schedule-connector-BXUOYgwZ.js}

@@ -1,85 +1,10 @@
 import { t as NodeFunnelFileSystem } from "./node-file-system-xJx7dymE.js";
 import { t as errorMessageOf } from "./error-message-of-BG4ezZ_s.js";
 import { t as FunnelConnectorListener } from "./connector-listener-BcQMzY6Q.js";
-import { n as scheduleConnectorSchema, r as scheduleEntrySchema } from "./schedule-connector-schema-C2AChpwX.js";
+import { a as scheduleConnectorSchema, c as matchCron, o as scheduleEntryInputSchema, s as scheduleEntrySchema } from "./schedule-connector-schema-CNV8PgWX.js";
 import { t as FunnelConnectorDiagnosticsRecorder } from "./connector-diagnostics-recorder-BmOijU1p.js";
 import { dirname, join } from "node:path";
 import { z } from "zod";
-//#region lib/engine/connectors/match-cron.ts
-const parseField = (expr, min, max) => {
-	const values = /* @__PURE__ */ new Set();
-	for (const part of expr.split(",")) {
-		const [rangePart, stepPart] = part.split("/");
-		const step = stepPart ? Number(stepPart) : 1;
-		if (!Number.isFinite(step) || step <= 0) throw new Error(`invalid cron step: "${stepPart}"`);
-		let lo = min;
-		let hi = max;
-		if (rangePart === "*" || rangePart === void 0 || rangePart === "") {
-			lo = min;
-			hi = max;
-		} else if (rangePart.includes("-")) {
-			const [aStr, bStr] = rangePart.split("-");
-			const a = Number(aStr);
-			const b = Number(bStr);
-			if (!Number.isFinite(a) || !Number.isFinite(b)) throw new Error(`invalid cron range: "${rangePart}"`);
-			lo = a;
-			hi = b;
-		} else {
-			const n = Number(rangePart);
-			if (!Number.isFinite(n)) throw new Error(`invalid cron value: "${rangePart}"`);
-			lo = n;
-			hi = stepPart ? max : n;
-		}
-		if (lo < min || hi > max || lo > hi) throw new Error(`cron value out of range: ${rangePart} (must be ${min}-${max})`);
-		for (let i = lo; i <= hi; i += step) values.add(i);
-	}
-	return {
-		min,
-		max,
-		values
-	};
-};
-/**
-* Returns true when `date` (local time) satisfies a 5-field cron expression.
-*
-* Two deliberate deviations from Vixie cron, called out so schedules are not
-* written expecting the other behavior:
-*   - Day-of-month and day-of-week are ANDed, not ORed. Vixie cron fires when
-*     EITHER matches once both are restricted; here every field must match.
-*   - Day-of-week is 0-6 (Sunday=0). `7` for Sunday is NOT accepted (it throws
-*     as out-of-range); use `0`.
-*/
-const matchCron = (expr, date) => {
-	const parts = expr.trim().split(/\s+/);
-	if (parts.length !== 5) throw new Error(`cron must have 5 fields (got ${parts.length}): "${expr}"`);
-	const [minute, hour, dom, month, dow] = parts;
-	if (!minute || !hour || !dom || !month || !dow) throw new Error(`cron has empty fields: "${expr}"`);
-	const fields = [
-		{
-			field: parseField(minute, 0, 59),
-			value: date.getMinutes()
-		},
-		{
-			field: parseField(hour, 0, 23),
-			value: date.getHours()
-		},
-		{
-			field: parseField(dom, 1, 31),
-			value: date.getDate()
-		},
-		{
-			field: parseField(month, 1, 12),
-			value: date.getMonth() + 1
-		},
-		{
-			field: parseField(dow, 0, 6),
-			value: date.getDay()
-		}
-	];
-	for (const { field, value } of fields) if (!field.values.has(value)) return false;
-	return true;
-};
-//#endregion
 //#region lib/engine/connectors/schedule-state-store.ts
 const defaultFs = new NodeFunnelFileSystem();
 /**
@@ -190,16 +115,35 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 	async tick(notify) {
 		const now = this.truncateToMinute(this.now());
 		const state = this.lastFiredStore.load();
-		let changed = false;
+		const changes = [this.pruneRemovedEntries(state)];
 		for (const entry of this.config.entries) {
 			if (!entry.enabled) continue;
-			if (await this.fireEntry(entry, now, state, notify)) changed = true;
+			const fired = await this.fireEntry(entry, now, state, notify);
+			changes.push(fired);
 		}
-		if (changed) this.lastFiredStore.save(state);
+		if (changes.includes(true)) this.lastFiredStore.save(state);
 	}
 	async fireEntry(entry, now, state, notify) {
+		if (entry.kind === "once") return this.fireOnceEntry(entry, now, state, notify);
+		return this.fireCronEntry(entry, now, state, notify);
+	}
+	async fireOnceEntry(entry, now, state, notify) {
+		if (state.has(entry.id)) return false;
+		const runAt = new Date(entry.runAt);
+		if (now.getTime() < runAt.getTime()) return false;
+		const lateness = now.getTime() - runAt.getTime();
+		if (entry.catchupPolicy === "skip" && lateness >= 6e4) {
+			state.set(entry.id, runAt);
+			return true;
+		}
+		await this.notifyOne(entry, runAt, notify, lateness > 0);
+		state.set(entry.id, runAt);
+		return true;
+	}
+	async fireCronEntry(entry, now, state, notify) {
 		const lastFired = state.get(entry.id);
-		const searchFrom = lastFired ? new Date(lastFired.getTime() + 6e4) : now;
+		const createdAt = entry.createdAt ? this.truncateToMinute(new Date(entry.createdAt)) : now;
+		const searchFrom = lastFired ? new Date(lastFired.getTime() + 6e4) : createdAt;
 		if (searchFrom.getTime() > now.getTime()) return false;
 		if (entry.catchupPolicy === "skip") {
 			try {
@@ -214,30 +158,38 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		}
 		if (entry.catchupPolicy === "all") {
 			const matches = this.findAllMatches(entry.cron, searchFrom, now, entry.id);
-			if (matches.length === 0) return false;
+			if (matches.length === 0) return this.seedSearchWatermark(entry.id, lastFired, now, state);
 			for (const match of matches) await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime());
 			state.set(entry.id, matches[matches.length - 1] ?? now);
 			return true;
 		}
 		const match = this.findMostRecentMatch(entry.cron, searchFrom, now, entry.id);
-		if (!match) return false;
+		if (!match) return this.seedSearchWatermark(entry.id, lastFired, now, state);
 		await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime());
 		state.set(entry.id, match);
 		return true;
 	}
+	seedSearchWatermark(entryId, lastFired, now, state) {
+		if (lastFired !== void 0) return false;
+		state.set(entryId, now);
+		return true;
+	}
 	async notifyOne(entry, firedAt, notify, catchup) {
 		const meta = {
 			event_type: "schedule",
 			schedule_id: entry.id,
-			cron: entry.cron,
+			schedule_kind: entry.kind,
 			fired_at: firedAt.toISOString(),
 			catchup_policy: entry.catchupPolicy
 		};
+		if (entry.kind === "cron") meta.cron = entry.cron;
+		else meta.run_at = entry.runAt;
 		if (catchup) meta.catchup = "true";
 		const eventId = `${entry.id}@${firedAt.toISOString()}`;
 		this.diagnostics.recordRaw(eventId, JSON.stringify({
 			schedule_id: entry.id,
-			cron: entry.cron,
+			kind: entry.kind,
+			...entry.kind === "cron" ? { cron: entry.cron } : { run_at: entry.runAt },
 			prompt: entry.prompt,
 			fired_at: firedAt.toISOString(),
 			catchup
@@ -308,16 +260,19 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		copy.setSeconds(0, 0);
 		return copy;
 	}
+	pruneRemovedEntries(state) {
+		const configuredIds = new Set(this.config.entries.map((entry) => entry.id));
+		const removedIds = [];
+		for (const id of state.keys()) {
+			if (configuredIds.has(id)) continue;
+			state.delete(id);
+			removedIds.push(id);
+		}
+		return removedIds.length > 0;
+	}
 };
 //#endregion
 //#region lib/engine/connectors/schedule-connector.ts
-const addEntryArgsSchema = z.object({
-	cron: z.string(),
-	prompt: z.string(),
-	id: z.string().optional(),
-	enabled: z.boolean().optional(),
-	catchupPolicy: scheduleEntrySchema.shape.catchupPolicy.optional()
-});
 const removeEntryArgsSchema = z.object({ id: z.string() });
 /**
 * Schedule connector descriptor. Pass `scheduleConnector()` to
@@ -375,11 +330,20 @@ const scheduleConnector = (options = {}) => ({
 		},
 		addEntry(props) {
 			const parsed = scheduleConnectorSchema.parse(props.config);
-			const args = addEntryArgsSchema.parse(props.args);
+			const args = scheduleEntryInputSchema.parse(props.args);
+			const id = args.id ?? props.context.generateId();
+			if (parsed.entries.some((entry) => entry.id === id)) throw new Error(`schedule entry "${id}" already exists`);
 			const entry = scheduleEntrySchema.parse({
-				id: args.id ?? props.context.generateId(),
-				cron: args.cron,
+				id,
+				..."cron" in args ? {
+					kind: "cron",
+					cron: args.cron
+				} : {
+					kind: "once",
+					runAt: args.runAt
+				},
 				prompt: args.prompt,
+				createdAt: props.context.now,
 				...args.enabled !== void 0 ? { enabled: args.enabled } : {},
 				...args.catchupPolicy !== void 0 ? { catchupPolicy: args.catchupPolicy } : {}
 			});
@@ -408,4 +372,4 @@ const scheduleConnector = (options = {}) => ({
 	}
 });
 //#endregion
-export { matchCron as i, FunnelScheduleListener as n, FunnelScheduleStateStore as r, scheduleConnector as t };
+export { FunnelScheduleListener as n, FunnelScheduleStateStore as r, scheduleConnector as t };

package/dist/schedule-connector-schema-CNV8PgWX.js

@@ -0,0 +1,137 @@
+import { z } from "zod";
+//#region lib/engine/connectors/match-cron.ts
+const parseField = (expr, min, max) => {
+	const values = /* @__PURE__ */ new Set();
+	for (const part of expr.split(",")) {
+		if (part.length === 0) throw new Error(`invalid empty cron list item: "${expr}"`);
+		const stepSegments = part.split("/");
+		if (stepSegments.length > 2) throw new Error(`invalid cron step: "${part}"`);
+		const rangePart = stepSegments[0];
+		const stepPart = stepSegments[1];
+		if (stepSegments.length === 2 && stepPart === "") throw new Error(`invalid cron step: "${part}"`);
+		const step = stepPart ? Number(stepPart) : 1;
+		if (!Number.isInteger(step) || step <= 0) throw new Error(`invalid cron step: "${stepPart}"`);
+		let lo = min;
+		let hi = max;
+		if (rangePart === "*" || rangePart === void 0 || rangePart === "") {
+			lo = min;
+			hi = max;
+		} else if (rangePart.includes("-")) {
+			const rangeSegments = rangePart.split("-");
+			if (rangeSegments.length !== 2) throw new Error(`invalid cron range: "${rangePart}"`);
+			const aStr = rangeSegments[0];
+			const bStr = rangeSegments[1];
+			const a = Number(aStr);
+			const b = Number(bStr);
+			if (!Number.isInteger(a) || !Number.isInteger(b)) throw new Error(`invalid cron range: "${rangePart}"`);
+			lo = a;
+			hi = b;
+		} else {
+			const n = Number(rangePart);
+			if (!Number.isInteger(n)) throw new Error(`invalid cron value: "${rangePart}"`);
+			lo = n;
+			hi = stepPart ? max : n;
+		}
+		if (lo < min || hi > max || lo > hi) throw new Error(`cron value out of range: ${rangePart} (must be ${min}-${max})`);
+		for (let i = lo; i <= hi; i += step) values.add(i);
+	}
+	return {
+		min,
+		max,
+		values
+	};
+};
+const parseCron = (expr) => {
+	const parts = expr.trim().split(/\s+/);
+	if (parts.length !== 5) throw new Error(`cron must have 5 fields (got ${parts.length}): "${expr}"`);
+	const [minute, hour, dom, month, dow] = parts;
+	if (!minute || !hour || !dom || !month || !dow) throw new Error(`cron has empty fields: "${expr}"`);
+	return {
+		minute: parseField(minute, 0, 59),
+		hour: parseField(hour, 0, 23),
+		dayOfMonth: parseField(dom, 1, 31),
+		month: parseField(month, 1, 12),
+		dayOfWeek: parseField(dow, 0, 7),
+		dayOfMonthRestricted: dom !== "*",
+		dayOfWeekRestricted: dow !== "*"
+	};
+};
+/** Throws with a user-facing reason when `expr` is not a supported cron expression. */
+const validateCronExpression = (expr) => {
+	parseCron(expr);
+};
+/**
+* Returns true when `date` (local time) satisfies a standard 5-field cron
+* expression. Sunday accepts both 0 and 7. When day-of-month and day-of-week
+* are both restricted, either field matching is sufficient (Vixie cron).
+*/
+const matchCron = (expr, date) => {
+	const cron = parseCron(expr);
+	if (!cron.minute.values.has(date.getMinutes())) return false;
+	if (!cron.hour.values.has(date.getHours())) return false;
+	if (!cron.month.values.has(date.getMonth() + 1)) return false;
+	const dayOfMonthMatches = cron.dayOfMonth.values.has(date.getDate());
+	const day = date.getDay();
+	const dayOfWeekMatches = cron.dayOfWeek.values.has(day) || day === 0 && cron.dayOfWeek.values.has(7);
+	if (cron.dayOfMonthRestricted && cron.dayOfWeekRestricted) return dayOfMonthMatches || dayOfWeekMatches;
+	return dayOfMonthMatches && dayOfWeekMatches;
+};
+//#endregion
+//#region lib/engine/connectors/schedule-connector-schema.ts
+/**
+* Catch-up behavior when the daemon was down past one or more matching minutes.
+*
+* - `latest`: fire once with the most recent missed match (default; preserves prior behavior).
+* - `all`: fire once per missed minute, oldest first (capped at 24 h).
+* - `skip`: never fire missed matches; only fire when the current minute matches.
+*/
+const scheduleCatchupPolicySchema = z.enum([
+	"latest",
+	"all",
+	"skip"
+]);
+const cronExpressionSchema = z.string().superRefine((expression, context) => {
+	try {
+		validateCronExpression(expression);
+	} catch (error) {
+		context.addIssue({
+			code: "custom",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+});
+const scheduleEntryBaseSchema = z.object({
+	id: z.string(),
+	prompt: z.string(),
+	enabled: z.boolean().default(true),
+	catchupPolicy: scheduleCatchupPolicySchema.default("latest"),
+	createdAt: z.string().datetime().optional()
+});
+const scheduleEntryInputBaseSchema = z.object({
+	id: z.string().optional(),
+	prompt: z.string(),
+	enabled: z.boolean().optional(),
+	catchupPolicy: scheduleCatchupPolicySchema.optional()
+});
+const cronScheduleEntryInputSchema = scheduleEntryInputBaseSchema.extend({ cron: cronExpressionSchema }).strict();
+const onceScheduleEntryInputSchema = scheduleEntryInputBaseSchema.extend({ runAt: z.string().datetime({ offset: true }) }).strict();
+const scheduleEntryInputSchema = z.union([onceScheduleEntryInputSchema, cronScheduleEntryInputSchema]);
+const cronScheduleEntrySchema = scheduleEntryBaseSchema.extend({
+	kind: z.literal("cron").default("cron"),
+	cron: cronExpressionSchema
+});
+const onceScheduleEntrySchema = scheduleEntryBaseSchema.extend({
+	kind: z.literal("once"),
+	runAt: z.string().datetime({ offset: true })
+});
+const scheduleEntrySchema = z.union([onceScheduleEntrySchema, cronScheduleEntrySchema]);
+const scheduleConnectorSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.literal("schedule"),
+	entries: z.array(scheduleEntrySchema).default([]),
+	createdAt: z.string().datetime().optional(),
+	updatedAt: z.string().datetime().optional()
+});
+//#endregion
+export { scheduleConnectorSchema as a, matchCron as c, scheduleCatchupPolicySchema as i, validateCronExpression as l, cronScheduleEntrySchema as n, scheduleEntryInputSchema as o, onceScheduleEntrySchema as r, scheduleEntrySchema as s, cronExpressionSchema as t };

package/dist/schedule-connector-schema-Tq5kJul-.d.ts

@@ -0,0 +1,127 @@
+import { z } from "zod";
+//#region lib/engine/connectors/schedule-connector-schema.d.ts
+/**
+ * Catch-up behavior when the daemon was down past one or more matching minutes.
+ *
+ * - `latest`: fire once with the most recent missed match (default; preserves prior behavior).
+ * - `all`: fire once per missed minute, oldest first (capped at 24 h).
+ * - `skip`: never fire missed matches; only fire when the current minute matches.
+ */
+declare const scheduleCatchupPolicySchema: z.ZodEnum<{
+  latest: "latest";
+  all: "all";
+  skip: "skip";
+}>;
+type ScheduleCatchupPolicy = z.infer<typeof scheduleCatchupPolicySchema>;
+declare const cronExpressionSchema: z.ZodString;
+declare const scheduleEntryInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+  id: z.ZodOptional<z.ZodString>;
+  prompt: z.ZodString;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  catchupPolicy: z.ZodOptional<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  runAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  id: z.ZodOptional<z.ZodString>;
+  prompt: z.ZodString;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  catchupPolicy: z.ZodOptional<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  cron: z.ZodString;
+}, z.core.$strict>]>;
+type ScheduleEntryInput = z.input<typeof scheduleEntryInputSchema>;
+declare const cronScheduleEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  kind: z.ZodDefault<z.ZodLiteral<"cron">>;
+  cron: z.ZodString;
+}, z.core.$strip>;
+declare const onceScheduleEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  kind: z.ZodLiteral<"once">;
+  runAt: z.ZodString;
+}, z.core.$strip>;
+declare const scheduleEntrySchema: z.ZodUnion<readonly [z.ZodObject<{
+  id: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  kind: z.ZodLiteral<"once">;
+  runAt: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  kind: z.ZodDefault<z.ZodLiteral<"cron">>;
+  cron: z.ZodString;
+}, z.core.$strip>]>;
+type ScheduleEntry = z.infer<typeof scheduleEntrySchema>;
+type CronScheduleEntry = z.infer<typeof cronScheduleEntrySchema>;
+type OnceScheduleEntry = z.infer<typeof onceScheduleEntrySchema>;
+declare const scheduleConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"schedule">;
+  entries: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"once">;
+    runAt: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    kind: z.ZodDefault<z.ZodLiteral<"cron">>;
+    cron: z.ZodString;
+  }, z.core.$strip>]>>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>;
+//#endregion
+export { ScheduleEntry as a, cronScheduleEntrySchema as c, scheduleConnectorSchema as d, scheduleEntryInputSchema as f, ScheduleConnectorConfig as i, onceScheduleEntrySchema as l, OnceScheduleEntry as n, ScheduleEntryInput as o, scheduleEntrySchema as p, ScheduleCatchupPolicy as r, cronExpressionSchema as s, CronScheduleEntry as t, scheduleCatchupPolicySchema as u };

package/dist/{slack-connector-BE0KAjCs.js → slack-connector-BTtUiXAU.js}

@@ -5,7 +5,7 @@ import { t as slackConnectorSchema } from "./slack-connector-schema-EGVuuqSX.js"
 import { t as FunnelConnectorAdapter } from "./connector-adapter-BL2ehMej.js";
 import { t as FunnelSlackEventProcessor } from "./slack-event-processor-Cs_YuI3w.js";
 import { t as resolveConnectorToken } from "./resolve-connector-token-BwiJCu82.js";
-import { i as resolveFlumeDeps, n as FunnelFlumeSourceListener, r as flumeLogHandler, t as slotFields } from "./slot-fields-5ERhytIA.js";
+import { i as resolveFlumeDeps, n as FunnelFlumeSourceListener, r as flumeLogHandler, t as slotFields } from "./slot-fields-eCWizJqS.js";
 import { z } from "zod";
 import { FlumeSlackSource } from "@interactive-inc/flume/slack";
 //#region lib/engine/connectors/slack-adapter.ts
@@ -219,7 +219,7 @@ var FunnelFlumeSlackListener = class extends FunnelFlumeSourceListener {
 				}
 			})).text();
 		} catch (error) {
-			this.diagnostics.recordConnection("auth-failed", errorMessageOf(error));
+			this.diagnostics.recordConnection("error", errorMessageOf(error));
 			throw error;
 		}
 		const parsed = authTestResponseSchema.safeParse(safeJsonParse(text));

package/dist/{slot-fields-5ERhytIA.js → slot-fields-eCWizJqS.js}

@@ -46,7 +46,7 @@ const flumeLogHandler = (logger) => {
 	};
 };
 const buildMeta = (log) => {
-	const meta = { ...log.detail ?? {} };
+	const meta = { ...log.detail };
 	if (log.error) {
 		meta.error = log.error.message;
 		if (log.error.stack) meta.stack = log.error.stack;