one-code-extension 0.5.0 → 0.6.0

package/extensions/system-reminder/index.ts

@@ -1,230 +1,202 @@
 /**
- * system-reminder extension — injects queued <system-reminder> blocks into the
- * outgoing LLM request (pi `context` event), and writes one-shots into the tool
- * result they follow (pi `tool_result` event) so they persist in the session
- * the way Claude Code's mid-turn reminders do. Context and sticky anchors are
- * restored from hidden custom entries; rendered messages stay untouched. This extension owns
- * the one queue instance; every other extension reaches it over
- * `one-code:system-reminder` (lib/reminders.ts has the placement contract).
+ * system-reminder extension, the renderer of the record-once request path
+ * (lib/reminders.ts has the placement contract, extensions/ledger the design).
+ * It owns the live reminder state every other extension feeds over
+ * `one-code:system-reminder`: the `first-prepend` stack and the open sticky
+ * states. A one-shot is persisted when emitted, as a `one-code:pending` entry,
+ * and delivered from the ledger's outbox.
+ *
+ * Its `context` hook runs right after the ledger's, which has cut the request
+ * to its tail and published the plan. It renders onto that tail only: the
+ * stack when the request opens an epoch, the sticky states, the pending
+ * one-shots, and the blocks capability owners add on RENDER_CHANNEL (live
+ * minus what the epoch told). It writes into the plan which pending items the
+ * request carries and what its new blocks tell, and the ledger records both
+ * with the request. Nothing is snapshotted or restored: everything above the
+ * tail is the record.
  *
  * On a model that takes a mid-conversation system message (lib/system-role.ts),
- * its `before_provider_request` hook then lifts the session-fact blocks off the
- * first user message into one system message after it, Claude Code's layout.
- * It loads before tool-search and compaction, so replays and forks inherit it.
+ * its `before_provider_request` hook lifts the stack's session-fact blocks off
+ * the first user message into one system message after it (an epoch's request
+ * only), and shapes the tail's `<total_tokens>` lines (lib/turn-budget-layout.ts).
  */
 
+import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { CLEAR_AT_BETA, MID_CONVERSATION_SYSTEM_BETA, reseatMessageMark, withBetas } from "../lib/anthropic-payload.ts";
-import {
-	appendReminderBlocks,
-	framedReminderText,
-	injectReminders,
-	movesToSystemRole,
-	openingUserAnchor,
-	REMINDER_CHANNEL,
-	ReminderQueue,
-	type ReminderEntry,
-	type ReminderPayload,
-	tailAnchor,
-} from "../lib/reminders.ts";
-import {
-	CONTEXT_BASELINE_CHANNEL, CONTEXT_RESTORE_CHANNEL, CONTEXT_STACK_ENTRY, CONTEXT_STATE_ENTRY, CONTEXT_FACTS_REFRESH_CHANNEL,
-	contextStackOnBranch, RESTORED_STACK_KEYS, LIVE_CONTEXT_KEYS,
-	type ContextBaseline, type ContextRestoreRequest, type ContextStackSnapshot, type ContextFactsRefresh,
-} from "../lib/context-stack.ts";
-import { CONTEXT_FACT_KEYS, DATE_CHANGE_KEY, RESUME_FACTS_KEY } from "../lib/context-facts.ts";
-import { claudeFamily } from "../lib/model-tier.ts";
 import { emptyToolResultContent } from "../lib/empty-tool-result.ts";
+import { foldBranch } from "../lib/ledger/fold.ts";
+import { LEDGER_PLAN_CHANNEL, type RequestPlan } from "../lib/ledger/plan.ts";
+import { type EntryLike, makeRecord, type PendingRecordData, RECORD, stateOnBranch } from "../lib/ledger/records.ts";
+import { recordState } from "../lib/ledger/state.ts";
+import { contentHash } from "../lib/ledger/wire.ts";
+import { claudeFamily } from "../lib/model-tier.ts";
+import { extensionVersion } from "../lib/package-version.ts";
+import { LiveReminders, type OneShot, REMINDER_CHANNEL, RENDER_CHANNEL, type RenderRequest, renderReminders, type ReminderPayload, stickyFact } from "../lib/reminders.ts";
+import { sessionAlive } from "../lib/session-lifecycle.ts";
 import { instructionRole, messagesKey, type MovedBlock, systemRoleLayout, wireShape, withSystemRoleContext } from "../lib/system-role.ts";
 import { resolveCountdowns, withTurnBudgetMessages } from "../lib/turn-budget-layout.ts";
 
