@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/Client.js

@@ -0,0 +1,41 @@
+import { i as ClientError, n as make$1, o as layer, s as make, t as ImportError } from "./DataTransfer-BmECvPHB.js";
+import { Cause, Effect, Exit, Layer, ManagedRuntime } from "effect";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { FetchHttpClient } from "effect/http";
+//#region ../cli/src/Client.ts
+/** One run owns its in-memory session and request scopes. Consume streams inside run's callback. */
+async function connectCms(options) {
+	const site = new URL(options.site);
+	const transport = options.fetch ? layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.Fetch, options.fetch))) : layer;
+	const runtime = ManagedRuntime.make(Layer.merge(NodeServices.layer, transport));
+	const result = async (operation) => {
+		const exit = await runtime.runPromiseExit(Effect.scoped(operation));
+		if (Exit.isSuccess(exit)) return exit.value;
+		throw Cause.squash(exit.cause);
+	};
+	try {
+		const connection = await runtime.runPromise(make(site, options.session));
+		const data = make$1(connection);
+		const client = {
+			site,
+			get session() {
+				return connection.session;
+			},
+			run: (operation) => result(operation(connection.api)),
+			signIn: (email, password) => result(connection.signIn(email, password)),
+			initialize: (input) => result(connection.initialize(input)),
+			signOut: () => result(connection.signOut()),
+			resetPassword: (token, newPassword) => result(connection.resetPassword(token, newPassword)),
+			export: (file, force) => result(data.export(file, force)),
+			import: (file, settings) => result(data.import(file, settings)),
+			close: () => runtime.dispose()
+		};
+		if (options.credentials) await client.signIn(options.credentials.email, options.credentials.password);
+		return client;
+	} catch (error) {
+		await runtime.dispose();
+		throw error;
+	}
+}
+//#endregion
+export { ClientError, ImportError, connectCms };

package/src/Collections.d.ts

