studiocms 0.2.0 → 0.4.0

package/frontend/pages/studiocms_api/_handlers/sdk.ts

@@ -0,0 +1,129 @@
+import { SDKCore } from 'studiocms:sdk';
+import { HttpApiBuilder } from '@effect/platform';
+import { StudioCMSSDKApiSpec } from '@withstudiocms/api-spec';
+import { SDKAPIError } from '@withstudiocms/api-spec/sdk';
+import { experimental_AstroContainer as AstroContainer } from 'astro/container';
+import { Effect, Layer } from 'effect';
+import { parseMarkdown } from '#utils/tinyMDParser';
+// biome-ignore lint/suspicious/noTsIgnore: Typechecker override for Astro component imports
+// @ts-ignore - This is an Astro component, so we ignore TypeScript errors for this import
+import UserListItems from '../../../components/dashboard/user-mgmt/UserListItems.astro';
+import { ProcessChangelog } from './_utils/changelog.js';
+
+/**
+ * Utility function to catch errors in the Effect chain and convert them into SDKAPIError instances with a provided message.
+ */
+const catchError = (message: string) =>
+	Effect.catchAll((error: Error) => new SDKAPIError({ error: error.message || message }));
+
+/**
+ * Utility function to create a response object for the changelog endpoint.
+ */
+const makeChangelogResponse = (changelog: string) => ({ success: true, changelog });
+
+/**
+ * Utility function to create a response object for the latest version cache update endpoint.
+ */
+const makeVersionResponse = (latestVersion: { version: string; lastCacheUpdate: Date }) => ({
+	success: true,
+	latestVersion,
+});
+
+/**
+ * SDK API Handler - Handles all API routes related to the StudioCMS SDK, including changelog generation and page listing.
+ *
+ * Endpoints:
+ * - POST /sdk/full-changelog.json: Generates and returns the full changelog in markdown format.
+ * - GET /sdk/list-pages: Retrieves a list of all SDK documentation pages with their last updated timestamp.
+ * - POST /sdk/update-latest-version-cache: Updates the cache for the latest SDK version and returns the new version information.
+ *
+ * Each endpoint is implemented as an Effect that interacts with the SDKCore and other utilities to perform the necessary operations.
+ */
+export const SDKAPIHandler = HttpApiBuilder.group(StudioCMSSDKApiSpec, 'sdk', (handlers) =>
+	handlers
+		.handle('fullChangelog', () =>
+			ProcessChangelog.pipe(
+				Effect.flatMap(({ runPipeline }) => runPipeline()),
+				Effect.map(makeChangelogResponse),
+				ProcessChangelog.Provide,
+				catchError('Failed to generate changelog')
+			)
+		)
+		.handle('updateLatestVersionCache', () =>
+			SDKCore.pipe(
+				Effect.flatMap((sdk) => sdk.UPDATE.latestVersion()),
+				Effect.map(makeVersionResponse),
+				catchError('Failed to update latest version cache')
+			)
+		)
+);
+
+/**
+ * SDK Utilities Handler - Handles utility API routes related to the StudioCMS SDK, such as rendering markdown content.
+ */
+export const SDKUtilsHandler = HttpApiBuilder.group(StudioCMSSDKApiSpec, 'utils', (handlers) =>
+	handlers
+		.handle(
+			'renderMarkdown',
+			Effect.fn(
+				({
+					urlParams: { content: queryParamContent, 'preload-content': preloadContent },
+					payload: { content: payloadContent },
+				}) =>
+					Effect.try({
+						try: () => {
+							let markdownContent: string | undefined;
+
+							if (payloadContent) {
+								markdownContent = payloadContent;
+							} else if (queryParamContent && queryParamContent !== 'null') {
+								markdownContent = queryParamContent;
+							} else if (preloadContent && preloadContent !== 'null') {
+								markdownContent = preloadContent;
+							} else {
+								markdownContent = 'No content provided';
+							}
+
+							const html = parseMarkdown(markdownContent);
+
+							return { html };
+						},
+						catch: () => new SDKAPIError({ error: 'Failed to render markdown' }),
+					})
+			)
+		)
+		.handle(
+			'userListItems',
+			Effect.fn(({ payload }) =>
+				Effect.tryPromise({
+					try: async () => {
+						const container = await AstroContainer.create();
+
+						let html = 'fail';
+
+						try {
+							html = await container.renderToString(UserListItems, {
+								props: payload,
+							});
+						} catch (error) {
+							console.error('Error rendering UserListItems:', error);
+							throw new SDKAPIError({ error: 'Failed to render user list items' });
+						}
+
+						return {
+							html,
+						};
+					},
+					catch: () => new SDKAPIError({ error: 'Failed to render user list items' }),
+				})
+			)
+		)
+);
+
+/**
+ * Live SDK API Handler Layer - Provides the SDKAPIHandler with all necessary dependencies for live operation.
+ */
+export const SDKAPILive = HttpApiBuilder.api(StudioCMSSDKApiSpec).pipe(
+	Layer.provide(SDKAPIHandler),
+	Layer.provide(SDKUtilsHandler)
+);

