@sentry/junior 0.267.0 → 0.269.0

package/dist/locks-D-0h111u.js

@@ -0,0 +1,48 @@
+import { setTimeout } from "node:timers/promises";
+// src/chat/state/locks.ts
+const ACTIVE_LOCK_TTL_MS = 9e4;
+const MUTATION_LOCK_TTL_MS = 1e4;
+/**
+* Acquire a lock for long-running work that the queued state adapter should
+* keep alive while the owning invocation is still making progress.
+*/
+async function acquireActiveLock(state, threadId) {
+	return await state.acquireLock(threadId, ACTIVE_LOCK_TTL_MS);
+}
+/**
+* Run work under one lock, optionally waiting for the current owner.
+* `keepAlive` is for multi-store mutations that must retain ownership until all
+* side effects finish; callers should still fence each blind write.
+*/
+async function withLock(state, key, run, options = {}) {
+	const ttlMs = options.ttlMs ?? 9e4;
+	const startedAtMs = Date.now();
+	let lock;
+	while (true) {
+		lock = await state.acquireLock(key, ttlMs);
+		if (lock) break;
+		if (Date.now() - startedAtMs >= (options.waitMs ?? 0)) return { acquired: false };
+		await setTimeout(options.retryMs ?? 25, void 0, { ref: false });
+	}
+	const heartbeat = options.keepAlive ? setInterval(() => void state.extendLock(lock, ttlMs).catch(() => void 0), Math.max(1, Math.floor(ttlMs / 3))) : void 0;
+	heartbeat?.unref();
+	try {
+		return {
+			acquired: true,
+			value: await run(lock)
+		};
+	} finally {
+		if (heartbeat) clearInterval(heartbeat);
+		await state.releaseLock(lock);
+	}
+}
+/**
+* Prove lock ownership immediately before a blind write.
+*
+* Whole-record mutations must stop if their lock expired rather than overwrite
+* state committed by a newer owner.
+*/
+async function fenceLock(state, lock, ttlMs = MUTATION_LOCK_TTL_MS) {
+	if (!await state.extendLock(lock, ttlMs)) throw new Error(`Lock ownership was lost before write for ${lock.threadId}`);
+}
+export { withLock as a, fenceLock as i, MUTATION_LOCK_TTL_MS as n, acquireActiveLock as r, ACTIVE_LOCK_TTL_MS as t };

package/dist/{logging-DuZ1A4ab.js → logging-n7knse-O.js}

@@ -1,5 +1,5 @@
 import { _ as withScope, d as setTag, f as setUser, h as startSpan, i as getActiveSpan, l as logger, n as captureMessage, p as spanToJSON, s as getTraceData, t as captureException } from "./sentry-MDkYAVPV.js";
-import { t as JUNIOR_VERSION } from "./version-Bapedn4A.js";
+import { t as JUNIOR_VERSION } from "./version-CXCHLgWm.js";
 import path from "node:path";
 import { styleText } from "node:util";
 import { ConfigError, configureSync, getConfig, getLogger } from "@logtape/logtape";

package/dist/{history-C84mlAwO.js → media-85PDJxO_.js}

@@ -522,4 +522,86 @@ const newConversationEventSchema = z.object({
 	idempotencyKey: z.string().min(1).optional(),
 	createdAtMs: z.number().finite()
 }).strict();
