@namzu/sdk 27.0.0 → 28.0.0

package/src/public-types.ts

@@ -16,6 +16,7 @@
 export type * from './types/ids/index.js'
 export type * from './types/message/index.js'
 export type * from './types/common/index.js'
+export type { CoalesceOptions } from './streaming/coalesce.js'
 export type * from './types/bidi/index.js'
 export type * from './types/tool/index.js'
 // The directory convention: what a loaded `agent/` directory is, and what the
@@ -51,7 +52,7 @@ export type * from './types/sandbox/index.js'
 export type * from './types/structured-output/index.js'
 export type * from './types/invocation/index.js'
 export type * from './types/computer-use/index.js'
-export type * from './types/verification/index.js'
+export type * from './types/authorization/index.js'
 export type * from './types/bus/index.js'
 export type * from './types/probe/index.js'
 export type * from './types/doctor/index.js'
@@ -103,10 +104,18 @@ export type { VendorRates } from './pricing/index.js'
 export type { PricingSubject } from './manager/run/persistence.js'
 export type { FrontmatterValue, ParsedFrontmatter } from './utils/frontmatter.js'
 export type { Logger } from './utils/logger.js'
+export type {
+	LevelFilter,
+	LogRecord,
+	LogSink,
+	LogSinkCounters,
+	Resource,
+	Severity,
+} from './utils/log/index.js'
 export type { ShellCompressOptions, ShellCompressResult } from './utils/shell-compress.js'
 
 export type { QueryParams } from './runtime/query/index.js'
-export type { ContextCacheConfig, PromptCacheInput } from './runtime/query/context-cache.js'
+export type { PromptCacheConfig, PromptCacheInput } from './runtime/query/prompt-cache.js'
 
 export type { LimitCheckResult, LimitCheckerState, RunReporter } from './run/index.js'
 
@@ -162,7 +171,7 @@ export type {
 	ConnectorToolConfig,
 	ConnectorToolRouterConfig,
 	ConnectorToolStrategy,
-} from './bridge/tools/connector/index.js'
+} from './connector/tools/index.js'
 
 export type { CreateRunFromA2A } from './bridge/a2a/index.js'
 
@@ -170,7 +179,8 @@ export type { MappedStreamEvent } from './bridge/sse/index.js'
 
 export type { AgentBusConfig } from './bus/index.js'
 
-export type { ToolCallContext } from './verification/index.js'
+export type { ToolCallContext } from './authorization/index.js'
+export type { PermissionPreset } from './authorization/index.js'
 
 export type { DiskSessionStoreConfig, LinkageView } from './store/session/index.js'
 
@@ -190,3 +200,90 @@ export type {
 } from './compaction/index.js'
 export type * from './eval/index.js'
 export type * from './types/guardrail/index.js'
+
+export type {
+	HostCommandContext,
+	HostCommandDescriptor,
+	HostCommandOutcome,
+	HostCommandRow,
+	SerializableHostCommand,
+} from './types/command/index.js'
+
+export type { TopicState } from './types/topic/state.js'
+export type {
+	ObjectiveAdvance,
+	ObjectiveAdvanceResult,
+	ObjectiveBlock,
+	ObjectivePhase,
+	ObjectiveRefusal,
+	ObjectiveRoundVerdict,
+	TopicObjective,
+} from './types/topic/objective.js'
+export type {
+	CreateObjectiveParams,
+	DiskTopicObjectiveStoreConfig,
+	TopicObjectiveStore,
+} from './store/topic/objective.js'
+export type {
+	AdvanceObjectiveParams,
+	DriveObjectiveParams,
+} from './manager/topic/objective.js'
+
+export type { AgentHandle, AgentHandleOptions, AgentHandleStatus } from './agents/handle.js'
+
+export type {
+	CredentialDescription,
+	CredentialProvider,
+	CredentialRef as CredentialName,
+	ResolvedCredential,
+} from './vault/CredentialProvider.js'
+
+// Who answers when a run asks a human, as a value rather than a closure
+// captured at `query()` start. See `types/hitl/policy.ts`.
+export type {
+	ApprovalPolicy,
+	ApprovalPolicyChange,
+	ApprovalPolicyChangedEvent,
+	RunApprovalPolicy,
+} from './types/hitl/policy.js'
+
+export type {
+	PromptContribution,
+	PromptContributionContext,
+	PromptPlacement,
+} from './prompt/index.js'
+
+export type {
+	GuardedFetchConfig,
+	WebFetchProvider,
+	WebFetchRefusalReason,
+	WebFetchRequest,
+	WebFetchResult,
+	WebSearchHit,
+	WebSearchProvider,
+	WebSearchRequest,
+	WebSearchResult,
+} from './connector/web/index.js'
+
+export type {
+	AttachmentStore,
+	StoredAttachment,
+	StoredBytes,
+} from './store/attachment/index.js'
+
+export type {
+	ReadModel,
+	RunStatusReadModelOptions,
+	RunStatusState,
+} from './read-model/index.js'
+
+export type { RunQueryOptions, ShedPass } from './run-query/index.js'
+
+export type {
+	OpenTerminalOptions,
+	PtyLoader,
+	PtyModule,
+	PtyProcess,
+	TerminalSession,
+	TerminalSize,
+} from './sandbox/terminal.js'