package/frontend/pages/studiocms_api/_middleware/astroLocals.ts

@@ -0,0 +1,36 @@
+import {
+	AstroLocalsMiddleware,
+	AstroLocalsMissing,
+	CurrentUser,
+} from '@withstudiocms/api-spec/astro-context';
+import { Effect, Layer } from 'effect';
+import { AstroAPIContext } from 'effectify/astro/context';
+
+/**
+ * Live implementation of the Astro locals authorization middleware.
+ */
+export const AstroLocalsAuthLive = Layer.effect(
+	AstroLocalsMiddleware,
+	Effect.gen(function* () {
+		return {
+			localUser: (_) =>
+				Effect.gen(function* () {
+					const { locals } = yield* AstroAPIContext;
+					const user = locals.StudioCMS?.security?.userSessionData;
+					const userPermissionLevel = locals.StudioCMS?.security?.userPermissionLevel || {
+						isVisitor: false,
+						isEditor: false,
+						isAdmin: false,
+						isOwner: false,
+					};
+					if (user) {
+						return CurrentUser.of({
+							...user,
+							userPermissionLevel,
+						});
+					}
+					return yield* new AstroLocalsMissing();
+				}),
+		};
+	})
+);

package/frontend/pages/studiocms_api/_middleware/restApi.ts

@@ -0,0 +1,56 @@
+import { SDKCore } from 'studiocms:sdk';
+import {
+	RestAPIAuthorization,
+	RestAPIError,
+	type RestAPIUser,
+	Unauthorized,
+} from '@withstudiocms/api-spec/rest-api';
+import { Effect, Layer, Redacted } from 'effect';
+
+/**
+ * Utility function to check if the provided user object is a valid RestAPIUser.
+ *
+ * This function takes a user object that may be `false` or a valid `RestAPIUser`.
+ * If the user is valid, it returns an Effect that succeeds with the user.
+ * If the user is `false`, it returns an Effect that fails with an `Unauthorized` error.
+ *
+ * @param user - The user object to validate, which can be `false` or a `RestAPIUser`.
+ * @returns An Effect that either succeeds with the valid RestAPIUser or fails with an Unauthorized error.
+ */
+const isUser = (
+	user: false | typeof RestAPIUser.Type
+): Effect.Effect<RestAPIUser, Unauthorized, never> =>
+	user ? Effect.succeed(user) : Effect.fail(new Unauthorized());
+
+/**
+ * Live implementation of the RestAPIAuthorization middleware.
+ */
+export const RestAPIAuthorizationLive = Layer.effect(
+	RestAPIAuthorization,
+	Effect.gen(function* () {
+		return {
+			restApiToken: Effect.fn(
+				(token: Redacted.Redacted<string>) =>
+					SDKCore.pipe(
+						Effect.flatMap(({ REST_API }) => REST_API.tokens.verify(Redacted.value(token))),
+						Effect.flatMap(isUser)
+					),
+				Effect.catchTags({
+					DBClientInitializationError: () =>
+						new RestAPIError({
+							error: 'Database client initialization failed during token verification',
+						}),
+					DBCallbackFailure: () =>
+						new RestAPIError({ error: 'Database error during token verification' }),
+					SDKInitializationError: () =>
+						new RestAPIError({ error: 'SDK initialization error during token verification' }),
+					NotFoundError: () => new RestAPIError({ error: 'Token error during verification' }),
+					QueryError: () =>
+						new RestAPIError({ error: 'Database query error during token verification' }),
+					QueryParseError: () =>
+						new RestAPIError({ error: 'Database query parse error during token verification' }),
+				})
+			),
+		};
+	})
+);

