@happyvertical/smrt-content 0.40.65 → 0.40.67

package/dist/workbench.js

@@ -0,0 +1,719 @@
+import { t as playground_default } from "./chunks/playground-DryZ2Hm_.js";
+import ContentContributionsRoute from "./svelte/routes/ContentContributionsRoute.svelte";
+import ContentFactsRoute from "./svelte/routes/ContentFactsRoute.svelte";
+import ContentGovernanceRoute from "./svelte/routes/ContentGovernanceRoute.svelte";
+import ContentWorkspaceRoute from "./svelte/routes/ContentWorkspaceRoute.svelte";
+import PublishedArticleRoute from "./svelte/routes/PublishedArticleRoute.svelte";
+//#region src/route-loaders.ts
+function createContentRouteLoadError(status, message, code) {
+	const error = new Error(message);
+	error.name = "ContentRouteLoadError";
+	error.status = status;
+	error.code = code;
+	return error;
+}
+function getItemData(payload) {
+	if (!payload || typeof payload !== "object") return payload;
+	const wrappedPayload = payload;
+	if ("result" in wrappedPayload) return wrappedPayload.result;
+	if ("data" in wrappedPayload) return wrappedPayload.data;
+	return payload;
+}
+async function loadPublishedArticleRouteData({ fetch, slug, apiBasePath = "/api/v1" }) {
+	const contentResponse = await fetch(`${apiBasePath}/contents/by-slug?${new URLSearchParams({
+		slug,
+		status: "published"
+	}).toString()}`);
+	if (!contentResponse.ok) throw createContentRouteLoadError(contentResponse.status, "Failed to load article", "content_fetch_failed");
+	const content = getItemData(await contentResponse.json());
+	if (!content?.id) throw createContentRouteLoadError(404, "Article not found", "content_not_found");
+	const transparencyResponse = await fetch(`${apiBasePath}/contents/${content.id}/transparency`);
+	if (!transparencyResponse.ok) throw createContentRouteLoadError(transparencyResponse.status, "Failed to load transparency", "transparency_fetch_failed");
+	return {
+		content,
+		transparency: getItemData(await transparencyResponse.json())
+	};
+}
+//#endregion
+//#region src/svelte/routes/shared.ts
+var CONTENT_ROUTE_IDS = {
+	workspace: "content.workspace",
+	facts: "content.facts",
+	governance: "content.governance",
+	contributions: "content.contributions",
+	article: "content.article"
+};
+var CONTENT_ROUTE_META = {
+	workspace: {
+		id: CONTENT_ROUTE_IDS.workspace,
+		title: "Contents",
+		description: "Author, review, and publish content records against the content module workflows.",
+		defaultPath: "/workspace",
+		nav: {
+			label: "Workspace",
+			description: "Authoring and publishing workspace",
+			icon: "file-text",
+			order: 10,
+			group: "content"
+		}
+	},
+	governance: {
+		id: CONTENT_ROUTE_IDS.governance,
+		title: "Governance Admin",
+		description: "Manage review policies, profiles, and publication assignments for governed content.",
+		defaultPath: "/governance",
+		nav: {
+			label: "Governance",
+			description: "Policy, profile, and assignment management",
+			icon: "shield-check",
+			order: 20,
+			group: "content"
+		}
+	},
+	facts: {
+		id: CONTENT_ROUTE_IDS.facts,
+		title: "Fact Catalog",
+		description: "Browse extracted facts, search by text or domain, and confirm what content workflows can cite.",
+		defaultPath: "/facts",
+		nav: {
+			label: "Facts",
+			description: "Browse indexed facts and confidence",
+			icon: "sparkles",
+			order: 15,
+			group: "content"
+		}
+	},
+	contributions: {
+		id: CONTENT_ROUTE_IDS.contributions,
+		title: "Contribution Intake and Review",
+		description: "Review contributor submissions, moderation state, and promotion flows into content.",
+		defaultPath: "/contributions",
+		nav: {
+			label: "Contributions",
+			description: "Contributor intake, moderation, and promotion",
+			icon: "inbox",
+			order: 30,
+			group: "content"
+		}
+	},
+	article: {
+		id: CONTENT_ROUTE_IDS.article,
+		title: "Published article",
+		description: "Render a published content record with its public transparency information.",
+		defaultPath: "/articles/[slug]",
+		loadKind: "page"
+	}
+};
+var CONTENT_NAV_ROUTE_KEYS = [
+	"workspace",
+	"facts",
+	"governance",
+	"contributions"
+];
+function createContentRouteNavigation(pathOverrides = {}) {
+	return CONTENT_NAV_ROUTE_KEYS.map((routeKey) => {
+		const route = CONTENT_ROUTE_META[routeKey];
+		return {
+			routeId: route.id,
+			href: pathOverrides[route.id] || route.defaultPath,
+			label: route.nav.label,
+			description: route.nav.description,
+			icon: route.nav.icon,
+			order: route.nav.order,
+			group: route.nav.group
+		};
+	}).sort((left, right) => (left.order || 0) - (right.order || 0));
+}
+createContentRouteNavigation();
+//#endregion
+//#region src/route-module.ts
+var CONTENT_ROUTE_MODULE = {
+	packageName: "@happyvertical/smrt-content",
+	displayName: "Content",
+	description: "Package-owned route surfaces for authoring, facts, governance, contributions, and published article rendering.",
+	routes: {
+		workspace: {
+			...CONTENT_ROUTE_META.workspace,
+			component: ContentWorkspaceRoute,
+			tags: [
+				"content",
+				"authoring",
+				"admin"
+			]
+		},
+		facts: {
+			...CONTENT_ROUTE_META.facts,
+			component: ContentFactsRoute,
+			tags: [
+				"content",
+				"facts",
+				"admin"
+			]
+		},
+		governance: {
+			...CONTENT_ROUTE_META.governance,
+			component: ContentGovernanceRoute,
+			tags: [
+				"content",
+				"governance",
+				"admin"
+			]
+		},
+		contributions: {
+			...CONTENT_ROUTE_META.contributions,
+			component: ContentContributionsRoute,
+			tags: [
+				"content",
+				"contributions",
+				"admin"
+			]
+		},
+		article: {
+			...CONTENT_ROUTE_META.article,
+			component: PublishedArticleRoute,
+			load: loadPublishedArticleRouteData,
+			tags: [
+				"content",
+				"article",
+				"public"
+			]
+		}
+	}
+};
+//#endregion
+//#region src/workbench.ts
+var sampleContents = [{
+	id: "content-workbench-brief",
+	slug: "workbench-editorial-brief",
+	title: "Workbench Editorial Brief",
+	description: "A draft content record used to exercise the shared route shell.",
+	body: "## Editorial Brief\n\nThis fixture is served by the workbench route module so the authoring route can render inline.",
+	bodyFormat: "markdown",
+	author: "Content Systems",
+	type: "article",
+	status: "draft",
+	state: "active",
+	source: "manual",
+	factIds: ["fact-workbench-route"],
+	createdAt: "2026-03-20T12:00:00.000Z",
+	updatedAt: "2026-03-20T12:00:00.000Z"
+}, {
+	id: "content-workbench-published",
+	slug: "shared-route-workbench",
+	title: "Shared Route Workbench",
+	description: "Published sample content with a slug so the workspace can show the public route affordance.",
+	body: "Shared routes render inside one Workbench app instead of redirecting to package-local dev servers.",
+	bodyFormat: "markdown",
+	author: "Content Ops",
+	type: "article",
+	status: "published",
+	state: "active",
+	source: "manual",
+	publish_date: "2026-03-21T09:00:00.000Z",
+	factIds: ["fact-workbench-route", "fact-governance-visible"],
+	createdAt: "2026-03-19T15:00:00.000Z",
+	updatedAt: "2026-03-21T09:00:00.000Z"
+}];
+var sampleFacts = [{
+	id: "fact-workbench-route",
+	textRaw: "Workbench route demos render inside the shared workbench host.",
+	textRefined: "Workbench route demos render inside the shared workbench host.",
+	status: "active",
+	domain: "developer-tools",
+	confidence: .94,
+	sourceCount: 3,
+	metadata: {
+		package: "@happyvertical/smrt-content",
+		source: "workbench"
+	},
+	createdAt: "2026-03-20T12:00:00.000Z",
+	updatedAt: "2026-03-20T12:00:00.000Z"
+}, {
+	id: "fact-governance-visible",
+	textRaw: "Governance policies should be visible before publishing.",
+	textRefined: "Governance policies should be visible before publishing.",
+	status: "active",
+	domain: "content-governance",
+	confidence: .88,
+	sourceCount: 2,
+	metadata: { policy: "facts" },
+	createdAt: "2026-03-18T16:00:00.000Z",
+	updatedAt: "2026-03-19T10:00:00.000Z"
+}];
+var sampleGovernanceDefinitions = {
+	effective: {
+		policies: [{
+			id: "policy-facts",
+			key: "facts",
+			label: "Facts review",
+			kind: "facts",
+			instructions: "Compare claims against linked facts before publication.",
+			enabled: true
+		}, {
+			id: "policy-style",
+			key: "style",
+			label: "Style review",
+			kind: "custom",
+			instructions: "Apply editorial style and clarity guidelines.",
+			enabled: true
+		}],
+		profiles: [{
+			id: "profile-publication",
+			key: "publication",
+			label: "Publication",
+			description: "Required before governed content can be published.",
+			enabled: true,
+			requirements: [{
+				policyKey: "facts",
+				label: "Facts review",
+				blocking: true,
+				acceptedStatuses: ["passed"]
+			}, {
+				policyKey: "style",
+				label: "Style review",
+				blocking: false,
+				acceptedStatuses: ["passed", "warning"]
+			}]
+		}],
+		assignments: [{
+			id: "assignment-article",
+			key: "article",
+			label: "Articles",
+			contentType: "article",
+			contentVariant: null,
+			enabled: true,
+			factLinkingEnabled: true,
+			transparencyEnabled: true,
+			publicationProfileKey: "publication",
+			correctionProfileKey: null,
+			enforcePublishReadiness: true,
+			defaultFactRelationship: "supports"
+		}]
+	},
+	persisted: {
+		policies: [{
+			id: "policy-style",
+			key: "style",
+			label: "Style review",
+			kind: "custom",
+			instructions: "Apply editorial style and clarity guidelines.",
+			enabled: true
+		}],
+		profiles: [{
+			id: "profile-publication",
+			key: "publication",
+			label: "Publication",
+			description: "Required before governed content can be published.",
+			enabled: true,
+			requirements: [{
+				policyKey: "facts",
+				label: "Facts review",
+				blocking: true,
+				acceptedStatuses: ["passed"]
+			}, {
+				policyKey: "style",
+				label: "Style review",
+				blocking: false,
+				acceptedStatuses: ["passed", "warning"]
+			}]
+		}],
+		assignments: [{
+			id: "assignment-article",
+			key: "article",
+			label: "Articles",
+			contentType: "article",
+			contentVariant: null,
+			enabled: true,
+			factLinkingEnabled: true,
+			transparencyEnabled: true,
+			publicationProfileKey: "publication",
+			correctionProfileKey: null,
+			enforcePublishReadiness: true,
+			defaultFactRelationship: "supports"
+		}]
+	}
+};
+var sampleContributionTypes = [{
+	id: "type-article",
+	key: "article",
+	label: "Article pitch",
+	enabled: true,
+	allowedChannels: ["web", "email"],
+	allowText: true,
+	allowFiles: true,
+	allowEmptyText: false,
+	intakeRules: { requireTitle: true }
+}, {
+	id: "type-field-report",
+	key: "field-report",
+	label: "Field report",
+	enabled: true,
+	allowedChannels: ["web"],
+	allowText: true,
+	allowFiles: false,
+	allowEmptyText: false
+}];
+var sampleContributors = [{
+	id: "contributor-taylor",
+	email: "taylor@example.com",
+	name: "Taylor Rowan",
+	trustLevel: "trusted"
+}, {
+	id: "contributor-jordan",
+	email: "jordan@example.com",
+	name: "Jordan Lee",
+	trustLevel: "new"
+}];
+var sampleContributions = [{
+	id: "contribution-spring-guide",
+	contributorId: "contributor-taylor",
+	contributionTypeKey: "article",
+	status: "needs_changes",
+	intakeDecision: "needs_changes",
+	channel: "web",
+	title: "Spring buyer guide",
+	description: "Draft guide with sourcing notes for editorial review.",
+	body: "The spring buyer guide draft includes product comparisons and sourcing notes.",
+	contributorEmail: "taylor@example.com",
+	contributorName: "Taylor Rowan",
+	revisionCount: 2,
+	editorNotes: "Please tighten the sourcing notes in the opening section.",
+	updatedAt: "2026-03-20T15:18:00.000Z"
+}, {
+	id: "contribution-field-report",
+	contributorId: "contributor-jordan",
+	contributionTypeKey: "field-report",
+	status: "submitted",
+	intakeDecision: "submitted",
+	channel: "web",
+	title: "Field report: Pacific logistics",
+	description: "Field notes from the Pacific corridor.",
+	body: "Updated shipping windows, route constraints, and operator interviews.",
+	contributorEmail: "jordan@example.com",
+	contributorName: "Jordan Lee",
+	revisionCount: 1,
+	updatedAt: "2026-03-18T10:40:00.000Z"
+}];
+function cloneValue(value) {
+	if (value === void 0) return value;
+	return JSON.parse(JSON.stringify(value));
+}
+function buildResponse(data) {
+	return {
+		data: cloneValue(data),
+		success: true
+	};
+}
+function upsertByIdOrKey(items, value, prefix) {
+	const id = value.id || `${prefix}-${value.key || items.length + 1}`;
+	const nextValue = {
+		...value,
+		id
+	};
+	const index = items.findIndex((item) => item.id === id || Boolean(value.key && item.key === value.key));
+	if (index === -1) return [...items, nextValue];
+	const nextItems = [...items];
+	nextItems[index] = {
+		...nextItems[index],
+		...nextValue
+	};
+	return nextItems;
+}
+function createContentWorkbenchClient() {
+	let contents = cloneValue(sampleContents);
+	let facts = cloneValue(sampleFacts);
+	let policies = cloneValue(sampleGovernanceDefinitions.effective.policies);
+	let profiles = cloneValue(sampleGovernanceDefinitions.effective.profiles);
+	let assignments = cloneValue(sampleGovernanceDefinitions.effective.assignments);
+	let contributionTypes = cloneValue(sampleContributionTypes);
+	let contributors = cloneValue(sampleContributors);
+	let contributions = cloneValue(sampleContributions);
+	const getDefinitions = () => ({
+		effective: {
+			policies: cloneValue(policies),
+			profiles: cloneValue(profiles),
+			assignments: cloneValue(assignments)
+		},
+		persisted: {
+			policies: cloneValue(policies),
+			profiles: cloneValue(profiles),
+			assignments: cloneValue(assignments)
+		}
+	});
+	const resolveGovernance = (type, variant) => {
+		const assignment = assignments.find((item) => item.contentType === type && (item.contentVariant || null) === (variant || null)) || assignments.find((item) => item.contentType === type) || assignments[0] || null;
+		return {
+			isGoverned: Boolean(assignment),
+			factLinkingEnabled: assignment?.factLinkingEnabled ?? true,
+			transparencyEnabled: assignment?.transparencyEnabled ?? true,
+			publicationProfileKey: assignment?.publicationProfileKey || null,
+			correctionProfileKey: assignment?.correctionProfileKey || null,
+			enforcePublishReadiness: assignment?.enforcePublishReadiness ?? Boolean(assignment),
+			defaultFactRelationship: assignment?.defaultFactRelationship || "supports",
+			reviewPolicies: cloneValue(policies),
+			availableProfiles: cloneValue(profiles),
+			assignment: cloneValue(assignment)
+		};
+	};
+	const updateContributionStatus = (id, status, extra = {}) => {
+		contributions = contributions.map((item) => item.id === id ? {
+			...item,
+			status,
+			intakeDecision: status,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...extra
+		} : item);
+		return contributions.find((item) => item.id === id) || null;
+	};
+	const getContributionTypes = () => ({
+		effective: cloneValue(contributionTypes),
+		persisted: cloneValue(contributionTypes)
+	});
+	return {
+		contents: {
+			list: async () => buildResponse(contents),
+			get: async (id) => buildResponse(contents.find((item) => item.id === id) || contents[0]),
+			create: async (content) => {
+				const nextContent = {
+					type: "article",
+					status: "draft",
+					state: "active",
+					source: "manual",
+					...content,
+					id: content.id || `content-workbench-${contents.length + 1}`,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				contents = [nextContent, ...contents];
+				return buildResponse(nextContent);
+			},
+			update: async (id, updates) => {
+				contents = contents.map((item) => item.id === id ? {
+					...item,
+					...updates,
+					id,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				} : item);
+				return buildResponse(contents.find((item) => item.id === id) || contents[0]);
+			},
+			delete: async (id) => {
+				contents = contents.filter((item) => item.id !== id);
+				return buildResponse(void 0);
+			},
+			browseFacts: async (query = "", _options = {}) => {
+				const normalizedQuery = query.trim().toLowerCase();
+				facts = cloneValue(sampleFacts);
+				return buildResponse(normalizedQuery ? facts.filter((fact) => [
+					fact.textRaw,
+					fact.textRefined,
+					fact.domain,
+					JSON.stringify(fact.metadata || {})
+				].join(" ").toLowerCase().includes(normalizedQuery)) : facts);
+			},
+			getGovernanceDefinitions: async () => buildResponse(getDefinitions()),
+			resolveGovernance: async (options) => buildResponse(resolveGovernance(options.type, options.variant))
+		},
+		contentGovernancePolicies: {
+			create: async (policy) => {
+				policies = upsertByIdOrKey(policies, policy, "policy");
+				return buildResponse(policies[policies.length - 1]);
+			},
+			update: async (id, policy) => {
+				policies = upsertByIdOrKey(policies, {
+					...policy,
+					id
+				}, "policy");
+				return buildResponse(policies.find((item) => item.id === id) || policies[0]);
+			},
+			delete: async (id) => {
+				policies = policies.filter((item) => item.id !== id);
+				return buildResponse(void 0);
+			}
+		},
+		contentGovernanceProfiles: {
+			create: async (profile) => {
+				profiles = upsertByIdOrKey(profiles, profile, "profile");
+				return buildResponse(profiles[profiles.length - 1]);
+			},
+			update: async (id, profile) => {
+				profiles = upsertByIdOrKey(profiles, {
+					...profile,
+					id
+				}, "profile");
+				return buildResponse(profiles.find((item) => item.id === id) || profiles[0]);
+			},
+			delete: async (id) => {
+				profiles = profiles.filter((item) => item.id !== id);
+				return buildResponse(void 0);
+			}
+		},
+		contentGovernanceAssignments: {
+			create: async (assignment) => {
+				assignments = upsertByIdOrKey(assignments, assignment, "assignment");
+				return buildResponse(assignments[assignments.length - 1]);
+			},
+			update: async (id, assignment) => {
+				assignments = upsertByIdOrKey(assignments, {
+					...assignment,
+					id
+				}, "assignment");
+				return buildResponse(assignments.find((item) => item.id === id) || assignments[0]);
+			},
+			delete: async (id) => {
+				assignments = assignments.filter((item) => item.id !== id);
+				return buildResponse(void 0);
+			}
+		},
+		contentContributions: {
+			getContributionTypes: async () => buildResponse(getContributionTypes()),
+			listInbox: async () => buildResponse(contributions),
+			listForContributor: async (options) => buildResponse(contributions.filter((item) => options.contributorId ? item.contributorId === options.contributorId : item.contributorEmail === options.contributorEmail)),
+			submitWebContribution: async (payload) => {
+				const contributor = contributors.find((item) => item.email === payload.contributorEmail);
+				const nextContribution = {
+					id: `contribution-workbench-${contributions.length + 1}`,
+					contributorId: contributor?.id,
+					contributionTypeKey: payload.typeKey || payload.contributionTypeKey,
+					status: "submitted",
+					intakeDecision: "submitted",
+					channel: "web",
+					title: payload.title,
+					description: payload.description,
+					body: payload.body,
+					contributorEmail: payload.contributorEmail,
+					contributorName: payload.contributorName,
+					revisionCount: 1,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				contributions = [nextContribution, ...contributions];
+				return buildResponse({ contribution: nextContribution });
+			},
+			ingestEmailContribution: async (payload) => buildResponse({ contribution: {
+				...payload,
+				id: `contribution-email-${contributions.length + 1}`,
+				status: "submitted"
+			} }),
+			appendRevision: async (id) => buildResponse(updateContributionStatus(id, "submitted", { revisionCount: (contributions.find((item) => item.id === id)?.revisionCount || 0) + 1 })),
+			requestChanges: async (id) => buildResponse(updateContributionStatus(id, "needs_changes")),
+			approve: async (id) => buildResponse(updateContributionStatus(id, "approved", { approvedAt: (/* @__PURE__ */ new Date()).toISOString() })),
+			reject: async (id) => buildResponse(updateContributionStatus(id, "rejected", { rejectedAt: (/* @__PURE__ */ new Date()).toISOString() })),
+			withdraw: async (id) => buildResponse(updateContributionStatus(id, "withdrawn", { withdrawnAt: (/* @__PURE__ */ new Date()).toISOString() })),
+			promote: async (id) => buildResponse(updateContributionStatus(id, "promoted", { promotedAt: (/* @__PURE__ */ new Date()).toISOString() }))
+		},
+		contentContributionTypes: {
+			create: async (type) => {
+				contributionTypes = upsertByIdOrKey(contributionTypes, type, "contribution-type");
+				return buildResponse(contributionTypes[contributionTypes.length - 1]);
+			},
+			update: async (id, type) => {
+				contributionTypes = upsertByIdOrKey(contributionTypes, {
+					...type,
+					id
+				}, "contribution-type");
+				return buildResponse(contributionTypes.find((item) => item.id === id) || contributionTypes[0]);
+			},
+			delete: async (id) => {
+				contributionTypes = contributionTypes.filter((item) => item.id !== id);
+				return buildResponse(void 0);
+			}
+		},
+		contentContributors: {
+			list: async () => buildResponse(contributors),
+			create: async (contributor) => {
+				const nextContributor = {
+					...contributor,
+					id: contributor.id || `contributor-${contributors.length + 1}`
+				};
+				contributors = [nextContributor, ...contributors];
+				return buildResponse(nextContributor);
+			},
+			update: async (id, contributor) => {
+				contributors = contributors.map((item) => item.id === id ? {
+					...item,
+					...contributor,
+					id
+				} : item);
+				return buildResponse(contributors.find((item) => item.id === id) || contributors[0]);
+			},
+			delete: async (id) => {
+				contributors = contributors.filter((item) => item.id !== id);
+				return buildResponse(void 0);
+			}
+		}
+	};
+}
+var contentRouteProps = {
+	embedded: true,
+	client: createContentWorkbenchClient(),
+	navigation: createContentRouteNavigation({
+		[CONTENT_ROUTE_IDS.workspace]: "#content-workspace",
+		[CONTENT_ROUTE_IDS.facts]: "#content-facts",
+		[CONTENT_ROUTE_IDS.governance]: "#content-governance",
+		[CONTENT_ROUTE_IDS.contributions]: "#content-contributions"
+	})
+};
+var articleRouteData = {
+	content: {
+		id: "workbench-article",
+		slug: "workbench-reference-article",
+		title: "Workbench Reference Article",
+		description: "Inline route sample rendered inside the shared SMRT workbench.",
+		author: "Content Systems",
+		body: "## Reference Article\n\nThis article route is rendered without redirecting to a package-local dev server.",
+		bodyFormat: "markdown",
+		publish_date: "2026-03-20T12:00:00.000Z",
+		status: "published"
+	},
+	transparency: null
+};
+var workbench_default = {
+	packageName: "@happyvertical/smrt-content",
+	displayName: "Content",
+	description: "Workbench surfaces for content authoring, governance, facts, contributions, articles, and package previews.",
+	routeModules: [{
+		...CONTENT_ROUTE_MODULE,
+		routes: {
+			workspace: {
+				...CONTENT_ROUTE_MODULE.routes.workspace,
+				props: contentRouteProps
+			},
+			facts: {
+				...CONTENT_ROUTE_MODULE.routes.facts,
+				props: contentRouteProps
+			},
+			governance: {
+				...CONTENT_ROUTE_MODULE.routes.governance,
+				props: contentRouteProps
+			},
+			contributions: {
+				...CONTENT_ROUTE_MODULE.routes.contributions,
+				props: contentRouteProps
+			},
+			article: {
+				...CONTENT_ROUTE_MODULE.routes.article,
+				props: {
+					data: articleRouteData,
+					backHref: "#content-workspace"
+				}
+			}
+		}
+	}],
+	recommendedCommands: [{
+		id: "content:test",
+		label: "Test",
+		command: "pnpm --filter @happyvertical/smrt-content test"
+	}, {
+		id: "content:typecheck",
+		label: "Typecheck",
+		command: "pnpm --filter @happyvertical/smrt-content typecheck"
+	}],
+	examples: [{
+		id: "content:playground",
+		title: "Content playground module",
+		path: "src/svelte/playground.ts",
+		source: "playground"
+	}]
+};
+//#endregion
+export { workbench_default as default, playground_default as playground };
+
+//# sourceMappingURL=workbench.js.map