@@ -0,0 +1,142 @@
+import { n as MediaKind, r as MediaSelection } from "./Media-BQ0uL4w7.js";
+import { n as FieldDefinition, t as CollectionDefinition } from "./Fields-BegSgYhj.js";
+import { n as AuthoredImage, t as LinkTarget } from "./Links-Dx1yOni8.js";
+import { Schema } from "effect";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+declare namespace Field_d_exports {
+  export { Field, Fields, NumberOptions, Options, TextOptions, Value, Values, boolean, date, document, icon, image, link, list, media, multiSelect, number, object, select, text, textarea };
+}
+declare const valueType: unique symbol;
+interface Options<Value extends Schema.Json, Required extends boolean = boolean> {
+  readonly label?: string;
+  readonly description?: string;
+  readonly required?: Required;
+  readonly defaultValue?: Value;
+}
+type TextConstraints = Pick<Extract<FieldDefinition, {
+  kind: 'text';
+}>, 'minLength' | 'maxLength'>;
+type NumberConstraints = Pick<Extract<FieldDefinition, {
+  kind: 'number';
+}>, 'integer' | 'min' | 'max'>;
+interface TextOptions<Required extends boolean> extends Options<string, Required>, TextConstraints {}
+interface NumberOptions<Required extends boolean> extends Options<number, Required>, NumberConstraints {}
+interface Field<Value extends Schema.Json = Schema.Json, Required extends boolean = boolean> {
+  readonly [valueType]?: Value;
+  readonly kind: FieldDefinition['kind'];
+  readonly options: Options<Value, Required> & TextConstraints & NumberConstraints;
+  readonly fields?: Fields;
+  readonly choices?: Readonly<Record<string, string>>;
+  readonly collections?: ReadonlyArray<string>;
+  readonly mediaKind?: MediaKind;
+}
+type Fields = Readonly<Record<string, Field>>;
+type Value<F extends Field> = NonNullable<F[typeof valueType]>;
+type RequiredNames<F extends Fields> = { [Name in keyof F]: F[Name]['options']['required'] extends true | undefined ? Name : never; }[keyof F];
+type Values<F extends Fields> = { readonly [Name in RequiredNames<F>]: Value<F[Name]>; } & { readonly [Name in Exclude<keyof F, RequiredNames<F>>]?: Value<F[Name]>; };
+declare function text<const Required extends boolean = false>(options?: TextOptions<Required>): Field<string, Required>;
+declare function textarea<const Required extends boolean = false>(options?: TextOptions<Required>): Field<string, Required>;
+declare function date<const Required extends boolean = false>(options?: Options<string, Required>): Field<string, Required>;
+declare function icon<const Required extends boolean = false>(options?: Options<string, Required>): Field<string, Required>;
+declare function number<const Required extends boolean = false>(options?: NumberOptions<Required>): Field<number, Required>;
+declare function boolean<const Required extends boolean = false>(options?: Options<boolean, Required>): Field<boolean, Required>;
+declare function select<const Choices extends Readonly<Record<string, string>>, const Required extends boolean = false>(choices: Choices, options?: Options<NoInfer<Extract<keyof Choices, string>>, Required>): {
+  choices: Choices;
+  kind: FieldDefinition["kind"];
+  options: Options<NoInfer<Extract<keyof Choices, string>>, Required> & TextConstraints & NumberConstraints;
+  fields?: Readonly<Record<string, Field<Schema.Json, boolean>>> | undefined;
+  collections?: ReadonlyArray<string>;
+  mediaKind?: MediaKind;
+  [valueType]?: NoInfer<Extract<keyof Choices, string>> | undefined;
+};
+declare function multiSelect<const Choices extends Readonly<Record<string, string>> = Readonly<Record<string, string>>, const Required extends boolean = false>(choices?: Choices, options?: Options<ReadonlyArray<NoInfer<Extract<keyof Choices, string>>>, Required>): {
+  choices: {
+    [x: string]: string;
+  };
+  kind: FieldDefinition["kind"];
+  options: Options<readonly NoInfer<Extract<keyof Choices, string>>[], Required> & TextConstraints & NumberConstraints;
+  fields?: Readonly<Record<string, Field<Schema.Json, boolean>>> | undefined;
+  collections?: ReadonlyArray<string>;
+  mediaKind?: MediaKind;
+  [valueType]?: readonly NoInfer<Extract<keyof Choices, string>>[] | undefined;
+};
+declare function document<const Required extends boolean = false>(options?: Omit<Options<string, Required>, 'defaultValue'> & {
+  readonly collections?: ReadonlyArray<string>;
+}): {
+  collections: string[] | undefined;
+  kind: FieldDefinition["kind"];
+  options: Options<string, Required> & TextConstraints & NumberConstraints;
+  fields?: Readonly<Record<string, Field<Schema.Json, boolean>>> | undefined;
+  choices?: Readonly<Record<string, string>>;
+  mediaKind?: MediaKind;
+  [valueType]?: string | undefined;
+};
+declare function image<const Required extends boolean = false>(options?: Options<AuthoredImage, Required>): Field<{
+  readonly kind: "image";
+  readonly mediaId: string;
+  readonly alt?: string | undefined;
+  readonly frame?: "square" | "wide" | undefined;
+  readonly focalX?: number | undefined;
+  readonly focalY?: number | undefined;
+  readonly zoom?: number | undefined;
+}, Required>;
+declare function media<const Kind extends MediaKind, const Required extends boolean = false>(options: Options<MediaSelection & {
+  readonly mediaKind: NoInfer<Kind>;
+}, Required> & {
+  readonly mediaKind: Kind;
+}): {
+  mediaKind: Kind;
+  kind: FieldDefinition["kind"];
+  options: Options<{
+    readonly kind: "media";
+    readonly mediaId: string;
+    readonly mediaKind: "video" | "image";
+  } & {
+    readonly mediaKind: Kind;
+  }, Required> & TextConstraints & NumberConstraints;
+  fields?: Readonly<Record<string, Field<Schema.Json, boolean>>> | undefined;
+  choices?: Readonly<Record<string, string>>;
+  collections?: ReadonlyArray<string>;
+  [valueType]?: ({
+    readonly kind: "media";
+    readonly mediaId: string;
+    readonly mediaKind: "video" | "image";
+  } & {
+    readonly mediaKind: Kind;
+  }) | undefined;
+};
+declare function link<const Required extends boolean = false>(options?: Options<LinkTarget, Required>): Field<{
+  readonly kind: "url";
+  readonly href: string;
+} | {
+  readonly kind: "document";
+  readonly documentId: string;
+  readonly path: string;
+}, Required>;
+declare function object<const F extends Fields, const Required extends boolean = false>(fields: F, options?: Omit<Options<Values<F>, Required>, 'defaultValue'>): Field<Values<F>, Required>;
+declare function list<const F extends Fields, const Required extends boolean = false>(fields: F, options?: Omit<Options<ReadonlyArray<Values<F> & {
+  readonly id: string;
+}>, Required>, 'defaultValue'>): Field<ReadonlyArray<Values<F> & {
+  readonly id: string;
+}>, Required>;
+//#endregion
+//#region ../model/src/Collection.d.ts
+declare const contentType: unique symbol;
+interface Collection<Value extends Schema.JsonObject = Schema.JsonObject, Name extends string = string> extends CollectionDefinition {
+  readonly collection: Name;
+  readonly [contentType]?: Value;
+  /** Optional asynchronous business rules; their output is never persisted. */
+  readonly schema?: StandardSchemaV1<Value, unknown>;
+}
+type CollectionFields<C extends Collection> = NonNullable<C[typeof contentType]>;
+declare function defineCollection<const Name extends string, const F extends Fields>(definition: Omit<CollectionDefinition, 'fields' | 'title'> & {
+  readonly collection: Name;
+  readonly fields: F;
+  readonly validate?: StandardSchemaV1<NoInfer<Values<F>>, unknown>;
+}): Collection<Values<F>, Name>;
+//#endregion
+//#region src/Collections.d.ts
+export type CmsCollection = Collection;
+export declare function defineCmsCollections<const Collections extends ReadonlyArray<CmsCollection>>(collections: Collections): Collections;
+//#endregion
+export { type CollectionFields as CmsCollectionFields, defineCollection as defineCmsCollection, Field_d_exports as field };

