@growth-labs/cms 0.1.0

package/src/routes/authors.ts

@@ -0,0 +1,282 @@
+// Authors CRUD route handlers (WS7-07). Ported from fulcrum-labs/fronts
+// src/pages/api/v1/publisher/authors/index.ts + [id].ts and the
+// publisher-authors.ts helpers (inventory §3: extract — authors are core CMS).
+// Auth/authz is injected via config.authz.requirePublisher; nothing here binds
+// Fronts' context.locals.user.
+
+import { z } from 'zod'
+import type { D1Database } from '../engine/d1.js'
+import { slugify } from '../engine/slug.js'
+import type { CmsRouteConfig } from './config.js'
+import { resolveConfig } from './config.js'
+import { json, type RouteContext, requireId } from './context.js'
+
+// --- publisher-authors.ts helpers (extract) -------------------------------
+
+export function parseSocialJson(value: string | null | undefined): Record<string, string> {
+	if (!value) return {}
+	try {
+		const parsed = JSON.parse(value)
+		if (parsed && typeof parsed === 'object') {
+			return parsed as Record<string, string>
+		}
+	} catch {
+		// ignore malformed JSON
+	}
+	return {}
+}
+
+export function normalizeSocialInput(
+	input: Record<string, string> | null | undefined,
+): Record<string, string> | null {
+	if (!input) return null
+	const output: Record<string, string> = {}
+	for (const [key, value] of Object.entries(input)) {
+		if (typeof value !== 'string') continue
+		const trimmed = value.trim()
+		if (trimmed) output[key] = trimmed
+	}
+	return Object.keys(output).length > 0 ? output : null
+}
+
+export function serializeSocialInput(
+	input: Record<string, string> | null | undefined,
+): string | null {
+	const normalized = normalizeSocialInput(input)
+	return normalized ? JSON.stringify(normalized) : null
+}
+
+export async function ensureUniqueAuthorSlug(
+	db: D1Database,
+	slug: string,
+	excludeId?: string,
+): Promise<string> {
+	const base = slugify(slug)
+	if (!base) return ''
+	let candidate = base
+	let suffix = 2
+
+	while (true) {
+		const row = await db
+			.prepare('SELECT id FROM authors WHERE slug = ? LIMIT 1')
+			.bind(candidate)
+			.first<{ id: string }>()
+
+		if (!row || (excludeId && row.id === excludeId)) {
+			return candidate
+		}
+		candidate = `${base}-${suffix}`
+		suffix += 1
+	}
+}
+
+// --- schemas --------------------------------------------------------------
+
+const SocialSchema = z
+	.object({
+		twitter: z.string().optional(),
+		linkedin: z.string().optional(),
+		github: z.string().optional(),
+		website: z.string().optional(),
+	})
+	.optional()
+
+const CreateSchema = z.object({
+	id: z.string().min(1).optional(),
+	name: z.string().min(1),
+	slug: z.string().min(1).optional(),
+	bio: z.string().optional().nullable(),
+	avatar: z.string().optional().nullable(),
+	email: z.string().optional().nullable(),
+	social: SocialSchema.nullish(),
+})
+
+const UpdateSchema = z.object({
+	name: z.string().min(1).optional(),
+	slug: z.string().min(1).optional(),
+	bio: z.string().optional().nullable(),
+	avatar: z.string().optional().nullable(),
+	email: z.string().optional().nullable(),
+	social: SocialSchema.nullish(),
+})
+
+function normalizeNullable(value: string | null | undefined): string | null {
+	if (value === undefined) return null
+	const trimmed = value?.trim()
+	return trimmed ? trimmed : null
+}
+
+interface AuthorRow {
+	id: string
+	name: string
+	slug: string
+	bio: string | null
+	avatar: string | null
+	email: string | null
+	social: string | null
+	updated_at: number | null
+}
+
+function serializeAuthor(row: AuthorRow) {
+	return {
+		id: row.id,
+		name: row.name,
+		slug: row.slug,
+		bio: row.bio,
+		avatar: row.avatar,
+		email: row.email,
+		social: parseSocialJson(row.social),
+		updatedAt: row.updated_at ? new Date(row.updated_at * 1000).toISOString() : null,
+	}
+}
+
+async function readJson(ctx: RouteContext): Promise<unknown> {
+	return ctx.request.json().catch(() => null)
+}
+
+export interface AuthorRouteHandlers {
+	/** GET /authors — list. */
+	list(ctx: RouteContext): Promise<Response>
+	/** POST /authors — create. */
+	create(ctx: RouteContext): Promise<Response>
+	/** GET /authors/:id — read one. */
+	get(ctx: RouteContext): Promise<Response>
+	/** PATCH /authors/:id — update. */
+	update(ctx: RouteContext): Promise<Response>
+}
+
+export function createAuthorRoutes(config: CmsRouteConfig): AuthorRouteHandlers {
+	const resolved = resolveConfig(config)
+
+	return {
+		async list(ctx) {
+			const denied = await resolved.authz.requirePublisher(ctx)
+			if (denied) return denied
+
+			const result = await ctx.db
+				.prepare(
+					'SELECT id, name, slug, bio, avatar, email, social, updated_at FROM authors ORDER BY name',
+				)
+				.all<AuthorRow>()
+
+			const items = (result.results || []).map(serializeAuthor)
+			return json({ items })
+		},
+
+		async create(ctx) {
+			const denied = await resolved.authz.requirePublisher(ctx)
+			if (denied) return denied
+
+			const parsed = CreateSchema.safeParse(await readJson(ctx))
+			if (!parsed.success) {
+				return json({ error: 'Invalid request', details: parsed.error.flatten() }, 400)
+			}
+
+			const slugInput = parsed.data.slug || parsed.data.name
+			const slug = await ensureUniqueAuthorSlug(ctx.db, slugInput)
+			if (!slug) return json({ error: 'Slug is required' }, 400)
+
+			const id = parsed.data.id?.trim() || slug
+			const existingId = await ctx.db
+				.prepare('SELECT id FROM authors WHERE id = ? LIMIT 1')
+				.bind(id)
+				.first<{ id: string }>()
+			if (existingId) return json({ error: 'Author id already exists' }, 409)
+
+			const social = serializeSocialInput(parsed.data.social ?? null)
+			await ctx.db
+				.prepare(
+					`INSERT INTO authors (id, name, slug, bio, avatar, email, social, created_at, updated_at)
+					 VALUES (?, ?, ?, ?, ?, ?, ?, unixepoch(), unixepoch())`,
+				)
+				.bind(
+					id,
+					parsed.data.name.trim(),
+					slug,
+					normalizeNullable(parsed.data.bio),
+					normalizeNullable(parsed.data.avatar),
+					normalizeNullable(parsed.data.email),
+					social,
+				)
+				.run()
+
+			return json({ id, slug }, 201)
+		},
+
+		async get(ctx) {
+			const denied = await resolved.authz.requirePublisher(ctx)
+			if (denied) return denied
+
+			const idResult = requireId(ctx)
+			if ('error' in idResult) return idResult.error
+
+			const row = await ctx.db
+				.prepare(
+					'SELECT id, name, slug, bio, avatar, email, social, updated_at FROM authors WHERE id = ? LIMIT 1',
+				)
+				.bind(idResult.id)
+				.first<AuthorRow>()
+
+			if (!row) return json({ error: 'Not found' }, 404)
+			return json({ item: serializeAuthor(row) })
+		},
+
+		async update(ctx) {
+			const denied = await resolved.authz.requirePublisher(ctx)
+			if (denied) return denied
+
+			const idResult = requireId(ctx)
+			if ('error' in idResult) return idResult.error
+			const id = idResult.id
+
+			const parsed = UpdateSchema.safeParse(await readJson(ctx))
+			if (!parsed.success) {
+				return json({ error: 'Invalid request', details: parsed.error.flatten() }, 400)
+			}
+
+			const existing = await ctx.db
+				.prepare(
+					'SELECT id, name, slug, bio, avatar, email, social FROM authors WHERE id = ? LIMIT 1',
+				)
+				.bind(id)
+				.first<{
+					id: string
+					name: string
+					slug: string
+					bio: string | null
+					avatar: string | null
+					email: string | null
+					social: string | null
+				}>()
+			if (!existing) return json({ error: 'Not found' }, 404)
+
+			const nextName = parsed.data.name ? parsed.data.name.trim() : existing.name
+			const nextSlug = parsed.data.slug
+				? await ensureUniqueAuthorSlug(ctx.db, parsed.data.slug, id)
+				: existing.slug
+			if (parsed.data.slug && !nextSlug) return json({ error: 'Slug is required' }, 400)
+
+			const nextBio =
+				parsed.data.bio !== undefined ? normalizeNullable(parsed.data.bio) : existing.bio
+			const nextAvatar =
+				parsed.data.avatar !== undefined ? normalizeNullable(parsed.data.avatar) : existing.avatar
+			const nextEmail =
+				parsed.data.email !== undefined ? normalizeNullable(parsed.data.email) : existing.email
+			const nextSocial =
+				parsed.data.social !== undefined
+					? serializeSocialInput(parsed.data.social ?? null)
+					: existing.social
+
+			await ctx.db
+				.prepare(
+					`UPDATE authors
+					 SET name = ?, slug = ?, bio = ?, avatar = ?, email = ?, social = ?, updated_at = unixepoch()
+					 WHERE id = ?`,
+				)
+				.bind(nextName, nextSlug, nextBio, nextAvatar, nextEmail, nextSocial, id)
+				.run()
+
+			return json({ id, slug: nextSlug })
+		},
+	}
+}