-export { conversationTurnFailureReasonSchema as a, newConversationEventSchema as c, contextProvenance as d, instructionActors as f, usageSchema as h, conversationTurnFailureCodeSchema as i, encodeHistoryPayload as l, sameActorIdentity as m, agentHistoryItemSchema as n, decodeStoredConversationEvent as o, instructionProvenanceFor as p, conversationEventDataSchema as r, historyReplacementSchema as s, KNOWN_CONVERSATION_EVENT_TYPES as t, agentInstructionProvenance as u };
+// src/chat/attachments/media.ts
+const INPUT_IMAGE_TYPES = [
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+];
+/** Leading bytes of each accepted image type. `null` matches any byte. */
+const IMAGE_SIGNATURES = [
+	{
+		mediaType: "image/png",
+		bytes: [
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		]
+	},
+	{
+		mediaType: "image/jpeg",
+		bytes: [
+			255,
+			216,
+			255
+		]
+	},
+	{
+		mediaType: "image/gif",
+		bytes: [
+			71,
+			73,
+			70,
+			56,
+			55,
+			97
+		]
+	},
+	{
+		mediaType: "image/gif",
+		bytes: [
+			71,
+			73,
+			70,
+			56,
+			57,
+			97
+		]
+	},
+	{
+		mediaType: "image/webp",
+		bytes: [
+			82,
+			73,
+			70,
+			70,
+			null,
+			null,
+			null,
+			null,
+			87,
+			69,
+			66,
+			80
+		]
+	}
+];
+/**
+* Detect an accepted image type from file bytes. Use this instead of a file
+* name or declared content type, which can be wrong.
+*/
+function detectImageMediaType(data) {
+	return IMAGE_SIGNATURES.find(({ bytes }) => data.length >= bytes.length && bytes.every((byte, index) => byte === null || data[index] === byte))?.mediaType;
+}
+/** Report whether a media type is a raster image accepted by vision models. */
+function isVisionImageMediaType(mediaType) {
+	const normalized = mediaType.split(";", 1)[0]?.trim().toLowerCase();
+	return normalized ? INPUT_IMAGE_TYPES.some((type) => type === normalized) : false;
+}
+export { sameActorIdentity as _, agentHistoryItemSchema as a, conversationTurnFailureReasonSchema as c, newConversationEventSchema as d, encodeHistoryPayload as f, instructionProvenanceFor as g, instructionActors as h, KNOWN_CONVERSATION_EVENT_TYPES as i, decodeStoredConversationEvent as l, contextProvenance as m, detectImageMediaType as n, conversationEventDataSchema as o, agentInstructionProvenance as p, isVisionImageMediaType as r, conversationTurnFailureCodeSchema as s, INPUT_IMAGE_TYPES as t, historyReplacementSchema as u, usageSchema as v };