package/src/Collections.js

@@ -0,0 +1,142 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { r as validateCollectionDefinition } from "./validation-DpUwPC8Y.js";
+import { t as CollectionDefinition } from "./Fields-ioGaMEh9.js";
+import { Schema } from "effect";
+//#region ../model/src/Collection.ts
+function defineCollection(definition) {
+	const { fields: declaredFields, validate, ...metadata } = definition;
+	const fields = structuredClone(declaredFields);
+	const title = fields.title;
+	if (!title || title.kind !== "text" || !title.options.required) throw new Error("A collection needs a required text title field.");
+	const catalog = Schema.decodeUnknownSync(CollectionDefinition)({
+		...metadata,
+		fields: catalogFields(fields, true),
+		...(title.options.minLength !== void 0 || title.options.maxLength !== void 0) && { title: {
+			...title.options.minLength !== void 0 && { minLength: title.options.minLength },
+			...title.options.maxLength !== void 0 && { maxLength: title.options.maxLength }
+		} }
+	});
+	const collection = Object.assign(catalog, {
+		collection: definition.collection,
+		fields: catalog.fields.filter((field) => field.name !== "title"),
+		...validate && { schema: validate }
+	});
+	const problems = validateCollectionDefinition(collection);
+	if (problems.length) throw new Error(problems.join("\n"));
+	return collection;
+}
+function catalogFields(fields, root = false) {
+	return Object.entries(fields).map(([name, field]) => {
+		if (!/^[a-z][a-zA-Z0-9]*$/u.test(name) || !root && name === "id") throw new Error("Invalid or reserved field name \"" + name + "\".");
+		return {
+			...field.options,
+			name,
+			kind: field.kind,
+			label: field.options.label ?? name.replaceAll(/([a-z])([A-Z])/gu, "$1 $2").replace(/^./u, (letter) => letter.toUpperCase()),
+			required: field.options.required ?? false,
+			...field.fields && { fields: catalogFields(field.fields) },
+			...field.choices && { options: Object.entries(field.choices).map(([value, label]) => ({
+				value,
+				label
+			})) },
+			...field.collections && { collections: field.collections },
+			...field.mediaKind && { mediaKind: field.mediaKind }
+		};
+	});
+}
+//#endregion
+//#region ../model/src/Field.ts
+var Field_exports = /* @__PURE__ */ __exportAll({
+	boolean: () => boolean,
+	date: () => date,
+	document: () => document,
+	icon: () => icon,
+	image: () => image,
+	link: () => link,
+	list: () => list,
+	media: () => media,
+	multiSelect: () => multiSelect,
+	number: () => number,
+	object: () => object,
+	select: () => select,
+	text: () => text,
+	textarea: () => textarea
+});
+function make(kind, options) {
+	if (options.defaultValue !== void 0 && [
+		"document",
+		"object",
+		"list"
+	].includes(kind)) throw new Error("A " + kind + " field does not support a default value.");
+	return {
+		kind,
+		options: structuredClone(options)
+	};
+}
+function text(options = {}) {
+	return make("text", options);
+}
+function textarea(options = {}) {
+	return make("textarea", options);
+}
+function date(options = {}) {
+	return make("date", options);
+}
+function icon(options = {}) {
+	return make("icon", options);
+}
+function number(options = {}) {
+	return make("number", options);
+}
+function boolean(options = {}) {
+	return make("boolean", options);
+}
+function select(choices, options = {}) {
+	return {
+		...make("select", options),
+		choices: { ...choices }
+	};
+}
+function multiSelect(choices, options = {}) {
+	return {
+		...make("multi-select", options),
+		choices: { ...choices }
+	};
+}
+function document(options = {}) {
+	return {
+		...make("document", options),
+		collections: options.collections?.slice()
+	};
+}
+function image(options = {}) {
+	return make("image", options);
+}
+function media(options) {
+	return {
+		...make("media", options),
+		mediaKind: options.mediaKind
+	};
+}
+function link(options = {}) {
+	return make("link", options);
+}
+function object(fields, options = {}) {
+	return {
+		...make("object", options),
+		fields: { ...fields }
+	};
+}
+function list(fields, options = {}) {
+	return {
+		...make("list", options),
+		fields: { ...fields }
+	};
+}
+//#endregion
+//#region src/Collections.ts
+function defineCmsCollections(collections) {
+	return collections;
+}
+//#endregion
+export { defineCollection as defineCmsCollection, defineCmsCollections, Field_exports as field };