-/**
- * Roles a reminder can be attached to (see injectReminders). `custom` is a
- * harness message (a task notification, a wakeup, hook context) that pi sends
- * to the model as a user message; a turn opened by one has no `user` message
- * of its own, so without it the model got no reminder stack at all
- * (STEERING-REVIEW-2026-09-05 H1).
- */
-const ANCHOR_ROLES = new Set(["user", "toolResult", "compactionSummary", "custom"]);
+/** Whether requests carry the `<total_tokens>` budget lines (`CC_TOTAL_TOKENS=0` turns them off). */
+const budgetMarkers = () => process.env.CC_TOTAL_TOKENS !== "0";
+
+/** A pending entry as a one-shot to place. */
+function oneShotOf(item: PendingRecordData): OneShot {
+	return {
+		id: item.id,
+		text: item.text,
+		placement: item.placement ?? "last-append",
+		...(item.raw ? { raw: true } : {}),
+		...(item.toolCallId ? { toolCallId: item.toolCallId } : {}),
+		...(item.promptTimestamp !== undefined ? { promptTimestamp: item.promptTimestamp } : {}),
+		...(item.once ? { once: true } : {}),
+		...(item.orTail ? { orTail: true } : {}),
+	};
+}
+
+/** The `one-code:state` key prefix of a sticky state's recorded start. */
+const STICKY_START_PREFIX = "sticky-start:";
 
 export default function systemReminderExtension(pi: ExtensionAPI) {
-	const reminderQueue = new ReminderQueue();
-	let restored: ContextStackSnapshot | undefined;
-	let stored = false;
-	let baselines: Record<string, unknown> = {};
-	let lastState = "";
-	let lastStack = "";
-	pi.events.on(CONTEXT_RESTORE_CHANNEL, (data) => {
-		if (data && restored) (data as ContextRestoreRequest).restored = structuredClone(restored);
-	});
-	pi.events.on(CONTEXT_BASELINE_CHANNEL, (data) => {
-		const baseline = data as ContextBaseline | undefined;
-		if (typeof baseline?.key === "string") {
-			baselines[baseline.key] = structuredClone(baseline.value);
-			baselineChanges++;
-		}
-	});
-	pi.on("session_start", (_event, ctx) => {
-		restored = contextStackOnBranch(ctx.sessionManager.getBranch());
-		stored = restored !== undefined;
-		baselines = restored ? structuredClone(restored.baselines) : {};
-		lastState = restored ? JSON.stringify({ version: 1, sticky: restored.sticky, pinned: restored.pinned ?? [], baselines }) : "";
-		lastStack = restored ? JSON.stringify(restored.stack) : "";
-		comparedQueue = -1;
-		if (restored) reminderQueue.restore(restored.stack, restored.sticky, RESTORED_STACK_KEYS, LIVE_CONTEXT_KEYS, restored.pinned);
-		else reminderQueue.releaseRestore();
-	});
-	// A /tree switch fires only session_tree (findings §3). The selected branch's
-	// messages were sent with its own facts, sticky blocks and pins: take them
-	// from its last snapshot, as a resume would, while live state and every
-	// emitter's baseline stay current (claude-context republishes its own).
-	pi.on("session_tree", (_event, ctx) => {
-		const branch = contextStackOnBranch(ctx.sessionManager.getBranch());
-		stored = branch !== undefined;
-		lastState = branch ? JSON.stringify({ version: 1, sticky: branch.sticky, pinned: branch.pinned ?? [], baselines: branch.baselines }) : "";
-		lastStack = branch ? JSON.stringify(branch.stack) : "";
-		comparedQueue = -1;
-		if (branch) reminderQueue.restoreBranch(branch, CONTEXT_FACT_KEYS);
-	});
+	const alive = sessionAlive(pi);
+	const by = extensionVersion();
+	const live = new LiveReminders();
+	/** The plan the ledger published for the request being rendered. */
+	let plan: RequestPlan | undefined;
+	/** One-shots emitted before the session started (an extension's load): persisted at session_start. */
+	let early: ReminderPayload[] | undefined = [];
+	/** Without the ledger (a test harness, a session that does not load it): the pending ids this instance delivered. */
+	const deliveredHere = new Set<string>();
+
+	const persist = (payload: ReminderPayload) => {
+		const data = makeRecord("pending", by, {
+			id: randomUUID(),
+			text: payload.text as string,
+			placement: payload.placement === "user-prepend" ? "user-prepend" : "last-append",
+			...(payload.key ? { key: payload.key } : {}),
+			...(payload.raw ? { raw: true } : {}),
+			...(payload.toolCallId ? { toolCallId: payload.toolCallId } : {}),
+			...(payload.promptTimestamp !== undefined ? { promptTimestamp: payload.promptTimestamp } : {}),
+			...(payload.once ? { once: true } : {}),
+			...(payload.orTail ? { orTail: true } : {}),
+			...(payload.untilCompaction ? { untilCompaction: true } : {}),
+			...(payload.observations?.length ? { observations: payload.observations } : {}),
+			...(payload.notified?.length ? { notified: payload.notified } : {}),
+		});
+		pi.appendEntry(RECORD.pending, data);
+	};
+
+	/** The session's branch: the sticky states' starts it recorded. */
+	let branchOf: (() => EntryLike[]) | undefined;
 	/**
-	 * The queue version and baseline count the last comparison saw, or -1 when
-	 * it must run again. A stack taken before a drain that changed the queue
-	 * may not be the stack the queue holds after it, so that sets -1 too.
+	 * When each sticky state started, as the branch recorded it. An owner that
+	 * runs again (a resume, /reload, /tree) emits its state without a start, so
+	 * the renderer takes the branch's start for the same key and text: an epoch
+	 * that renders the conversation again (a model switch) then places the block
+	 * where the original requests did, and its first delivery stays told. A
+	 * removal records the run's end (null), so nothing carries past it.
 	 */
-	let comparedQueue = -1;
-	let comparedBaselines = -1;
-	let baselineChanges = 0;
-	/** `capturedAt`: the queue version when `stack` was taken. Unchanged since the last comparison, the snapshot is too. */
-	const persistSnapshot = (stack: ReminderEntry[] = reminderQueue.persistentEntries("first-prepend"), capturedAt = reminderQueue.version) => {
-		const version = reminderQueue.version;
-		if (stored && capturedAt === version && version === comparedQueue && baselineChanges === comparedBaselines) return;
-		comparedQueue = capturedAt === version ? version : -1;
-		comparedBaselines = baselineChanges;
-		const state = { version: 1 as const, sticky: reminderQueue.persistentEntries("sticky-append"), pinned: reminderQueue.persistentPins(), baselines };
-		const serialized = JSON.stringify(state);
-		const serializedStack = JSON.stringify(stack);
-		if (!stored) {
-			pi.appendEntry(CONTEXT_STACK_ENTRY, structuredClone({ ...state, stack }));
-			stored = true;
-		} else if (serialized !== lastState || serializedStack !== lastStack) {
-			// Compaction and explicit capability switches start a new prefix.
-			pi.appendEntry(CONTEXT_STATE_ENTRY, structuredClone({ ...state, ...(serializedStack !== lastStack ? { stack } : {}) }));
-		}
-		lastState = serialized;
-		lastStack = serializedStack;
+	const stickyStart = (key: string): { since: number; hash: string } | undefined => {
+		const stored = branchOf ? (stateOnBranch(branchOf(), `${STICKY_START_PREFIX}${key}`) as { since?: unknown; hash?: unknown } | undefined) : undefined;
+		return typeof stored?.since === "number" && typeof stored.hash === "string" ? { since: stored.since, hash: stored.hash } : undefined;
 	};
-	pi.events.on(CONTEXT_FACTS_REFRESH_CHANNEL, (data) => {
-		const refresh = data as ContextFactsRefresh;
-		reminderQueue.replaceFirstPrepend(CONTEXT_FACT_KEYS, refresh.entries);
-		reminderQueue.cancelPending([DATE_CHANGE_KEY, RESUME_FACTS_KEY]);
-		baselines["claude-context"] = structuredClone(refresh.baseline);
-		baselineChanges++;
-		// /compact may be the last action before exit. Persist now, not just on
-		// the next request, so a resume cannot revive the pre-compaction facts.
-		persistSnapshot();
-	});
-	/** The blocks the last `context` pass placed for the system message; the payload hook moves them. */
-	let moved: MovedBlock[] = [];
-	/** The tool results' countdowns the last `context` pass lifted, by call id (lib/turn-budget-layout.ts). */
-	let countdowns = new Map<string, number>();
 
 	pi.events.on(REMINDER_CHANNEL, (data) => {
-		const payload = data as ReminderPayload;
+		let payload = data as ReminderPayload | undefined;
 		if (!payload) return;
-		if (payload.remove && payload.key) {
-			reminderQueue.remove(payload.key);
-		} else if (typeof payload.text === "string") {
-			reminderQueue.enqueue(payload.text, {
-				scope: payload.scope,
-				key: payload.key,
-				placement: payload.placement,
-				order: payload.order,
-				suffix: payload.suffix,
-				raw: payload.raw,
-				systemRoleOnly: payload.systemRoleOnly,
-				skipStackCarrier: payload.skipStackCarrier,
-				since: payload.since,
-				once: payload.once,
-				toolCallId: payload.toolCallId,
-			});
+		const sticky = payload.placement === "sticky-append" && !payload.remove && typeof payload.text === "string";
+		const key = payload.key ?? payload.text ?? "";
+		const recorded = sticky ? stickyStart(key) : undefined;
+		if (sticky && payload.since === undefined && recorded?.hash === contentHash(payload.text)) payload = { ...payload, since: recorded.since };
+		// A removal ends the state's run: switched on again, even with the same
+		// text, it is a new state that rides the switching call's result, not the
+		// old run's start, whose first delivery the branch already told.
+		if (payload.remove && payload.key && branchOf && alive() && stickyStart(payload.key)) recordState(pi, `${STICKY_START_PREFIX}${payload.key}`, null);
+		const applied = live.apply(payload);
+		if (sticky && applied === "live" && branchOf && alive()) {
+			const entry = live.stickyEntries().find((state) => state.key === key);
+			const hash = entry ? contentHash(entry.text) : undefined;
+			if (entry && entry.since > 0 && (recorded?.since !== entry.since || recorded?.hash !== hash)) recordState(pi, `${STICKY_START_PREFIX}${key}`, { since: entry.since, hash });
 		}
+		if (applied !== "one-shot") return;
+		if (early) early.push(payload);
+		else if (alive()) persist(payload);
+	});
+	pi.on("session_start", (_event, ctx) => {
+		const sessionManager = ctx?.sessionManager;
+		branchOf = sessionManager ? () => sessionManager.getBranch() as EntryLike[] : undefined;
+		const queued = early ?? [];
+		early = undefined;
+		for (const payload of queued) persist(payload);
+	});
+	pi.events.on(LEDGER_PLAN_CHANNEL, (data) => {
+		plan = data as RequestPlan;
 	});
 
-	// A one-shot pending when a tool result is stored goes INTO that result: the
-	// model reads it right there, the session file keeps it, and no later request
-	// re-caches the message (a transient block would vanish on the next request
-	// and cost the result and everything after it). Runs before the hooks
-	// extension's PostToolUse in load order, so a hook that replaces the whole
-	// result would drop these appended blocks — the hooks extension re-attaches
-	// the trailing reminder run when it applies a replacement (review M3,
-	// applyPostToolUseOutcome / isAppendedReminderText).
+	// A tool's empty result is normalized before anything else reads it. Read's
+	// raw bytes stay for file-tracker's empty-file warning.
 	pi.on("tool_result", (event) => {
-		// Normalize the tool's result before reminders make an empty result look
-		// nonempty. Read's raw bytes stay for file-tracker's empty-file warning.
 		const replacement = emptyToolResultContent(event.content, event.toolName);
-		const entries = reminderQueue.hasPendingOneShots ? reminderQueue.takeOneShots(event.toolCallId) : [];
-		if (!replacement && entries.length === 0) return;
-		const content = replacement ?? event.content;
-		return {
-			content: entries.length ? appendReminderBlocks(content, entries) : content,
-			...(event.structuredContent !== undefined ? { structuredContent: event.structuredContent } : {}),
-		};
+		if (!replacement) return;
+		return { content: replacement, ...(event.structuredContent !== undefined ? { structuredContent: event.structuredContent } : {}) };
 	});
 
-	/** The request's messages with the queued reminders placed, or the input when nothing can be placed. */
-	const withReminders = (messages: Parameters<typeof injectReminders>[0], layout: ReturnType<typeof systemRoleLayout>) => {
-		if (reminderQueue.size === 0 && !stored) return messages;
-		// injectReminders is a no-op when there is nothing to attach to. Only
-		// consume the queue once there is somewhere to put the reminders, so they
-		// survive to the next eligible request.
-		if (!messages.some((m) => ANCHOR_ROLES.has(m.role))) return messages;
-		// A one-shot that arrived after the last tool result was stored (a mode
-		// change while idle, a deferred-tool miss whose call had no tool_result
-		// hook) rides this request's tail — and stays pinned there afterwards.
-		if (reminderQueue.hasPendingOneShots) {
-			const anchor = tailAnchor(messages);
-			if (anchor) reminderQueue.pin(anchor, "last-append", messages);
-		}
-		// A local-command breadcrumb rides the prompt that opens a request, before
-		// the user's text (Claude Code's placement), and stays there. Mid-turn —
-		// the request ends in a tool result — it waits for the next prompt.
-		if (reminderQueue.hasPending("user-prepend")) {
-			const anchor = openingUserAnchor(messages);
-			if (anchor) reminderQueue.pin(anchor, "user-prepend");
-		}
-		// Capture first-prepend before draining (one may be next-turn), then save
-		// after drain resolves sticky anchors. Store logical entries before layout,
-		// including systemRoleOnly blocks even on a model that cannot carry them.
-		reminderQueue.finishRestore();
-		const capturedAt = reminderQueue.version;
-		const stack = reminderQueue.persistentEntries("first-prepend");
-		const drained = reminderQueue.drain(messages);
-		persistSnapshot(stack, capturedAt);
-		// A block meant only for the system message is left out where there is none.
-		const reminders = drained.filter((entry) => layout || !entry.systemRoleOnly);
-		if (layout) {
-			moved = reminders
-				.filter((entry) => entry.placement === "first-prepend" && movesToSystemRole(entry.order))
-				.sort((a, b) => a.order - b.order)
-				.map((entry) => ({ framed: framedReminderText(entry), inner: entry.text }));
-		}
-		return injectReminders(messages, reminders);
-	};
+	/** The stack blocks the last `context` pass placed for the system message; the payload hook moves them. */
+	let moved: MovedBlock[] = [];
+	/** Whether the last `context` pass rendered an epoch: only then does the first user message carry the stack. */
+	let epochRequest = true;
+	/** The tool results' countdowns the last `context` pass lifted, by call id (lib/turn-budget-layout.ts). */
+	let countdowns = new Map<string, number>();
 
 	pi.on("context", (event, ctx) => {
-		moved = [];
-		countdowns = new Map();
+		const current = plan;
+		plan = undefined;
 		const layout = systemRoleLayout(ctx.model);
-		const messages = withReminders(event.messages, layout);
-		// Each tool result's stored <total_tokens> countdown, on every request so
-		// the layout never depends on the queue: lifted for a system message or
-		// framed, while the result's blocks are still separate (lib/turn-budget-layout.ts).
+		const epoch = current?.epoch ?? true;
+		const fold = current?.fold ?? foldBranch(ctx.sessionManager.getBranch() as EntryLike[]);
+
+		// Owners add nothing on an epoch (the live stack is rendered), so the told maps need no reset here.
+		const request: RenderRequest = { epoch, told: fold.told, modes: fold.modes, toldBlocks: fold.blocks, model: ctx.model, blocks: [] };
+		pi.events.emit(RENDER_CHANNEL, request);
+		const oneShots: OneShot[] = [
+			...fold.pending.filter((item) => !deliveredHere.has(item.id)).map(oneShotOf),
+			...request.blocks.map((block) => ({ text: block.text, placement: "last-append" as const, ...(block.facts ? { facts: block.facts } : {}) })),
+		];
+		const stack = live.stackEntries();
+		// A sticky state's first delivery is told, so a failed request's revokes and an epoch renders it again.
+		const toldBlocks = epoch ? new Map<string, string>() : fold.blocks;
+		const sticky = live.stickyEntries().map((entry) => {
+			const fact = stickyFact(entry);
+			return { ...entry, fact, delivered: toldBlocks.get(fact.key) === fact.hash };
+		});
+		const rendered = renderReminders(event.messages, { epoch, layout: layout !== undefined, stack, sticky, oneShots });
+		const stickyFacts = sticky.filter((entry) => !entry.delivered && rendered.stickyPlaced.includes(entry.key)).map((entry) => entry.fact);
+
+		const consumed = rendered.placed.flatMap((shot) => (shot.id ? [shot.id] : []));
+		// Each fact with the text that carries it: a repair that drops the text drops the fact.
+		const carried = [
+			...(epoch && rendered.stackPlaced ? stack.filter((entry) => layout !== undefined || !entry.systemRoleOnly).map((entry) => ({ text: entry.text, facts: entry.facts ?? [] })) : []),
+			...rendered.placed.map((shot) => ({ text: shot.text, facts: shot.facts ?? [] })),
+			...sticky.filter((entry) => stickyFacts.includes(entry.fact)).map((entry) => ({ text: entry.text, facts: [entry.fact] })),
+		].filter((block) => block.facts.length > 0);
+		if (current) {
+			current.consumed.push(...consumed);
+			current.carried.push(...carried);
+		} else {
+			for (const id of consumed) deliveredHere.add(id);
+		}
+
+		moved = rendered.moved;
+		epochRequest = epoch;
+		// Each tool result's <total_tokens> countdown, lifted for a system message
+		// or framed, while the result's blocks are still separate (lib/turn-budget-layout.ts).
 		// With the budget off no result carries one, so a tool's own such line stays its output.
-		const budgetOn = process.env.CC_TOTAL_TOKENS !== "0";
-		const resolved = budgetOn && ctx.model && wireShape(ctx.model.api) ? resolveCountdowns(messages, layout !== undefined) : undefined;
+		countdowns = new Map();
+		const resolved = budgetMarkers() && ctx.model && wireShape(ctx.model.api) ? resolveCountdowns(rendered.messages, layout !== undefined) : undefined;
 		if (resolved) countdowns = resolved.left;
-		const out = resolved?.messages ?? messages;
-		return out === event.messages ? undefined : { messages: out };
+		const out = resolved?.messages ?? rendered.messages;
+		const changed = out.length !== event.messages.length || out.some((message, i) => message !== event.messages[i]);
+		return changed ? { messages: out } : undefined;
 	});
 
 	pi.on("before_provider_request", (event, ctx) => {
@@ -239,14 +211,14 @@ export default function systemReminderExtension(pi: ExtensionAPI) {
 		// gets its clear_at nudge after each tool result.
 		const firstParty = model.provider === "anthropic";
 		const nudge = layout === "anthropic" && firstParty && claudeFamily(model.id) === "fable";
-		const markers = process.env.CC_TOTAL_TOKENS !== "0";
-		payload = withTurnBudgetMessages(payload, { shape, systemRole: layout !== undefined, role, left: countdowns, nudge, markers }) ?? payload;
-		if (payload === event.payload) return undefined;
-		if (shape === "anthropic") {
+		payload = withTurnBudgetMessages(payload, { shape, systemRole: layout !== undefined, role, left: countdowns, nudge, markers: budgetMarkers(), stackCarrier: epochRequest }) ?? payload;
+		if (payload !== event.payload && shape === "anthropic") {
 			const key = messagesKey(shape);
 			payload = { ...payload, [key]: reseatMessageMark(payload[key] as Array<{ role?: unknown; content?: unknown }>) };
 		}
-		if (layout !== "anthropic" || !firstParty) return payload;
-		return withBetas(payload, nudge ? [MID_CONVERSATION_SYSTEM_BETA, CLEAR_AT_BETA] : [MID_CONVERSATION_SYSTEM_BETA]);
+		// The betas go on every request of a model that takes the layout: an
+		// earlier request's system messages are part of every later one.
+		if (layout === "anthropic" && firstParty) payload = withBetas(payload, nudge ? [MID_CONVERSATION_SYSTEM_BETA, CLEAR_AT_BETA] : [MID_CONVERSATION_SYSTEM_BETA]);
+		return payload === event.payload ? undefined : payload;
 	});
 }