package/frontend/pages/studiocms_api/integrations/[...all].ts

@@ -0,0 +1,8 @@
+import type { APIRoute } from 'astro';
+import { HttpApiToAstroRoute } from 'effectify/astro/HttpApi';
+import { IntegrationsAPILive } from '../_handlers/integration/index.js';
+
+/**
+ * Integrations API Route - Combines all Integrations API handlers into a single Astro route for serving the integrations-related API endpoints.
+ */
+export const ALL: APIRoute = HttpApiToAstroRoute(IntegrationsAPILive);

package/frontend/scripts/formdata.ts

@@ -0,0 +1,219 @@
+import { ParseResult } from 'effect';
+import * as Schema from 'effect/Schema';
+
+/**
+ * Convenience function to create a Schema from a property of a Schema. This is useful for creating Schemas for objects that are derived from FormData, where the keys are not known at compile time. It allows us to define the shape of the object we want to create from the FormData, while still being able to validate the individual properties using the original Schema.
+ *
+ * @param self - The original Schema that contains the property we want to extract.
+ * @param key - The key of the property we want to extract from the original Schema.
+ * @returns A new Schema that validates the value of the specified property from the original Schema.
+ */
+const FromKeyProperty = <Self extends Schema.Schema.All, Key extends PropertyKey>(
+	self: Self,
+	key: Key
+) => Schema.propertySignature(self).pipe(Schema.fromKey(key));
+
+/**
+ * Similar to FromKeyProperty, but makes the property optional and allows for a default value. This is useful for handling optional fields in the FormData, where the absence of a key should not cause validation to fail, and we want to provide a default value instead.
+ *
+ * @param self - The original Schema that contains the property we want to extract.
+ * @param key - The key of the property we want to extract from the original Schema.
+ * @returns A new Schema that validates the value of the specified property from the original Schema, but allows it to be optional and provides a default value if it is not present.
+ */
+const OptionalFromKeyProperty = <Self extends Schema.Schema.All, Key extends PropertyKey>(
+	self: Self,
+	key: Key
+) => Schema.optional(self).pipe(Schema.fromKey(key));
+
+/**
+ * Schema for validating that an input is an instance of FormData. This is used as a base for creating more complex Schemas that transform FormData into other shapes, such as objects with specific properties. It ensures that the input we are working with is indeed a FormData instance before we attempt to extract data from it.
+ *
+ * @remarks
+ * This Schema is used in conjunction with the ObjectFromFormData Schema, which transforms a FormData instance into a Record<string, string> object. By validating that the input is a FormData instance first, we can safely perform the transformation and handle any errors that may arise from invalid input.
+ */
+export const FormDataSchema = Schema.declare(
+	(input: unknown): input is FormData => input instanceof FormData,
+	{
+		title: 'FormData',
+		description: 'Schema for validating FormData instances',
+		identifier: 'FormData',
+	}
+);
+
+/**
+ * Schema for transforming a FormData instance into a Record<string, string> object. This is useful for handling form submissions, where we want to convert the FormData into a more usable format for processing. It validates that the input is a FormData instance, and then iterates over its entries to create a plain object with string keys and values.
+ *
+ * @remarks
+ * This Schema is used in the CreatePage and EditPage components to handle form submissions. By transforming the FormData into a Record<string, string>, we can easily access the form values using standard object property access, and we can also perform additional validation on the individual properties using other Schemas.
+ */
+export const ObjectFromFormData = Schema.transformOrFail(
+	FormDataSchema,
+	Schema.mutable(
+		Schema.Record({
+			key: Schema.String,
+			value: Schema.String,
+		})
+	),
+	{
+		strict: true,
+		decode: (input, _options, ast) => {
+			if (!(input instanceof FormData)) {
+				return ParseResult.fail(
+					new ParseResult.Type(ast, input, 'Input is not an instance of FormData')
+				);
+			}
+			const record: Record<string, string> = {};
+			for (const [key, value] of input.entries()) {
+				if (typeof key !== 'string' || typeof value !== 'string') {
+					return ParseResult.fail(
+						new ParseResult.Type(ast, input, 'FormData keys and values must be strings')
+					);
+				}
+				record[key] = value;
+			}
+			return ParseResult.succeed(record);
+		},
+		encode: (input) => {
+			const formData = new FormData();
+			for (const key in input) {
+				formData.append(key, input[key]);
+			}
+			return ParseResult.succeed(formData);
+		},
+	}
+);
+
+/**
+ * Schema for validating that a string is a valid slug. A slug is a URL-friendly string that typically consists of lowercase letters, numbers, hyphens, and slashes. This Schema ensures that the input string adheres to these rules, which is important for generating clean URLs for pages in the CMS. It checks that the string is lowercase, does not contain spaces or special characters (other than hyphens and slashes), and does not have leading or trailing hyphens or slashes.
+ *
+ * @remarks
+ * This Schema is used for validating the slug field when creating or editing pages. By enforcing a specific format for slugs, we can ensure that the generated URLs are consistent and SEO-friendly. If the input does not match the expected slug format, the Schema will fail with a descriptive error message.
+ */
+export const SlugSchema = Schema.transformOrFail(Schema.String, Schema.String, {
+	strict: true,
+	decode: (input, _options, ast) => {
+		if (typeof input !== 'string') {
+			return ParseResult.fail(new ParseResult.Type(ast, input, 'Input is not a string'));
+		}
+		const slugRegex = /^[a-z0-9]+(?:[-/][a-z0-9]+)*$/;
+		if (!slugRegex.test(input)) {
+			return ParseResult.fail(
+				new ParseResult.Type(
+					ast,
+					input,
+					'Slug must be lowercase and can only contain letters, numbers, hyphens, and slashes (no leading/trailing hyphens or slashes)'
+				)
+			);
+		}
+		return ParseResult.succeed(input);
+	},
+	encode: (input) => ParseResult.succeed(input),
+});
+
+/**
+ * Schema for validating the parent folder field, which can be either a string or null. This is used for handling the parent folder selection when creating or editing pages. The field can be a string representing the ID of the parent folder, or it can be null if the page does not have a parent folder. This Schema ensures that the input is either a valid string or null, and it also handles the case where the string "null" is passed, treating it as null.
+ */
+export const ParentFolderSchema = Schema.transformOrFail(
+	Schema.Union(Schema.String, Schema.Null),
+	Schema.Union(Schema.String, Schema.Null),
+	{
+		strict: true,
+		decode: (input, _options, ast) => {
+			if (typeof input === 'string') {
+				if (input === 'null') {
+					return ParseResult.succeed(null);
+				}
+				return ParseResult.succeed(input);
+			}
+			if (input === null) {
+				return ParseResult.succeed(null);
+			}
+			return ParseResult.fail(new ParseResult.Type(ast, input, 'Input must be a string or null'));
+		},
+		encode: (input) => ParseResult.succeed(input),
+	}
+);
+
+/**
+ * Schema for validating that an input is either a string or an array of strings, and transforming it into an array of strings. This is useful for handling form fields that can accept either a single value or multiple values, such as categories or tags. The Schema checks if the input is a string, and if so, it wraps it in an array. If the input is already an array of strings, it validates that all elements are strings and returns it as is. If the input does not match either of these formats, the Schema fails with an error message.
+ *
+ * @remarks
+ * This Schema is used for the categories and tags fields in the CreatePage and EditPage components. By allowing both a single string and an array of strings, we can provide flexibility in how users input data, while still ensuring that the final output is always an array of strings for consistent processing.
+ */
+export const StringOrStringArrayToStringArraySchema = Schema.transformOrFail(
+	Schema.Union(Schema.String, Schema.Array(Schema.String)),
+	Schema.Array(Schema.String),
+	{
+		strict: true,
+		decode: (input, _options, ast) => {
+			if (typeof input === 'string') {
+				const isStringifiedArray = /^\s*\[\s*("[^"]*"\s*,\s*)*("[^"]*"\s*)?\]\s*$/.test(input);
+				if (isStringifiedArray) {
+					try {
+						const parsed = JSON.parse(input);
+						if (Array.isArray(parsed) && parsed.every((item) => typeof item === 'string')) {
+							return ParseResult.succeed(parsed);
+						}
+					} catch {}
+				}
+				if (Array.isArray(input)) {
+					return ParseResult.succeed(input);
+				}
+				return ParseResult.succeed([input]);
+			}
+			if (Array.isArray(input) && input.every((item) => typeof item === 'string')) {
+				return ParseResult.succeed(input);
+			}
+			return ParseResult.fail(
+				new ParseResult.Type(ast, input, 'Input must be a string or an array of strings')
+			);
+		},
+		encode: (input) => ParseResult.succeed(input),
+	}
+);
+
+/**
+ * Schema for validating and transforming the data from the CreatePage form. This Schema defines the expected structure of the data that is submitted when creating a new page, including fields such as title, slug, description, package, showOnNav, heroImage, parentFolder, draft status, showAuthor, showContributors, categories, tags, and augments. It uses the previously defined Schemas for specific fields like SlugSchema and ParentFolderSchema to ensure that the data adheres to the expected formats.
+ */
+export const CreatePageDataFromFormDataObjectSchema = Schema.Struct({
+	title: FromKeyProperty(Schema.String, 'page-title'),
+	slug: FromKeyProperty(SlugSchema, 'page-slug'),
+	description: OptionalFromKeyProperty(Schema.String, 'page-description'),
+	package: FromKeyProperty(Schema.String, 'page-type'),
+	showOnNav: OptionalFromKeyProperty(Schema.BooleanFromString, 'show-in-nav'),
+	heroImage: OptionalFromKeyProperty(Schema.String, 'page-hero-image'),
+	parentFolder: Schema.optionalWith(ParentFolderSchema, {
+		default: () => null,
+	}).pipe(Schema.fromKey('parent-folder')),
+	draft: Schema.optional(Schema.BooleanFromString),
+	showAuthor: OptionalFromKeyProperty(Schema.BooleanFromString, 'show-author'),
+	showContributors: OptionalFromKeyProperty(Schema.BooleanFromString, 'show-contributors'),
+	categories: Schema.optionalWith(StringOrStringArrayToStringArraySchema, {
+		default: () => [],
+	}),
+	tags: Schema.optionalWith(StringOrStringArrayToStringArraySchema, {
+		default: () => [],
+	}),
+	augments: Schema.optional(Schema.Array(Schema.String)),
+});
+
+/**
+ * Schema for validating and transforming the data from the EditPage form. This Schema extends the CreatePageDataFromFormDataObjectSchema by adding additional fields that are relevant for editing an existing page, such as the page ID, content, content ID, and plugin fields. It ensures that all the necessary data for editing a page is present and correctly formatted, while still allowing for optional fields and providing default values where appropriate.
+ */
+export const EditPageDataFromFormDataObjectSchema = Schema.mutable(
+	Schema.Struct({
+		...CreatePageDataFromFormDataObjectSchema.fields,
+		id: FromKeyProperty(Schema.String, 'page-id'),
+		content: FromKeyProperty(Schema.String, 'page-content'),
+		contentId: FromKeyProperty(Schema.String, 'page-content-id'),
+		pluginFields: Schema.optionalWith(
+			Schema.Record({
+				key: Schema.String,
+				value: Schema.NullOr(Schema.String),
+			}),
+			{
+				default: () => ({}),
+			}
+		),
+	})
+);