package/src/rag/rag-tool.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 import { defineTool } from '../tools/defineTool.js'
-import type { KnowledgeBaseId } from '../types/ids/index.js'
 import type { RAGToolConfig } from '../types/rag/index.js'
+import { asKnowledgeBaseId } from '../utils/id.js'
 import { assembleRAGContext } from './context-assembler.js'
 
 const ragInputSchema = z.object({
@@ -24,7 +24,9 @@ export function createRAGTool(config: RAGToolConfig) {
 
 		async execute(input) {
 			const kbId =
-				(input.knowledge_base_id as KnowledgeBaseId | undefined) ?? config.defaultKnowledgeBaseId
+				(input.knowledge_base_id === undefined
+					? undefined
+					: asKnowledgeBaseId(input.knowledge_base_id)) ?? config.defaultKnowledgeBaseId
 			const kb = kbId
 				? config.knowledgeBases.get(kbId)
 				: config.knowledgeBases.values().next().value

package/src/read-model/index.ts

@@ -0,0 +1,14 @@
+// A derived value maintained one event at a time. The registry's refusals
+// are what make "incremental" a property rather than a hope: a duplicate
+// double-counts, and a gap produces a state that looks complete and
+// describes a log the registry never saw.
+export {
+	DuplicateEventError,
+	EventGapError,
+	ReadModelCollisionError,
+	ReadModelRegistry,
+	UnknownReadModelError,
+} from './registry.js'
+export type { ReadModel } from './registry.js'
+export { RUN_STATUS_READ_MODEL_ID, createRunStatusReadModel } from './run-status.js'
+export type { RunStatusReadModelOptions, RunStatusState } from './run-status.js'

package/src/read-model/registry.ts

@@ -0,0 +1,152 @@
+import type { PersistedRunEvent } from '../types/run/index.js'
+
+/**
+ * A derived value maintained incrementally from the run's event log.
+ *
+ * Everything derived from a run was computed by scanning what was in hand
+ * at the moment somebody asked — `deriveRunStatus` takes a status and a
+ * park and answers about that instant. That works while the whole run fits
+ * in memory and stops working the moment it does not: a caller wanting the
+ * status of a run whose history has been compacted, or of a run in another
+ * process, has to load the log and fold it, and every caller folds it
+ * slightly differently.
+ *
+ * A read model is that fold, written once and advanced one event at a time.
+ * The registry below is what makes "advanced one event at a time" a
+ * property rather than a hope: it refuses a duplicate and refuses a gap, so
+ * a projection is either correct or absent, never quietly built on a log it
+ * did not fully see.
+ */
+
+export interface ReadModel<TState> {
+	/** Stable, and how a caller asks for this projection's state. */
+	readonly id: string
+	/** The value before any event. Called once per registry. */
+	initial(): TState
+	/**
+	 * PURE. Same state plus same event must give the same result, every
+	 * time and in any process.
+	 *
+	 * Returning the SAME object when an event changes nothing is expected
+	 * and cheap; the registry does not compare, and a model that allocated
+	 * a fresh state per event would still be correct, only wasteful.
+	 */
+	apply(state: TState, event: PersistedRunEvent): TState
+}
+
+/** An event the registry has already folded in. */
+export class DuplicateEventError extends Error {
+	readonly details: { seq: number; lastSeq: number }
+
+	constructor(details: { seq: number; lastSeq: number }) {
+		super(`Event seq=${details.seq} was already applied (the registry is at ${details.lastSeq}).`)
+		this.name = 'DuplicateEventError'
+		this.details = details
+	}
+}
+
+/** An event that skips one the registry never saw. */
+export class EventGapError extends Error {
+	readonly details: { seq: number; expected: number }
+
+	constructor(details: { seq: number; expected: number }) {
+		super(
+			`Event seq=${details.seq} arrived while the registry expected ${details.expected}; a projection built across a gap is wrong in a way nothing reports.`,
+		)
+		this.name = 'EventGapError'
+		this.details = details
+	}
+}
+
+/** A projection nobody registered. */
+export class UnknownReadModelError extends Error {
+	readonly details: { id: string }
+
+	constructor(details: { id: string }) {
+		super(`No read model registered as "${details.id}".`)
+		this.name = 'UnknownReadModelError'
+		this.details = details
+	}
+}
+
+/** Two models claiming one id. */
+export class ReadModelCollisionError extends Error {
+	readonly details: { id: string }
+
+	constructor(details: { id: string }) {
+		super(`A read model with id "${details.id}" is already registered.`)
+		this.name = 'ReadModelCollisionError'
+		this.details = details
+	}
+}
+
+/**
+ * Every projection of one run, advanced together.
+ *
+ * Together, and that is the design: a registry per run rather than per
+ * model, so `lastSeq` is one number and a caller reading two projections
+ * cannot be handed states derived from different prefixes of the same log.
+ */
+export class ReadModelRegistry {
+	private readonly models = new Map<string, ReadModel<unknown>>()
+	private readonly states = new Map<string, unknown>()
+	private seq = 0
+
+	/** The seq this registry has folded up to. `0` before any event. */
+	get lastSeq(): number {
+		return this.seq
+	}
+
+	register<TState>(model: ReadModel<TState>): void {
+		if (this.models.has(model.id)) throw new ReadModelCollisionError({ id: model.id })
+		this.models.set(model.id, model as ReadModel<unknown>)
+		this.states.set(model.id, model.initial())
+	}
+
+	/**
+	 * Fold one event into every projection.
+	 *
+	 * REFUSES a duplicate and REFUSES a gap. Both are silent corruptions
+	 * otherwise: a duplicate double-counts anything a model accumulates, and
+	 * a gap produces a state that looks complete and describes a log the
+	 * registry never saw. A caller that legitimately has to skip ahead
+	 * rebuilds with {@link replay} instead, which is honest about starting
+	 * over.
+	 */
+	apply(event: PersistedRunEvent): void {
+		if (event.seq <= this.seq) {
+			throw new DuplicateEventError({ seq: event.seq, lastSeq: this.seq })
+		}
+		if (event.seq !== this.seq + 1) {
+			throw new EventGapError({ seq: event.seq, expected: this.seq + 1 })
+		}
+		for (const [id, model] of this.models) {
+			this.states.set(id, model.apply(this.states.get(id), event))
+		}
+		this.seq = event.seq
+	}
+
+	/**
+	 * Throw away every state and fold the whole log again.
+	 *
+	 * The honest alternative to accepting a gap. A caller that has lost its
+	 * place, or that just registered a model into a running registry, gets a
+	 * correct answer by paying for the whole log rather than a plausible one
+	 * by pretending it did not miss anything.
+	 */
+	replay(events: readonly PersistedRunEvent[]): void {
+		for (const [id, model] of this.models) this.states.set(id, model.initial())
+		this.seq = 0
+		for (const event of events) this.apply(event)
+	}
+
+	/** The projection's state, or throw for an id nobody registered. */
+	get<TState>(id: string): TState {
+		if (!this.models.has(id)) throw new UnknownReadModelError({ id })
+		return this.states.get(id) as TState
+	}
+
+	has(id: string): boolean {
+		return this.models.has(id)
+	}
+}

package/src/read-model/run-status.ts

@@ -0,0 +1,127 @@
+import type { RunExecutionStatus } from '../types/common/index.js'
+import type { PendingDecision } from '../types/hitl/index.js'
+import { deriveRunStatus } from '../types/run/derive-status.js'
+import type { RunStatus } from '../types/run/index.js'
+import type { ReadModel } from './registry.js'
+
+/**
+ * A run's session-layer status, maintained from its own event log.
+ *
+ * `deriveRunStatus` answers about an instant: hand it a status and a park
+ * and it projects them. Getting those two inputs meant holding the run
+ * record and the park store, which a caller reading a finished run's
+ * history — or a run in another process — does not have. This derives both
+ * from the events the run already emits, so the projection needs the log
+ * and nothing else.
+ *
+ * The instant-projector is still what answers; this only feeds it. Two
+ * implementations of the same rule would be two chances to disagree about
+ * what `awaiting_hitl_resolution` means, and the disagreement would show up
+ * as a run that reads differently depending on which surface asked.
+ */
+
+export const RUN_STATUS_READ_MODEL_ID = 'namzu.run.status'
+
+export interface RunStatusState {
+	readonly execution: RunExecutionStatus
+	/** The outstanding park, if the log says there is one. */
+	readonly park?: PendingDecision
+	/** `deriveRunStatus` at the moment the last event was folded in. */
+	readonly status: RunStatus
+}
+
+/**
+ * `now` is injected, and the reason is subtle enough to state.
+ *
+ * `awaiting_hitl` becomes `awaiting_hitl_resolution` when a deadline
+ * passes, and a deadline passes without any event being emitted. So the
+ * state a fold produces is the status AS OF the last event — which is the
+ * honest thing for a projection to hold, since nothing woke it up at the
+ * deadline. A caller that needs the answer right now re-projects with
+ * `deriveRunStatus(state)` and its own clock; the field here is what the
+ * log alone can say.
+ */
+export interface RunStatusReadModelOptions {
+	readonly now?: () => number
+}
+
+export function createRunStatusReadModel(
+	options: RunStatusReadModelOptions = {},
+): ReadModel<RunStatusState> {
+	const now = options.now ?? Date.now
+
+	const project = (execution: RunExecutionStatus, park?: PendingDecision): RunStatusState => ({
+		execution,
+		...(park ? { park } : {}),
+		status: deriveRunStatus({ status: execution, ...(park ? { park } : {}), now: now() }),
+	})
+
+	return {
+		id: RUN_STATUS_READ_MODEL_ID,
+		// `idle`, not `pending`. A run whose log is empty has not been queued
+		// by anything this projection saw, and `queued` is a claim about a
+		// decision somebody made.
+		initial: () => project('idle'),
+
+		apply(state, event) {
+			switch (event.type) {
+				case 'run_started':
+					return project('running')
+				case 'run_completed':
+					return project('completed')
+				case 'run_failed':
+					return project('failed')
+
+				case 'checkpoint_created':
+				case 'run_paused':
+					// A pause is not a park. The park below is what carries a
+					// deadline and therefore what separates "waiting" from
+					// "waited too long"; a pause with no park is a run that
+					// stopped for a reason this projection cannot name, and
+					// inventing `awaiting_hitl` for it would report a human as
+					// owing an answer nobody asked them for.
+					//
+					// These two cases are BEHAVIOURALLY identical to the
+					// `default` below and are kept anyway, which a mutation
+					// correctly reports as surviving. They are here because
+					// these are the two events a reader most expects to change
+					// the status; falling into a silent `default` would leave
+					// the next person to ask deducing the decision from its
+					// absence, and the last time somebody deduced it they
+					// deduced wrong.
+					return state
+
+				case 'tool_review_requested':
+				case 'user_question_asked':
+					// A park, as the log records one. `deadlineAt` is absent
+					// here because these events do not carry it — so a run
+					// waiting on a review reads `awaiting_hitl` and never
+					// `awaiting_hitl_resolution`, which is correct: with no
+					// deadline in the log there is nothing that could expire.
+					return project(state.execution === 'idle' ? 'running' : state.execution, {
+						// The shape `deriveRunStatus` actually reads: `resolvedAt`
+						// absent means outstanding, and `deadlineAt` absent means
+						// nothing can expire. `request` is carried because the
+						// type requires it, and is the event itself — the log IS
+						// what the run parked on, so synthesising a different
+						// object would be inventing a request nobody made.
+						request: event as unknown as PendingDecision['request'],
+						parkedAt: event.timestamp,
+					})
+
+				case 'tool_review_completed':
+				case 'user_question_answered':
+				case 'run_resuming':
+					// Answered. Dropping the park is what moves the run back to
+					// `running`, and it has to happen on the ANSWER rather than
+					// on the next tool call — a run that stayed `awaiting_hitl`
+					// until it happened to do something else would show a human
+					// as owed an answer they had already given.
+					return project(state.execution)
+
+				default:
+					return state
+			}
+		},
+	}
+}

package/src/registry/{Registry.ts → BaseRegistry.ts}

@@ -1,4 +1,4 @@
-export class Registry<TDefinition> {
+export class BaseRegistry<TDefinition> {
 	protected items: Map<string, TDefinition> = new Map()
 
 	register(id: string, item: TDefinition): void {

package/src/registry/ManagedRegistry.ts

@@ -1,5 +1,7 @@
-import { type Logger, getRootLogger } from '../utils/logger.js'
-import { Registry } from './Registry.js'
+import { NAMZU } from '../constants/telemetry/index.js'
+import { SCOPE_ATTRIBUTE } from '../utils/log/types.js'
+import { type Logger, resolveLogger } from '../utils/logger.js'
+import { BaseRegistry } from './BaseRegistry.js'
 
 export interface ManagedRegistryConfig<TDefinition> {
 	componentName: string
@@ -12,7 +14,7 @@ export interface ManagedRegistryConfig<TDefinition> {
 	logger?: Logger
 }
 
-export class ManagedRegistry<TDefinition> extends Registry<TDefinition> {
+export class ManagedRegistry<TDefinition> extends BaseRegistry<TDefinition> {
 	protected log: Logger
 	private idField?: keyof TDefinition & string
 	private computeId?: (item: TDefinition) => string
@@ -21,8 +23,9 @@ export class ManagedRegistry<TDefinition> extends Registry<TDefinition> {
 		super()
 		this.idField = config.idField
 		this.computeId = config.computeId
-		this.log = (config.logger ?? getRootLogger()).child({
-			component: config.componentName,
+		this.log = resolveLogger(config.logger).child({
+			[SCOPE_ATTRIBUTE]: 'registry',
+			[NAMZU.REGISTRY_NAME]: config.componentName,
 		})
 	}
 
@@ -44,10 +47,10 @@ export class ManagedRegistry<TDefinition> extends Registry<TDefinition> {
 			const id = idOrItem
 			const item = maybeItem
 			if (this.has(id)) {
-				this.log.warn(`"${id}" already registered, overwriting.`)
+				this.log.warn('Already registered, overwriting', { 'namzu.registry.item_id': id })
 			}
 			super.register(id, item)
-			this.log.info(`Registered: ${id}`)
+			this.log.debug('Registered', { 'namzu.registry.item_id': id })
 			return
 		}
 
@@ -62,10 +65,24 @@ export class ManagedRegistry<TDefinition> extends Registry<TDefinition> {
 		}
 
 		if (this.has(id)) {
-			this.log.warn(`"${id}" already registered, overwriting.`)
+			this.log.warn('Already registered, overwriting', { 'namzu.registry.item_id': id })
 		}
 		super.register(id, item)
-		this.log.info(`Registered: ${id}`)
+		// `debug`, not `info`. Registration is the startup path doing exactly
+		// what it is supposed to do, once per item, and there are dozens: a
+		// default-level run opened with twenty `Registered` lines, one per
+		// tool, before anything an operator could act on. That is the same
+		// failure as silence with the sign flipped — the interesting lines are
+		// there, and nobody can find them.
+		//
+		// The overwrite case above stays at `warn`, because a second
+		// registration under a live id IS news.
+		//
+		// Found by running the CLI against a real provider rather than a mock.
+		// Every unit test here asserts on a logger stub, so the LEVEL was
+		// invisible to all of them: what a start actually reads like is not a
+		// property any of them measure.
+		this.log.debug('Registered', { 'namzu.registry.item_id': id })
 	}
 
 	getOrThrow(id: string): TDefinition {

package/src/registry/command/index-exports.ts

@@ -0,0 +1,4 @@
+// One import site for the public barrel, so `registry/index.ts` stays the
+// package-internal entry and `public-runtime.ts` does not reach past it.
+export { HostCommandNameCollisionError, HostCommandRegistry } from './index.js'
+export { kernelHostCommands } from './kernel-commands.js'

package/src/registry/command/index.ts

@@ -0,0 +1,105 @@
+import type {
+	HostCommandContext,
+	HostCommandDescriptor,
+	HostCommandOutcome,
+	SerializableHostCommand,
+} from '../../types/command/index.js'
+import { ManagedRegistry } from '../ManagedRegistry.js'
+
+/**
+ * A second command claiming a name that is already taken.
+ *
+ * Its own class rather than a bare `Error`, for the reason
+ * `ToolNameCollisionError` gives: a host that wants to decide what to do —
+ * skip, rename, refuse to boot — has to catch it narrowly instead of
+ * matching on message text.
+ */
+export class HostCommandNameCollisionError extends Error {
+	readonly commandName: string
+
+	constructor(commandName: string) {
+		super(
+			`Host command "/${commandName}" is already registered. Two commands answering to one name shadow each other silently, and which one wins depends on registration order.`,
+		)
+		this.name = 'HostCommandNameCollisionError'
+		this.commandName = commandName
+	}
+}
+
+/**
+ * The commands a host offers its operator, held where the kernel can fill
+ * them.
+ *
+ * `ManagedRegistry` for the id handling and the logging, with the
+ * collision policy tightened: the base class WARNS and overwrites, which is
+ * right for a tool roster a host assembles deliberately and wrong here.
+ * These are operator-facing, and a shadowed command is invisible — it does
+ * not fail, it simply never runs, and the one that wins depends on
+ * registration order. `ToolRegistry` reaches the same conclusion for the
+ * same reason one directory over.
+ */
+export class HostCommandRegistry extends ManagedRegistry<HostCommandDescriptor> {
+	constructor(logger?: ConstructorParameters<typeof ManagedRegistry>[0]['logger']) {
+		super({ componentName: 'host-commands', idField: 'name', ...(logger ? { logger } : {}) })
+	}
+
+	override register(id: string, item: HostCommandDescriptor): void
+	override register(item: HostCommandDescriptor): void
+	override register(items: HostCommandDescriptor[]): void
+	override register(
+		idOrItem: string | HostCommandDescriptor | HostCommandDescriptor[],
+		maybeItem?: HostCommandDescriptor,
+	): void {
+		if (Array.isArray(idOrItem)) {
+			for (const item of idOrItem) this.register(item)
+			return
+		}
+		const name = typeof idOrItem === 'string' ? idOrItem : idOrItem.name
+		if (this.has(name)) throw new HostCommandNameCollisionError(name)
+		if (typeof idOrItem === 'string') {
+			if (!maybeItem) throw new Error('register(id, item) requires an item argument')
+			super.register(idOrItem, maybeItem)
+			return
+		}
+		super.register(idOrItem)
+	}
+
+	/**
+	 * Run a command line, or say this is not one of ours.
+	 *
+	 * `undefined` for an unknown name, and that is not the same as
+	 * `refused`. A host layers its own commands under the kernel's — an
+	 * operator's `.md` files, a TUI's `/clear` — and needs "not mine, keep
+	 * looking" to be distinguishable from "mine, and no". Collapsing the two
+	 * makes every host command below this registry unreachable.
+	 */
+	async dispatch(
+		raw: string,
+		ctx?: Partial<HostCommandContext>,
+	): Promise<HostCommandOutcome | undefined> {
+		const trimmed = raw.trim()
+		if (!trimmed.startsWith('/')) return undefined
+		const [name, ...args] = trimmed.slice(1).split(/\s+/)
+		if (!name) return undefined
+
+		const command = this.get(name)
+		if (!command) return undefined
+
+		return command.handler({ args: ctx?.args ?? args })
+	}
+
+	/**
+	 * Every command, without its handler.
+	 *
+	 * Stripped rather than merely "not usually read": this is what crosses a
+	 * process boundary, and a function-valued key survives neither
+	 * `JSON.stringify` nor `structuredClone` — the first drops it silently,
+	 * the second throws. Removing it here means a host gets the same
+	 * descriptor either way.
+	 */
+	describe(): readonly SerializableHostCommand[] {
+		return this.getAll()
+			.map(({ handler: _handler, ...rest }) => rest)
+			.sort((a, b) => a.name.localeCompare(b.name))
+	}
+}