package/src/Config-CMiwciub.js

@@ -0,0 +1,130 @@
+import { i as SiteSeoSettings, n as SiteOrigin } from "./Seo-CjNUtUkj.js";
+import { n as LocaleConfiguration } from "./Locales-Ch7a5xuA.js";
+import { a as PersonEmail, s as StudioModule } from "./People-DvNZauWw.js";
+import { Effect, Schema, SchemaTransformation } from "effect";
+//#region ../cli/src/Config.ts
+const BooleanFromEnvironment = Schema.Union([Schema.Boolean, Schema.Literals(["true", "false"]).pipe(Schema.decodeTo(Schema.Boolean, SchemaTransformation.transform({
+	decode: (value) => value === "true",
+	encode: (value) => value ? "true" : "false"
+})))]);
+const PositiveBytes = Schema.Int.check(Schema.isGreaterThan(0));
+/** Serializable private values registered under Nuxt's runtimeConfig.cms. */
+const RuntimeConfiguration = Schema.Struct({
+	origin: SiteOrigin,
+	databaseFile: Schema.NonEmptyString,
+	installationSecret: Schema.String,
+	trustedProxyIps: Schema.String,
+	s3: Schema.Struct({
+		bucket: Schema.String,
+		region: Schema.String,
+		prefix: Schema.String,
+		endpoint: Schema.String,
+		forcePathStyle: BooleanFromEnvironment,
+		accessKeyId: Schema.String,
+		secretAccessKey: Schema.String,
+		maxUploadBytes: Schema.Union([PositiveBytes, Schema.FiniteFromString.pipe(Schema.decodeTo(PositiveBytes))])
+	})
+});
+/** Convert flat runtime values to the connection shared by provisioning and media storage. */
+function mediaStorageOptions(configuration) {
+	const { bucket, region, prefix, endpoint, forcePathStyle, accessKeyId, secretAccessKey } = configuration;
+	if (!bucket || !region) throw new Error("CMS media storage requires a bucket and region.");
+	if (!!accessKeyId !== !!secretAccessKey) throw new Error("CMS S3 access key and secret key must be configured together.");
+	return {
+		bucket,
+		region,
+		prefix,
+		endpoint: endpoint || void 0,
+		forcePathStyle,
+		credentials: accessKeyId ? {
+			accessKeyId,
+			secretAccessKey
+		} : void 0
+	};
+}
+const runtimeDefaults = {
+	origin: "http://127.0.0.1:3000",
+	databaseFile: ".data/cms.sqlite",
+	installationSecret: "",
+	trustedProxyIps: "",
+	s3: {
+		bucket: "",
+		region: "",
+		prefix: "",
+		endpoint: "",
+		forcePathStyle: false,
+		accessKeyId: "",
+		secretAccessKey: "",
+		maxUploadBytes: 25e7
+	}
+};
+const Account = Schema.Struct({
+	email: PersonEmail,
+	password: Schema.String.check(Schema.isMinLength(8))
+});
+const Administrator = Schema.Struct({
+	...Account.fields,
+	name: Schema.NonEmptyString
+});
+const ResolvedConfiguration = Schema.Struct({
+	locales: Schema.optionalKey(LocaleConfiguration),
+	seo: Schema.Struct({
+		...SiteSeoSettings.fields,
+		canonicalOrigin: Schema.optionalKey(Schema.Never)
+	}),
+	studio: Schema.Struct({ modules: Schema.Array(StudioModule.mapFields((fields) => ({
+		...fields,
+		access: Schema.optionalKey(fields.access)
+	}))) }),
+	robots: Schema.Boolean,
+	sitemap: Schema.Boolean,
+	runtime: RuntimeConfiguration,
+	provision: Schema.optionalKey(Schema.Struct({
+		compose: Schema.optionalKey(Schema.Struct({
+			file: Schema.NonEmptyString,
+			service: Schema.NonEmptyString
+		})),
+		createBucket: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false)))
+	})),
+	bootstrap: Schema.optionalKey(Schema.Struct({
+		administrator: Schema.Struct({
+			email: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(""))),
+			password: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(""))),
+			name: Schema.NonEmptyString
+		}),
+		snapshot: Schema.optionalKey(Schema.NonEmptyString),
+		accounts: Schema.Array(Account).pipe(Schema.withDecodingDefaultKey(Effect.succeed([])))
+	}))
+});
+/** One site-owned configuration; profiles change values, commands choose actions. */
+function defineCmsConfig(configuration) {
+	return configuration;
+}
+const configurationDefaults = {
+	runtime: runtimeDefaults,
+	seo: {
+		siteName: "CMS",
+		index: true,
+		follow: true
+	},
+	studio: { modules: [] },
+	robots: true,
+	sitemap: true
+};
+const overrides = (keys, prefix, environment) => Object.fromEntries(keys.flatMap((key) => {
+	const value = environment[`${prefix}${key.replace(/[A-Z]/gu, (letter) => `_${letter}`).toUpperCase()}`];
+	return value === void 0 ? [] : [[key, value]];
+}));
+/** Match Nuxt's fixed scalar environment keys without loading its framework in the CLI. */
+function runtimeFromEnvironment(runtime, environment) {
+	return Schema.decodeSync(RuntimeConfiguration)({
+		...runtime,
+		...overrides(Object.keys(RuntimeConfiguration.fields).filter((key) => key !== "s3"), "NUXT_CMS_", environment),
+		s3: {
+			...runtime.s3,
+			...overrides(Object.keys(RuntimeConfiguration.fields.s3.fields), "NUXT_CMS_S3_", environment)
+		}
+	});
+}
+//#endregion
+export { defineCmsConfig as a, configurationDefaults as i, ResolvedConfiguration as n, mediaStorageOptions as o, RuntimeConfiguration as r, runtimeFromEnvironment as s, Administrator as t };