package/frontend/setup-pages/3-done.astro

@@ -1,10 +1,7 @@
 ---
-import { Accordion, AccordionItem } from 'studiocms:ui/components/accordion';
 import { Card } from 'studiocms:ui/components/card';
 import PageHeader from '../components/first-time-setup/PageHeader.astro';
-import codeSnippet1 from '../components/first-time-setup/snippets/opt1-astro.config.diff?raw';
-import codeSnippet2 from '../components/first-time-setup/snippets/opt2-astro.config.diff?raw';
-import codeSnippet3 from '../components/first-time-setup/snippets/opt2-studiocms.config.diff?raw';
+import codeSnippet_studiocms from '../components/first-time-setup/snippets/studiocms.config.diff?raw';
 import Code from '../components/shared/Code.astro';
 import Layout from '../layouts/FirstTimeSetupLayout.astro';
 import { sharedProps } from './shared.js';
@@ -20,25 +17,12 @@ import { sharedProps } from './shared.js';
         </div>
 
         <div>
-            You're almost done! You can now start using StudioCMS after changing the following config option. If you have any questions, please reach out to us on our <a href="https://chat.studiocms.dev" target="_blank">Discord</a> server.
+            You're almost done! You can now start using StudioCMS after changing the following config option in your <code>studiocms.config.mjs</code> file. If you have any questions, please reach out to us on our <a href="https://chat.studiocms.dev" target="_blank">Discord</a> server.
         </div>
         <br />
 