package/src/routes/authz-matrix.ts

@@ -0,0 +1,239 @@
+// authz-matrix.ts — 5-role per-capability permission table + requireRole/
+// contributor-ownership middleware (P7 Task 2). Fills the OPTIONAL Authz.getUser /
+// Authz.requireRole seam from context.ts.
+//
+// Design:
+//   - CAPABILITY_MATRIX: a pure Record<Capability, ReadonlySet<CmsRole>> table.
+//   - roleCan(role, cap): pure predicate — role is in the set for cap.
+//   - canActOnContent(role, {actorSubject, contentAuthorId}, cap): ownership
+//     predicate for contributor/producer (own-content-only gate).
+//   - buildMatrixAuthz({loadMembership, workspaceId, getSubject}): returns an
+//     Authz-compatible { getUser, requireRole } pair that resolves the actor's role
+//     from workspace_memberships via the subject.
+//
+// The 5-role model (spec §12 authoritative source):
+//   owner           — all capabilities including owner-only settings
+//   senior_editor   — publish anything, manage team, NOT owner-only settings
+//   editor          — publish own + others' drafts, media pipeline, NOT manage team/settings
+//   contributor     — own drafts only, submit for review (NO publish)
+//   producer        — media/video pipeline + publish video only
+
+import type { MembershipRecord } from '../engine/members.js'
+import type { CmsRole } from '../schema/types.js'
+import type { Capability, CmsUser, RouteContext } from './context.js'
+import { json } from './context.js'
+
+// Capability is defined in context.ts (shared with Authz interface) and
+// re-exported here for consumers that import from authz-matrix.ts directly.
+export type { Capability }
+
+// ---------------------------------------------------------------------------
+// Capability matrix (spec §12 — authoritative)
+// ---------------------------------------------------------------------------
+
+// Roles that may perform each capability:
+//   owner:          ALL capabilities
+//   senior_editor:  everything except manage_settings (owner-only); incl. team /
+//                   api-keys / webhooks / subscriber-PII export
+//   editor:         FULL editorial — publish, media, own/others drafts, review —
+//                   but NOT team/settings/api/webhooks/PII-export
+//   contributor:    edit own draft + submit for review only (NO publish/destructive)
+//   producer:       media pipeline + publish video + own draft + submit for review
+//
+// Capability → role grouping (the launch policy):
+//   FULL editorial (owner+senior_editor+editor): publish_article,
+//     publish_others_draft, edit_own_draft (+ media_pipeline; producer too).
+//   senior_editor + owner (NOT editor): manage_team (members/invites),
+//     manage_api_keys, manage_webhooks, export_subscribers (PII).
+//   owner ONLY: manage_settings — workspace settings PATCH + the privileged
+//     LemonSqueezy entitlement sync (importLsEntitlements). Matches the 448e815
+//     gate (requireRole('manage_settings')).
+export const CAPABILITY_MATRIX: Record<Capability, ReadonlySet<CmsRole>> = {
+	publish_article: new Set<CmsRole>(['owner', 'senior_editor', 'editor']),
+	publish_video: new Set<CmsRole>(['owner', 'senior_editor', 'editor', 'producer']),
+	edit_own_draft: new Set<CmsRole>(['owner', 'senior_editor', 'editor', 'contributor', 'producer']),
+	publish_others_draft: new Set<CmsRole>(['owner', 'senior_editor', 'editor']),
+	submit_for_review: new Set<CmsRole>([
+		'owner',
+		'senior_editor',
+		'editor',
+		'contributor',
+		'producer',
+	]),
+	media_pipeline: new Set<CmsRole>(['owner', 'senior_editor', 'editor', 'producer']),
+	manage_team: new Set<CmsRole>(['owner', 'senior_editor']),
+	// manage_settings is owner-only — spec §12 + scope guard 5 + the 448e815
+	// LS-import gate. Workspace settings PATCH + importLsEntitlements share it.
+	manage_settings: new Set<CmsRole>(['owner']),
+	// API keys / webhooks: owner + senior_editor (management-level)
+	manage_api_keys: new Set<CmsRole>(['owner', 'senior_editor']),
+	manage_webhooks: new Set<CmsRole>(['owner', 'senior_editor']),
+	// Subscriber-PII export: owner + senior_editor only (NOT editor). Editors keep
+	// full editorial but never touch subscriber email lists.
+	export_subscribers: new Set<CmsRole>(['owner', 'senior_editor']),
+}
+
+// ---------------------------------------------------------------------------
+// roleCan — pure predicate
+// ---------------------------------------------------------------------------
+
+/** Returns true when `role` is authorised to perform `cap` per the matrix. */
+export function roleCan(role: CmsRole, cap: Capability): boolean {
+	return (CAPABILITY_MATRIX[cap] as Set<CmsRole>).has(role)
+}
+
+// ---------------------------------------------------------------------------
+// canActOnContent — ownership predicate
+// ---------------------------------------------------------------------------
+
+export interface ContentOwnershipContext {
+	/** Subject of the acting user (e.g. 'user:abc'). */
+	actorSubject: string
+	/** Subject/userId stored as the content's author. */
+	contentAuthorId: string | null
+}
+
+/**
+ * Returns true when `role` may perform `cap` on a specific content item,
+ * taking the contributor/producer ownership gate into account.
+ *
+ * For non-ownership capabilities (manage_team, manage_settings, etc.) the
+ * ownership context is irrelevant — falls through to roleCan.
+ *
+ * For ownership-sensitive capabilities (edit_own_draft, publish_article, etc.):
+ *   - contributor: may only act on own content (actorSubject === contentAuthorId)
+ *   - producer:    may publish_video on any content (pipeline role); all other
+ *                  caps follow the standard ownership rule within their matrix set
+ *   - owner/senior_editor/editor: no ownership restriction
+ */
+export function canActOnContent(
+	role: CmsRole,
+	ownership: ContentOwnershipContext,
+	cap: Capability,
+): boolean {
+	// If the role can't do this at all, short-circuit
+	if (!roleCan(role, cap)) return false
+
+	const isOwn = ownership.actorSubject === ownership.contentAuthorId
+
+	switch (role) {
+		case 'contributor':
+			// contributor may only act on their own content for any cap they hold
+			return isOwn
+		case 'producer':
+			// producer may publish_video on ANY content (video pipeline role)
+			// for other caps they hold (edit_own_draft, submit_for_review) enforce own
+			if (cap === 'publish_video') return true
+			return isOwn
+		default:
+			// owner / senior_editor / editor: no ownership restriction
+			return true
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Content-action → capability mapping
+// ---------------------------------------------------------------------------
+
+/**
+ * The mutating content surface, expressed as a small vocabulary of actions the
+ * route adapters perform. Each maps to a matrix capability so the live content
+ * routes enforce role differentially (P7 — capability matrix wired into the
+ * adapters).
+ *
+ *   - 'write'    — create / update / save a draft, set-status, snapshot,
+ *                  contributors edit. Lowest bar: edit_own_draft (any member;
+ *                  contributor/producer gated to OWN content by canActOnContent).
+ *   - 'publish'  — publish/unpublish/archive/unschedule an article. Requires
+ *                  publish_others_draft (owner/senior_editor/editor); on OWN
+ *                  content publish_article suffices (still excludes contributor).
+ *   - 'publish_video' — publish a video/podcast item (producer included).
+ *   - 'schedule' — schedule/bulk-schedule. Same bar as publish.
+ *   - 'trash'    — soft-delete / bulk-trash. Destructive → publish_others_draft.
+ *   - 'media'    — dispatch-to-foundry / regenerate AI artefacts. media_pipeline.
+ */
+export type ContentAction = 'write' | 'publish' | 'publish_video' | 'schedule' | 'trash' | 'media'
+
+/**
+ * Resolve whether `role` may perform a content `action` on an item authored by
+ * `contentAuthorId` (null = no recorded author). Honors the contributor/producer
+ * ownership gate via canActOnContent. owner/senior_editor/editor are never
+ * ownership-restricted (the launch roster keeps full editorial).
+ *
+ * For 'write' the bar is edit_own_draft; for 'publish'/'schedule'/'trash' the bar
+ * is publish_others_draft when acting on someone else's content, falling back to
+ * publish_article on own content (so a contributor — who lacks both — is blocked,
+ * while editors+ pass either way).
+ */
+export function canPerformContentAction(
+	role: CmsRole,
+	ownership: ContentOwnershipContext,
+	action: ContentAction,
+): boolean {
+	const isOwn = ownership.actorSubject === ownership.contentAuthorId
+	switch (action) {
+		case 'write':
+			return canActOnContent(role, ownership, 'edit_own_draft')
+		case 'media':
+			return canActOnContent(role, ownership, 'media_pipeline')
+		case 'publish_video':
+			return canActOnContent(role, ownership, 'publish_video')
+		case 'publish':
+		case 'schedule':
+		case 'trash':
+			// On own content publish_article is enough; on others' content the
+			// stricter publish_others_draft is required. Either way contributor
+			// (which holds neither) is blocked, and editor+ pass.
+			if (isOwn && canActOnContent(role, ownership, 'publish_article')) return true
+			return canActOnContent(role, ownership, 'publish_others_draft')
+		default:
+			return false
+	}
+}
+
+// ---------------------------------------------------------------------------
+// buildMatrixAuthz — factory that produces Authz-compatible getUser/requireRole
+// ---------------------------------------------------------------------------
+
+export interface MatrixAuthzConfig {
+	/** Load a membership by (workspaceId, userId). Injected so engine stays pure. */
+	loadMembership(workspaceId: string, userId: string): Promise<MembershipRecord | null>
+	/** The workspace this authz resolves against. */
+	workspaceId: string
+	/** Resolve the current actor's subject from the request context. Returns null when unauthenticated. */
+	getSubject(ctx: RouteContext): Promise<string | null> | string | null
+}
+
+/**
+ * Build an Authz-compatible { getUser, requireRole } pair that resolves the
+ * actor's role from workspace_memberships via the subject.
+ *
+ * Returned:
+ *   getUser(ctx)           → CmsUser | null  (null = no membership / unauthenticated)
+ *   requireRole(cap, ctx)  → null (allowed) | Response (401/403)
+ */
+export function buildMatrixAuthz(config: MatrixAuthzConfig): {
+	getUser(ctx: RouteContext): Promise<CmsUser | null>
+	requireRole(cap: Capability, ctx: RouteContext): Promise<Response | null>
+} {
+	async function getUser(ctx: RouteContext): Promise<CmsUser | null> {
+		const subject = await config.getSubject(ctx)
+		if (!subject) return null
+		const membership = await config.loadMembership(config.workspaceId, subject)
+		if (!membership) return null
+		return { subject, email: null, role: membership.role }
+	}
+
+	async function requireRole(cap: Capability, ctx: RouteContext): Promise<Response | null> {
+		const subject = await config.getSubject(ctx)
+		if (!subject) return json({ error: 'Unauthorized' }, 401)
+		const membership = await config.loadMembership(config.workspaceId, subject)
+		if (!membership) return json({ error: 'Unauthorized' }, 401)
+		if (!roleCan(membership.role, cap)) {
+			return json({ error: 'Forbidden', required: cap, role: membership.role }, 403)
+		}
+		return null
+	}
+
+	return { getUser, requireRole }
+}

package/src/routes/calendar.ts

@@ -0,0 +1,127 @@
+// src/routes/calendar.ts — Editorial calendar route factory (P5 Task 7).
+// Returns first-party content_items within a from/to date range, selecting
+// items that have a publish_at (scheduled) or published_at (published) within
+// the range. Trashed items and dateless drafts are excluded.
+//
+// The response shape { items: CalendarItem[] } feeds buildCalendarMonth directly.
+// Schedule-from-calendar reuses the existing POST /content/:id?action=schedule —
+// no new mutation route here.
+//
+// No provider calls: the editorial calendar is fully first-party D1.
+
+import type { Authz, RouteContext } from './context.js'
+import { json } from './context.js'
+
+export interface CalendarRouteConfig {
+	authz: Authz
+}
+
+export interface CalendarRouteHandlers {
+	month(ctx: RouteContext): Promise<Response>
+}
+
+/** A calendar item as returned by the route — matches CalendarItem in calendar-data.ts. */
+export interface CalendarRouteItem {
+	id: string
+	type: string
+	title: string
+	status: string
+	slug: string
+	/** ISO-8601 date string derived from publish_at (scheduled) or published_at (published). */
+	date: string
+}
+
+/**
+ * Parse ?from= and ?to= from the URL.
+ * Accepts unix-second integers or ISO-8601 strings.
+ * Returns { from, to } in unix seconds; defaults to the current calendar month
+ * if absent or unparseable.
+ */
+function parseRange(url: string): { from: number; to: number } {
+	const u = new URL(url)
+	const now = Math.floor(Date.now() / 1000)
+
+	const parseParam = (raw: string | null): number | null => {
+		if (!raw) return null
+		// Try as a plain unix-second integer first
+		const asInt = Number(raw)
+		if (Number.isFinite(asInt) && asInt > 1000000) return asInt
+		// Try as ISO-8601
+		const parsed = Date.parse(raw)
+		if (Number.isFinite(parsed)) return Math.floor(parsed / 1000)
+		return null
+	}
+
+	const from = parseParam(u.searchParams.get('from'))
+	const to = parseParam(u.searchParams.get('to'))
+
+	if (from !== null && to !== null) return { from, to }
+
+	// Default: current calendar month
+	const d = new Date(now * 1000)
+	const monthStart = Math.floor(new Date(d.getFullYear(), d.getMonth(), 1).getTime() / 1000)
+	const monthEnd = Math.floor(
+		new Date(d.getFullYear(), d.getMonth() + 1, 0, 23, 59, 59).getTime() / 1000,
+	)
+	return { from: monthStart, to: monthEnd }
+}
+
+/** Format a unix-second timestamp as an ISO-8601 date string (UTC). */
+function toIso(unixSeconds: number): string {
+	return new Date(unixSeconds * 1000).toISOString().slice(0, 10)
+}
+
+export function createCalendarRoutes(config: CalendarRouteConfig): CalendarRouteHandlers {
+	return {
+		async month(ctx: RouteContext): Promise<Response> {
+			const denied = await config.authz.requirePublisher(ctx)
+			if (denied) return denied
+
+			const { from, to } = parseRange(ctx.request.url)
+
+			// Query content_items that have a dated placement within the range.
+			// COALESCE(publish_at, published_at) picks the relevant date:
+			//   - scheduled items have publish_at set
+			//   - published items have published_at set
+			// Items with neither are dateless drafts and are excluded by the HAVING clause.
+			const result = await ctx.db
+				.prepare(
+					`SELECT
+						id,
+						type,
+						title,
+						status,
+						slug,
+						COALESCE(publish_at, published_at) AS date_unix
+					FROM content_items
+					WHERE deleted_at IS NULL
+						AND COALESCE(publish_at, published_at) IS NOT NULL
+						AND COALESCE(publish_at, published_at) >= ?
+						AND COALESCE(publish_at, published_at) <= ?
+					ORDER BY COALESCE(publish_at, published_at) ASC`,
+				)
+				.bind(from, to)
+				.all<{
+					id: string
+					type: string
+					title: string
+					status: string
+					slug: string
+					date_unix: number
+				}>()
+
+			const rows = result.results ?? []
+
+			const items: CalendarRouteItem[] = rows.map((row) => ({
+				id: row.id,
+				type: row.type,
+				title: row.title,
+				status: row.status,
+				slug: row.slug,
+				date: toIso(row.date_unix),
+			}))
+
+			return json({ items })
+		},
+	}
+}