package/src/Config.d.ts

@@ -0,0 +1,172 @@
+import { r as LocaleConfiguration } from "./Locales-jwbmJaOp.js";
+import { t as SiteSeoSettings } from "./Seo-BcpqxoAs.js";
+import { Schema } from "effect";
+//#region ../cli/src/Config.d.ts
+/** Serializable private values registered under Nuxt's runtimeConfig.cms. */
+declare const RuntimeConfiguration: Schema.Struct<{
+  readonly origin: Schema.String;
+  readonly databaseFile: Schema.NonEmptyString;
+  readonly installationSecret: Schema.String;
+  readonly trustedProxyIps: Schema.String;
+  readonly s3: Schema.Struct<{
+    readonly bucket: Schema.String;
+    readonly region: Schema.String;
+    readonly prefix: Schema.String;
+    readonly endpoint: Schema.String;
+    readonly forcePathStyle: Schema.Union<readonly [Schema.Boolean, Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>]>;
+    readonly accessKeyId: Schema.String;
+    readonly secretAccessKey: Schema.String;
+    readonly maxUploadBytes: Schema.Union<readonly [Schema.Int, Schema.compose<Schema.Int, Schema.FiniteFromString>]>;
+  }>;
+}>;
+interface RuntimeConfiguration extends Schema.Schema.Type<typeof RuntimeConfiguration> {}
+declare const Account: Schema.Struct<{
+  readonly email: Schema.NonEmptyString;
+  readonly password: Schema.String;
+}>;
+declare const ResolvedConfiguration: Schema.Struct<{
+  readonly locales: Schema.optionalKey<Schema.Struct<{
+    readonly defaultLocale: Schema.NonEmptyString;
+    readonly supported: Schema.$Array<Schema.Struct<{
+      readonly code: Schema.NonEmptyString;
+      readonly label: Schema.optionalKey<Schema.NonEmptyString>;
+      readonly dir: Schema.optionalKey<Schema.Literals<readonly ["ltr", "rtl"]>>;
+    }>>;
+    readonly prefixDefault: Schema.Boolean;
+  }>>;
+  readonly seo: Schema.Struct<{
+    readonly canonicalOrigin: Schema.optionalKey<Schema.Never>;
+    readonly siteName: Schema.String;
+    readonly defaultDescription: Schema.optionalKey<Schema.String>;
+    readonly titleTemplate: Schema.optionalKey<Schema.String>;
+    readonly socialTitle: Schema.optionalKey<Schema.String>;
+    readonly socialDescription: Schema.optionalKey<Schema.String>;
+    readonly socialImage: Schema.optionalKey<Schema.Struct<{
+      readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+      readonly alt: Schema.String;
+    }>>;
+    readonly index: Schema.Boolean;
+    readonly follow: Schema.Boolean;
+    readonly identity: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+      readonly image: Schema.optionalKey<Schema.Struct<{
+        readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+        readonly alt: Schema.String;
+      }>>;
+      readonly name: Schema.String;
+      readonly url: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.Literal<"Person">;
+    }>, Schema.Struct<{
+      readonly logo: Schema.optionalKey<Schema.Struct<{
+        readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+        readonly alt: Schema.String;
+      }>>;
+      readonly name: Schema.String;
+      readonly url: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.Literal<"Organization">;
+    }>, Schema.Struct<{
+      readonly logo: Schema.optionalKey<Schema.Struct<{
+        readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+        readonly alt: Schema.String;
+      }>>;
+      readonly image: Schema.optionalKey<Schema.Struct<{
+        readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+        readonly alt: Schema.String;
+      }>>;
+      readonly telephone: Schema.optionalKey<Schema.String>;
+      readonly address: Schema.optionalKey<Schema.Struct<{
+        readonly streetAddress: Schema.optionalKey<Schema.String>;
+        readonly addressLocality: Schema.optionalKey<Schema.String>;
+        readonly addressRegion: Schema.optionalKey<Schema.String>;
+        readonly postalCode: Schema.optionalKey<Schema.String>;
+        readonly addressCountry: Schema.optionalKey<Schema.String>;
+      }>>;
+      readonly name: Schema.String;
+      readonly url: Schema.optionalKey<Schema.String>;
+      readonly type: Schema.Literal<"LocalBusiness">;
+    }>]>>;
+  }>;
+  readonly studio: Schema.Struct<{
+    readonly modules: Schema.$Array<Schema.Struct<{
+      readonly access: Schema.optionalKey<Schema.Literals<readonly ["administrator", "signed-in"]>>;
+      readonly id: Schema.NonEmptyString;
+      readonly label: Schema.NonEmptyString;
+      readonly icon: Schema.NonEmptyString;
+      readonly path: Schema.NonEmptyString;
+    }>>;
+  }>;
+  readonly robots: Schema.Boolean;
+  readonly sitemap: Schema.Boolean;
+  readonly runtime: Schema.Struct<{
+    readonly origin: Schema.String;
+    readonly databaseFile: Schema.NonEmptyString;
+    readonly installationSecret: Schema.String;
+    readonly trustedProxyIps: Schema.String;
+    readonly s3: Schema.Struct<{
+      readonly bucket: Schema.String;
+      readonly region: Schema.String;
+      readonly prefix: Schema.String;
+      readonly endpoint: Schema.String;
+      readonly forcePathStyle: Schema.Union<readonly [Schema.Boolean, Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>]>;
+      readonly accessKeyId: Schema.String;
+      readonly secretAccessKey: Schema.String;
+      readonly maxUploadBytes: Schema.Union<readonly [Schema.Int, Schema.compose<Schema.Int, Schema.FiniteFromString>]>;
+    }>;
+  }>;
+  readonly provision: Schema.optionalKey<Schema.Struct<{
+    readonly compose: Schema.optionalKey<Schema.Struct<{
+      readonly file: Schema.NonEmptyString;
+      readonly service: Schema.NonEmptyString;
+    }>>;
+    readonly createBucket: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
+  }>>;
+  readonly bootstrap: Schema.optionalKey<Schema.Struct<{
+    readonly administrator: Schema.Struct<{
+      readonly email: Schema.withDecodingDefaultKey<Schema.String, never>;
+      readonly password: Schema.withDecodingDefaultKey<Schema.String, never>;
+      readonly name: Schema.NonEmptyString;
+    }>;
+    readonly snapshot: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly accounts: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Struct<{
+      readonly email: Schema.NonEmptyString;
+      readonly password: Schema.String;
+    }>>, never>;
+  }>>;
+}>;
+interface ResolvedConfiguration extends Schema.Schema.Type<typeof ResolvedConfiguration> {}
+interface CmsOptions {
+  readonly locales?: LocaleConfiguration;
+  readonly seo?: Partial<Omit<SiteSeoSettings, 'canonicalOrigin'>>;
+  readonly studio?: {
+    readonly modules?: ResolvedConfiguration['studio']['modules'];
+  };
+  readonly robots?: boolean;
+  readonly sitemap?: boolean;
+  readonly runtime?: Partial<Omit<RuntimeConfiguration, 's3'>> & {
+    readonly s3?: Partial<RuntimeConfiguration['s3']>;
+  };
+  readonly provision?: {
+    readonly compose?: {
+      readonly file: string;
+      readonly service: string;
+    };
+    readonly createBucket?: boolean;
+  };
+  readonly bootstrap?: {
+    readonly administrator: {
+      readonly name: string;
+      readonly email?: string;
+      readonly password?: string;
+    };
+    readonly snapshot?: string;
+    readonly accounts?: ReadonlyArray<typeof Account.Type>;
+  };
+}
+interface CmsConfig extends CmsOptions {
+  readonly $development?: CmsOptions;
+  readonly $production?: CmsOptions;
+  readonly $env?: Readonly<Record<string, CmsOptions>>;
+}
+/** One site-owned configuration; profiles change values, commands choose actions. */
+export declare function defineCmsConfig(configuration: CmsConfig): CmsConfig;
+//#endregion
+export type { CmsConfig, CmsOptions };

package/src/Config.js

@@ -0,0 +1,2 @@
+import { a as defineCmsConfig } from "./Config-CMiwciub.js";
+export { defineCmsConfig };