package/dist/{message-NKSbbnA6.js → message-BpaWd8TT.js}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { dt as actorFromRun, ft as toolInvocationDestination } from "./agent-runner-DgNATN4D.js";
-import { P as PARENT_AGENT_TARGET, i as createAgentInvocationForMessage, j as AgentMessageTargetError, o as findChildAgentConversationId, s as getActiveAgentInvocationForConversation } from "./store-6EetVP-m.js";
-import { n as enqueueAgentMessageToParent } from "./result-B9e9ATOU.js";
-import { r as enqueueAgentInvocation } from "./work-DUQoNcqP.js";
+import { At as actorFromRun, jt as toolInvocationDestination } from "./agent-runner-CrDrPUtY.js";
+import { P as PARENT_AGENT_TARGET, i as createAgentInvocationForMessage, j as AgentMessageTargetError, o as findChildAgentConversationId, s as getActiveAgentInvocationForConversation } from "./store-1DVhoKOL.js";
+import { r as enqueueAgentMessageToParent } from "./result-BemsOMOO.js";
+import { r as enqueueAgentInvocation } from "./work-BE_qTYGi.js";
 // src/chat/agent-invocations/message.ts
 var message_exports = /* @__PURE__ */ __exportAll({ bindMessageAgent: () => bindMessageAgent });
 /**

package/dist/nitro.d.ts

@@ -1,4 +1,4 @@
-import { i as JuniorDashboardOptions } from "./app-DAB3fzyp.js";
+import { i as JuniorDashboardOptions } from "./app-BrMMzjYm.js";
 import { n as JuniorPluginSet } from "./plugins-B_0Cr0MO.js";
 import { withSentryConfig as withSentryConfig$1 } from "@sentry/nitro";
 type SentryNitroConfig = Parameters<typeof withSentryConfig$1>[0];

package/dist/nitro.js

@@ -1,8 +1,8 @@
-import { A as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, D as JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE, F as getDeploymentServiceVersion, M as JUNIOR_RETENTION_ROUTE, N as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, O as JUNIOR_HEARTBEAT_CRON_SCHEDULE, j as JUNIOR_RETENTION_CRON_SCHEDULE, k as JUNIOR_HEARTBEAT_ROUTE } from "./logging-DuZ1A4ab.js";
+import { A as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, D as JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE, F as getDeploymentServiceVersion, M as JUNIOR_RETENTION_ROUTE, N as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, O as JUNIOR_HEARTBEAT_CRON_SCHEDULE, j as JUNIOR_RETENTION_CRON_SCHEDULE, k as JUNIOR_HEARTBEAT_ROUTE } from "./logging-n7knse-O.js";
 import { d as resolvePackageDir, t as discoverInstalledPluginPackageContent, u as isValidPackageName } from "./package-discovery-DJBompdd.js";
-import { o as resolveConversationWorkQueueTopic, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-C0BZSa7r.js";
+import { o as resolveConversationWorkQueueTopic, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-DI-k-Bbk.js";
 import { a as pluginRuntimeRegistrationsFromPluginSet, r as pluginCatalogConfigFromPluginSet } from "./plugins-DOm9Y6qI.js";
-import { t as PLUGIN_TASK_QUEUE_TOPIC } from "./task-queue-B0DLgd2P.js";
+import { t as PLUGIN_TASK_QUEUE_TOPIC } from "./task-queue-HMC4QjFm.js";
 import { n as loadPluginSetFromModule, r as resolvePluginModule } from "./plugin-module-Cf5gVPWP.js";
 import path from "node:path";
 import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";

package/dist/{oauth-callback-server-qAHLPtml.js → oauth-callback-server-CpGmEw_i.js}

@@ -1,5 +1,5 @@
-import { n as createUserTokenStore } from "./credentialed-CIGwoLU2.js";
-import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-DhEGEpgq.js";
+import { n as createUserTokenStore } from "./credentialed-BU-OW7HP.js";
+import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-CS_6IC-f.js";
 import { createServer } from "node:http";
 // src/chat/local/oauth-callback-server.ts
 const LOCAL_OAUTH_TIMEOUT_MS = 6e5;

package/dist/{prompt-BW9jFsqZ.js → prompt-BlQB0QQt.js}

@@ -1,4 +1,4 @@
-import { Q as parseBriefInput, X as briefOutcomeStatusSchema, Z as conversationBriefSchema } from "./conversation-DSo310Ps.js";
+import { J as conversationBriefSchema, Y as parseBriefInput, q as briefOutcomeStatusSchema } from "./conversation-CTpD_PGk.js";
 import { z } from "zod";
 // src/chat/briefs/generate.ts
 const MAX_INPUT_CHARS = 6e4;

package/dist/{registry-FQutO926.js → registry-By36_xsm.js}

@@ -1,5 +1,5 @@
-import { b as setSpanAttributes, h as logWarn, m as logInfo } from "./logging-DuZ1A4ab.js";
-import { a as isUserActor, o as parseActorUserId } from "./actor-DZSokpwj.js";
+import { b as setSpanAttributes, h as logWarn, m as logInfo } from "./logging-n7knse-O.js";
+import { o as isUserActor, s as parseActorUserId } from "./actor-CP9K2Idu.js";
 import { n as normalizePluginPackageNames, o as pluginRoots, t as discoverInstalledPluginPackageContent } from "./package-discovery-DJBompdd.js";
 import path from "node:path";
 import { z } from "zod";

package/dist/reporting-schema-CZREhYc-.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+// src/reporting-schema.ts
+const healthReportSchema = z.object({
+	status: z.literal("ok"),
+	service: z.string(),
+	timestamp: z.string()
+}).strict();
+const pluginSchema = z.object({
+	configKeys: z.array(z.string()),
+	description: z.string(),
+	displayName: z.string(),
+	name: z.string()
+}).strict();
+const pluginsSchema = z.array(pluginSchema);
+const skillReportSchema = z.object({
+	name: z.string(),
+	pluginProvider: z.string().optional()
+}).strict();
+const skillReportsSchema = z.array(skillReportSchema);
+const pluginPackageContentItemReportSchema = z.object({
+	dir: z.string(),
+	hasMigrationsDir: z.boolean(),
+	hasSkillsDir: z.boolean(),
+	packageName: z.string()
+}).strict();
+const pluginPackageContentReportSchema = z.object({
+	packageNames: z.array(z.string()),
+	packages: z.array(pluginPackageContentItemReportSchema),
+	manifestRoots: z.array(z.string()),
+	skillRoots: z.array(z.string()),
+	tracingIncludes: z.array(z.string())
+}).strict();
+const runtimeInfoReportSchema = z.object({
+	cwd: z.string(),
+	homeDir: z.string(),
+	descriptionText: z.string().optional(),
+	providers: z.array(z.string()),
+	skills: z.array(skillReportSchema),
+	packagedContent: pluginPackageContentReportSchema
+}).strict();
+const pluginOperationalToneSchema = z.enum([
+	"danger",
+	"good",
+	"neutral",
+	"warning"
+]);
+const pluginOperationalMetricSchema = z.object({
+	label: z.string(),
+	tone: pluginOperationalToneSchema.optional(),
+	value: z.string()
+}).strict();
+const pluginOperationalFieldSchema = z.object({
+	key: z.string(),
+	label: z.string()
+}).strict();
+const pluginOperationalRecordSchema = z.object({
+	id: z.string(),
+	tone: pluginOperationalToneSchema.optional(),
+	values: z.record(z.string(), z.string())
+}).strict();
+const pluginOperationalRecordSetSchema = z.object({
+	fields: z.array(pluginOperationalFieldSchema).optional(),
+	emptyText: z.string().optional(),
+	records: z.array(pluginOperationalRecordSchema).optional(),
+	title: z.string()
+}).strict();
+const pluginOperationalBarChartWidgetSchema = z.object({
+	categories: z.array(z.object({
+		id: z.string().min(1),
+		label: z.string().min(1),
+		values: z.record(z.string(), z.number().finite())
+	}).strict()).max(100),
+	description: z.string().optional(),
+	emptyText: z.string().optional(),
+	id: z.string().min(1),
+	series: z.array(z.object({
+		format: z.literal("usd").optional(),
+		key: z.string().min(1),
+		label: z.string().min(1),
+		tone: pluginOperationalToneSchema.optional()
+	}).strict()).min(1).max(8),
+	timeRangeDays: z.array(z.union([
+		z.literal(1),
+		z.literal(7),
+		z.literal(30),
+		z.literal(90)
+	])).min(1).max(4).optional(),
+	title: z.string().min(1),
+	type: z.literal("bar_chart")
+}).strict();
+const pluginOperationalReportSchema = z.object({
+	generatedAt: z.string().optional(),
+	metrics: z.array(pluginOperationalMetricSchema).optional(),
+	recordSets: z.array(pluginOperationalRecordSetSchema).optional(),
+	title: z.string().optional(),
+	pluginName: z.string(),
+	widgets: z.array(pluginOperationalBarChartWidgetSchema).max(12).optional()
+}).strict();
+const pluginOperationalReportFeedSchema = z.object({
+	generatedAt: z.string(),
+	reports: z.array(pluginOperationalReportSchema),
+	source: z.literal("plugins")
+}).strict();
+export { pluginPackageContentReportSchema as a, runtimeInfoReportSchema as c, pluginPackageContentItemReportSchema as i, skillReportSchema as l, pluginOperationalReportFeedSchema as n, pluginSchema as o, pluginOperationalReportSchema as r, pluginsSchema as s, healthReportSchema as t, skillReportsSchema as u };

package/dist/reporting-window-CVarfId9.js

@@ -0,0 +1,255 @@
+import { z } from "zod";
+// src/api/schema/user-customization.ts
+/** Longest customization text one user can save. */
+const USER_CUSTOMIZATION_MAX_CHARS = 1e3;
+/** Saved customization text. An empty string means none. */
+const userCustomizationTextSchema = z.string().trim().max(USER_CUSTOMIZATION_MAX_CHARS);
+/** Request and response body for the viewer's customization. */
+const userCustomizationSchema = z.object({ customization: userCustomizationTextSchema }).strict();
+// src/chat/conversations/web-message-id.ts
+/**
+* Build the retry-stable Message id shared by web ingress and browser sends.
+* Keep the existing hash and prefix so retries still address stored Messages.
+*/
+async function webMessageId(args) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${args.conversationId}\u0000${args.idempotencyKey}`));
+	return `api-msg:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 24)}`;
+}
+// src/chat/tools/runtime/user-input-request.ts
+const USER_INPUT_LIMITS = {
+	maxButtonOptions: 5,
+	maxDescriptionChars: 200,
+	maxFields: 4,
+	maxLabelChars: 75,
+	maxOptions: 10,
+	maxTextChars: 3e3,
+	maxQuestionChars: 3e3,
+	minOptions: 2
+};
+const labelSchema = z.string().trim().min(1).max(USER_INPUT_LIMITS.maxLabelChars);
+const descriptionSchema = z.string().trim().min(1).max(USER_INPUT_LIMITS.maxDescriptionChars).optional();
+const optionSchema = z.object({
+	label: labelSchema.describe("Short choice text, such as `Accept` or `Decline`. The answer uses this exact text."),
+	description: descriptionSchema.describe("Optional short note about what this choice does.")
+});
+const fieldBase = {
+	id: z.string().regex(/^[a-z][a-z0-9_]{0,31}$/).describe("Stable key for this field, such as `approach`."),
+	label: labelSchema.describe("Short field name, such as `Approach`."),
+	description: descriptionSchema.describe("Optional short help text for this field.")
+};
+const optionsSchema = z.array(optionSchema).min(USER_INPUT_LIMITS.minOptions).max(USER_INPUT_LIMITS.maxOptions).describe("Choices in display order.");
+const userInputFieldSchema = z.discriminatedUnion("kind", [
+	z.object({
+		...fieldBase,
+		kind: z.literal("choice").describe("The person picks one option."),
+		options: optionsSchema
+	}),
+	z.object({
+		...fieldBase,
+		kind: z.literal("multi_choice").describe("The person picks any number of options."),
+		options: optionsSchema
+	}),
+	z.object({
+		...fieldBase,
+		kind: z.literal("text").describe("The person types a short answer.")
+	})
+]);
+const userInputRequestSchema = z.object({
+	question: z.string().trim().min(1).max(USER_INPUT_LIMITS.maxQuestionChars).describe("The question, in markdown. Include the facts the person needs to decide."),
+	fields: z.array(userInputFieldSchema).min(1).max(USER_INPUT_LIMITS.maxFields).describe("What to ask, in display order. Use one `choice` field for a simple decision.")
+}).superRefine((request, context) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const field of request.fields) {
+		if (ids.has(field.id)) context.addIssue({
+			code: "custom",
+			message: "Each field needs a different id."
+		});
+		ids.add(field.id);
+		if (field.kind === "text") continue;
+		const labels = field.options.map((option) => option.label.toLowerCase());
+		if (new Set(labels).size !== labels.length) context.addIssue({
+			code: "custom",
+			message: "Each choice of a field needs a different label."
+		});
+	}
+});
+/**
+* Return the single choice field of a request that a surface can show as
+* one row of buttons, where one click is the whole answer.
+*/
+function buttonUserInputField(request) {
+	const [field, ...rest] = request.fields;
+	if (rest.length || field?.kind !== "choice") return void 0;
+	return field.options.length <= USER_INPUT_LIMITS.maxButtonOptions ? field : void 0;
+}
+/**
+* Keep only answer values that match the request: known field ids, known
+* option labels, one value for a `choice` field, and trimmed text.
+*/
+function normalizeUserInputAnswer(request, answer) {
+	const values = {};
+	for (const field of request.fields) {
+		const raw = (answer.values[field.id] ?? []).map((value) => value.trim()).filter(Boolean);
+		if (field.kind === "text") {
+			const text = raw.join("\n").slice(0, USER_INPUT_LIMITS.maxTextChars);
+			if (text) values[field.id] = [text];
+			continue;
+		}
+		const picked = field.options.map((option) => option.label).filter((label) => raw.includes(label));
+		const kept = field.kind === "choice" ? picked.slice(0, 1) : picked;
+		if (kept.length) values[field.id] = kept;
+	}
+	const other = answer.other?.trim().slice(0, USER_INPUT_LIMITS.maxTextChars);
+	return {
+		requestId: answer.requestId,
+		values,
+		...other ? { other } : void 0
+	};
+}
+/** Return true when an answer has no value and no free text. */
+function isEmptyUserInputAnswer(answer) {
+	return !answer.other && Object.keys(answer.values).length === 0;
+}
+function answerLine(text) {
+	return text.split("\n").map((line) => line.trim()).filter(Boolean).join("\n");
+}
+/**
+* Write an answer as the text of the person's message. Slack and the web
+* dashboard both send this text, so the model reads one format. The first
+* line names the request, and each field starts its own line.
+*/
+function formatUserInputAnswer(request, answer) {
+	const normalized = normalizeUserInputAnswer(request, answer);
+	const lines = [`Answer to request ${normalized.requestId}:`];
+	for (const field of request.fields) {
+		const values = normalized.values[field.id];
+		const value = values?.length ? values.join(", ") : "(no answer)";
+		lines.push(answerLine(`${field.label} (${field.id}): ${value}`));
+	}
+	if (normalized.other) lines.push(answerLine(`Other: ${normalized.other}`));
+	return lines.join("\n");
+}
+// src/api/reporting-window.ts
+/** Shared UTC day/hour/six-hour windows for dashboard activity series. */
+const HOUR_MS = 36e5;
+const SIX_HOUR_MS = 6 * HOUR_MS;
+const DAY_MS = 24 * HOUR_MS;
+/** Start of the UTC calendar day containing `valueMs`. */
+function startOfUtcDay(valueMs) {
+	const date = new Date(valueMs);
+	date.setUTCHours(0, 0, 0, 0);
+	return date;
+}
+/** Start of the UTC hour containing `valueMs`. */
+function startOfUtcHour(valueMs) {
+	const date = new Date(valueMs);
+	date.setUTCMinutes(0, 0, 0);
+	return date;
+}
+/** Start of the UTC 6-hour bucket containing `valueMs` (00/06/12/18). */
+function startOfUtcSixHour(valueMs) {
+	const date = startOfUtcHour(valueMs);
+	date.setUTCHours(Math.floor(date.getUTCHours() / 6) * 6, 0, 0, 0);
+	return date;
+}
+/** UTC day key `YYYY-MM-DD`. */
+function utcDayKey(value) {
+	return (typeof value === "number" ? new Date(value) : value).toISOString().slice(0, 10);
+}
+/** UTC hour key `YYYY-MM-DDTHH`. */
+function utcHourKey(value) {
+	return (typeof value === "number" ? new Date(value) : value).toISOString().slice(0, 13);
+}
+/** UTC 6-hour bucket key `YYYY-MM-DDTHH` at 00/06/12/18. */
+function utcSixHourKey(value) {
+	return utcHourKey(startOfUtcSixHour(typeof value === "number" ? value : value.getTime()));
+}
+/** Inclusive trailing UTC day window ending on today's UTC day. */
+function trailingUtcDayWindow(nowMs, dayCount) {
+	const end = startOfUtcDay(nowMs);
+	const start = new Date(end);
+	start.setUTCDate(start.getUTCDate() - (dayCount - 1));
+	return {
+		end,
+		start
+	};
+}
+/** Inclusive trailing UTC hour window ending on the current UTC hour. */
+function trailingUtcHourWindow(nowMs, hourCount = 24) {
+	const end = startOfUtcHour(nowMs);
+	return {
+		end,
+		start: /* @__PURE__ */ new Date(end.getTime() - (hourCount - 1) * HOUR_MS)
+	};
+}
+/** Inclusive trailing UTC 6-hour window ending on the current 6h bucket. */
+function trailingUtcSixHourWindow(nowMs, bucketCount = 28) {
+	const end = startOfUtcSixHour(nowMs);
+	return {
+		end,
+		start: /* @__PURE__ */ new Date(end.getTime() - (bucketCount - 1) * SIX_HOUR_MS)
+	};
+}
+/** Fill a fixed UTC day window from a sparse map. */
+function fillUtcDays(args) {
+	const { end, start } = trailingUtcDayWindow(args.nowMs, args.count);
+	const items = [];
+	for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+		const date = utcDayKey(cursor);
+		items.push(args.rows.get(date) ?? args.empty(date));
+	}
+	return items;
+}
+/** Fill a fixed UTC hour window from a sparse map. */
+function fillUtcHours(args) {
+	const hourCount = args.count ?? 24;
+	const { end, start } = trailingUtcHourWindow(args.nowMs, hourCount);
+	const items = [];
+	for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setTime(cursor.getTime() + HOUR_MS)) {
+		const date = utcHourKey(cursor);
+		items.push(args.rows.get(date) ?? args.empty(date));
+	}
+	return items;
+}
+/** Fill a fixed UTC 6-hour window from a map of known rows. */
+function fillUtcSixHours(args) {
+	const bucketCount = args.count ?? 28;
+	const { end, start } = trailingUtcSixHourWindow(args.nowMs, bucketCount);
+	const items = [];
+	for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setTime(cursor.getTime() + SIX_HOUR_MS)) {
+		const date = utcSixHourKey(cursor);
+		items.push(args.rows.get(date) ?? args.empty(date));
+	}
+	return items;
+}
+/**
+* Sum hour rows into trailing 6-hour buckets.
+* Adds number fields. Keeps other fields from the first row in the bucket.
+* Sets `date` to the 6-hour bucket key.
+*/
+function sumUtcHoursIntoSixHours(args) {
+	const bucketCount = args.count ?? 28;
+	const bySix = /* @__PURE__ */ new Map();
+	for (const hour of args.hours) {
+		const key = utcSixHourKey(Date.parse(`${hour.date}:00:00.000Z`));
+		const next = {
+			...bySix.get(key) ?? args.empty(key),
+			date: key
+		};
+		for (const [field, value] of Object.entries(hour)) {
+			if (field === "date") continue;
+			if (typeof value === "number") {
+				const prior = next[field];
+				next[field] = (typeof prior === "number" ? prior : 0) + value;
+			}
+		}
+		bySix.set(key, next);
+	}
+	return fillUtcSixHours({
+		count: bucketCount,
+		empty: args.empty,
+		nowMs: args.nowMs,
+		rows: bySix
+	});
+}
+export { userCustomizationTextSchema as S, normalizeUserInputAnswer as _, fillUtcSixHours as a, USER_CUSTOMIZATION_MAX_CHARS as b, trailingUtcDayWindow as c, utcDayKey as d, utcHourKey as f, isEmptyUserInputAnswer as g, formatUserInputAnswer as h, fillUtcHours as i, trailingUtcHourWindow as l, buttonUserInputField as m, HOUR_MS as n, startOfUtcHour as o, USER_INPUT_LIMITS as p, fillUtcDays as r, sumUtcHoursIntoSixHours as s, DAY_MS as t, trailingUtcSixHourWindow as u, userInputRequestSchema as v, userCustomizationSchema as x, webMessageId as y };

package/dist/{resolve-Bk4yeuHy.js → resolve-CUIBcdPd.js}

@@ -1,6 +1,6 @@
-import { E as withSpan, b as setSpanAttributes } from "./logging-DuZ1A4ab.js";
-import { En as SANDBOX_WORKSPACE_ROOT, F as getSandboxProvider, N as isStale, bn as runNonInteractiveCommand, cn as sleep, j as create, xn as SANDBOX_COMMAND_PATH } from "./credentialed-CIGwoLU2.js";
-import { i as getStateAdapter } from "./adapter-BybMEezj.js";
+import { E as withSpan, b as setSpanAttributes } from "./logging-n7knse-O.js";
+import { Kn as runNonInteractiveCommand, Nn as sleep, Qn as SANDBOX_WORKSPACE_ROOT, it as isStale, nt as create, ot as getSandboxProvider, qn as SANDBOX_COMMAND_PATH } from "./credentialed-BU-OW7HP.js";
+import { r as getStateAdapter } from "./adapter-2-CG25be.js";
 import { z } from "zod";
 // src/chat/sandbox/resources.ts
 let configuredResources;