-        <Accordion>
-            <AccordionItem>
-                <div slot="summary">Using StudioCMS with just the <code>astro.config.mjs</code></div>
-                 <Code code={codeSnippet1} ins='11' />
-            </AccordionItem>
-            <AccordionItem>
-                <div slot="summary">Using StudioCMS with the <code>studiocms.config.mjs</code></div>
-
-                <span>astro.config.mjs</span>
-                <Code code={codeSnippet2} />
-
-                <span>studiocms.config.mjs</span>
-                <Code ins="4" code={codeSnippet3} />
-            </AccordionItem>
-        </Accordion>
+        <span>studiocms.config.mjs</span>
+        <Code ins="5" code={codeSnippet_studiocms} />
 
     </Card>
 

package/frontend/setup-pages/studiocms_api/dashboard/step-2.ts

@@ -9,7 +9,7 @@ import {
 	OptionsResponse,
 	readAPIContextJson,
 } from '@withstudiocms/effect';
-import { z } from 'astro/zod';
+import { isValidEmail } from '#schemas/external-schemas';
 
 export const { POST, OPTIONS, ALL } = createEffectAPIRoutes(
 	{
@@ -85,15 +85,12 @@ export const { POST, OPTIONS, ALL } = createEffectAPIRoutes(
 				}
 
 				// If the email is invalid, return an error
-				const checkEmail = z
-					.string()
-					.email({ message: 'Email address is invalid' })
-					.safeParse(email);
+				const checkEmail = isValidEmail(email);
 
 				if (!checkEmail.success) {
 					return createJsonResponse(
 						{
-							error: checkEmail.error.errors.map((e) => e.message).join(', '),
+							error: checkEmail.error.message,
 						},
 						{
 							status: 400,

package/frontend/styles/dashboard-base.css

@@ -167,7 +167,6 @@ main {
 
 .container {
 	height: 100vh;
-	min-height: 100vh;
 	min-height: 100dvh;
 	max-height: 100vh;
 	max-width: 100%;

package/frontend/web-vitals/endpoint.ts

@@ -11,7 +11,8 @@ export const prerender = false;
 export const ALL: APIRoute = async ({ request }) => {
 	try {
 		const rawBody = await request.json();
-		const body = ServerMetricSchema.array().parse(rawBody);
+		const parser = Schema.decodeUnknownSync(Schema.Array(ServerMetricSchema));
+		const body = parser(rawBody);
 		const db = await runEffect(getAnalyticsDbClient(config.db.dialect));
 
 		const insert = db.withEncoder({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "studiocms",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A Community-Driven Astro native CMS. Built from the ground up by the Astro community.",
   "author": {
     "name": "withstudiocms",
@@ -56,6 +56,10 @@
     "studiocms": "./studiocms-cli.mjs"
   },
   "imports": {
+    "#client/*": {
+      "types": "./dist/client/*.d.ts",
+      "default": "./dist/client/*.js"
+    },
     "#consts": {
       "types": "./dist/consts.d.ts",
       "default": "./dist/consts.js"
@@ -127,6 +131,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./client/*": {
+      "types": "./dist/client/*.d.ts",
+      "default": "./dist/client/*.js"
+    },
     "./config": {
       "types": "./dist/config.d.ts",
       "default": "./dist/config.js"
@@ -163,10 +171,6 @@
       "types": "./dist/schemas/index.d.ts",
       "default": "./dist/schemas/index.js"
     },
-    "./schemas/renderer": {
-      "types": "./dist/schemas/config/rendererConfig.d.ts",
-      "default": "./dist/schemas/config/rendererConfig.js"
-    },
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "default": "./dist/runtime/index.js"
@@ -222,61 +226,61 @@
   "type": "module",
   "dependencies": {
     "@iconify-json/flat-color-icons": "^1.2.3",
-    "@iconify-json/simple-icons": "^1.2.66",
+    "@iconify-json/simple-icons": "^1.2.72",
     "@iconify-json/circle-flags": "^1.2.10",
-    "@inox-tools/runtime-logger": "^0.7.0",
+    "@inox-tools/runtime-logger": "^0.8.1",
     "@nanostores/i18n": "^1.2.2",
-    "@nanostores/persistent": "^1.2.0",
+    "@nanostores/persistent": "^1.3.3",
     "@outerbase/sdk-transform": "^1.0.8",
-    "@studiocms/ui": "^1.0.1",
-    "ace-builds": "^1.43.5",
+    "@studiocms/ui": "^1.1.2",
+    "ace-builds": "^1.43.6",
     "astro-integration-kit": "^0.19.1",
     "boxen": "^8.0.1",
-    "chalk": "^5.6.2",
     "diff": "^8.0.3",
-    "dompurify": "^3.3.1",
-    "dotenv": "^17.2.3",
+    "dompurify": "^3.3.2",
+    "dotenv": "^17.3.1",
     "fuse.js": "^7.1.0",
-    "jose": "^6.1.3",
+    "jose": "^6.2.0",
     "micromark": "^4.0.2",
     "micromark-extension-gfm": "^3.0.0",
-    "micromatch": "^4.0.8",
-    "magicast": "^0.5.1",
+    "magicast": "^0.5.2",
     "mdast-util-to-markdown": "^2.1.2",
     "mrmime": "^2.0.1",
-    "nanostores": "^1.1.0",
+    "nanostores": "^1.1.1",
     "package-manager-detector": "^1.6.0",
-    "semver": "^7.7.3",
+    "semver": "^7.7.4",
     "three": "0.170.0",
     "tinyglobby": "^0.2.15",
     "ultrahtml": "^1.6.0",
     "web-vitals": "^5.1.0",
-    "@withstudiocms/internal_helpers": "^0.1.0",
-    "@withstudiocms/auth-kit": "^0.1.2",
-    "@withstudiocms/config-utils": "^0.1.0",
-    "@withstudiocms/component-registry": "^0.1.2",
-    "@withstudiocms/cli-kit": "^0.2.0",
-    "@withstudiocms/effect": "^0.2.0",
-    "@withstudiocms/kysely": "^0.2.0",
+    "@withstudiocms/api-spec": "^0.3.0",
+    "@withstudiocms/internal_helpers": "^0.2.0",
+    "@withstudiocms/auth-kit": "^0.1.4",
+    "@withstudiocms/cli-kit": "^0.2.1",
+    "@withstudiocms/component-registry": "^0.1.4",
+    "@withstudiocms/config-utils": "^0.2.0",
+    "@withstudiocms/effect": "^0.4.0",
     "@withstudiocms/template-lang": "^0.1.0",
-    "@withstudiocms/sdk": "^0.2.0"
+    "@withstudiocms/kysely": "^0.2.1",
+    "@withstudiocms/sdk": "^0.3.0",
+    "effectify": "^0.1.0"
   },
   "devDependencies": {
     "@types/mdast": "^4.0.4",
-    "@types/micromatch": "^4.0.10",
     "@types/node": "^22.0.0",
     "@types/semver": "^7.7.1",
     "@types/three": "0.169.0",
-    "@types/pg": "^8.16.0",
+    "@types/pg": "^8.18.0",
     "typescript": "^5.9.3",
     "vite": "^6.3.4"
   },
   "peerDependencies": {
+    "@effect/platform": "^0.94.5",
     "@libsql/client": "^0.15.15",
     "astro": "^5.12.9",
-    "effect": "^3.19.14",
-    "pg": "^8.17.1",
-    "mysql2": "^3.16.0"
+    "effect": "^3.19.19",
+    "pg": "^8.20.0",
+    "mysql2": "^3.18.0"
   },
   "peerDependenciesMeta": {
     "@libsql/client": {