@phtngyn/cms 0.1.0-beta.5 → 0.2.0-beta.2

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.2.0-beta.2
+
+This beta replaces the earlier installation and form interfaces directly.
+
+- Runtime installation: move database URLs, origins, authentication secrets, initialization tokens, and S3 connection values out of `cms.config.ts` and into Nuxt `runtimeConfig.cms` / `NUXT_CMS_*`. Keep only the PostgreSQL schema and S3 prefix under `installation`. Rebuild once; no database migration, content import, or reset is required.
+- CLI: `cms dev` now loads `<root>/.env`, supports `--root`, `--env-file`, `--verbose`, and `--json`, and reports stable phase diagnostics. No data operation is required.
+- Forms: handlers must return `accepted`, `invalid`, or `unavailable`; `void` is no longer accepted. The handler receives request metadata. Replace `field()` and nested controller refs with `control()` / `visibleControls` and plain reactive properties. Rebuild the application; no stored form migration is required.
+- Generated types: Nuxt renderers should import named `CmsFormDefinition<'form-name'>` from `#cms/types` and use the auto-imported `useCmsForm`. Regenerate Nuxt types with `nuxt prepare` or a normal build.
+- Collection fields: `field(schema, { default })` replaces routine `Schema.withDecodingDefaultKey(Effect.succeed(...))` plumbing. Existing advanced Effect schemas remain valid. No data operation is required.
+- Locale metadata: `i18n.siteConfig` chooses `documents` (default) or `localized-routes`. Studio groups locale variants and can create blank or copied independent translations. No database migration or content rewrite is required.
+- Studio density: Overview previews are visibility-gated and serialized; the form builder edits one selected step at a time. Rebuild to update the embedded Studio.

package/README.md

@@ -24,7 +24,7 @@ export default defineNuxtConfig({
 
 ## Configure
 
-Create a PostgreSQL database and an S3-compatible bucket. The database user must be able to create and migrate CMS tables. Storage credentials need bucket access and object read, write, copy, list, and delete permissions. Configure public reads through your bucket or CDN and use that URL as `publicBaseUrl`; the module does not configure public access policies.
+Create a PostgreSQL database and an S3-compatible bucket. The database user must be able to create and migrate CMS tables. Storage credentials need bucket access and object read, write, copy, list, and delete permissions. Configure public reads through your bucket or CDN; the module does not configure public access policies.
 
 Create `cms.config.ts` beside `nuxt.config.ts`:
 
@@ -32,17 +32,7 @@ Create `cms.config.ts` beside `nuxt.config.ts`:
 import { defineCmsConfig } from '@phtngyn/cms/Configuration'
 import { pageSchema } from './page.schema'
 
-function env(name: string): string {
-  const value = process.env[name]
-  if (!value) throw new Error(`Missing ${name}`)
-  return value
-}
-
 export default defineCmsConfig({
-  baseUrl: env('CMS_BASE_URL'), // Website origin, e.g. http://localhost:3000
-  databaseUrl: env('DATABASE_URL'),
-  secret: env('CMS_SECRET'),
-  initializationToken: env('CMS_INITIALIZATION_TOKEN'),
   documents: {
     collections: {
       pages: {
@@ -53,26 +43,53 @@ export default defineCmsConfig({
       },
     },
   },
-  media: {
-    publicBaseUrl: env('S3_PUBLIC_URL'),
-    storage: {
-      bucket: env('S3_BUCKET'),
-      region: env('S3_REGION'),
-      credentials: {
-        accessKeyId: env('S3_ACCESS_KEY_ID'),
-        secretAccessKey: env('S3_SECRET_ACCESS_KEY'),
-      },
-      // For an S3-compatible provider, add its endpoint and, if required:
-      // endpoint: env('S3_ENDPOINT'),
-      // forcePathStyle: true,
+  installation: {
+    database: { schema: 'cms' },
+    media: {
+      prefix: 'cms/',
     },
   },
 })
 ```
 
-These environment variable names are examples; configuration is executable TypeScript, so you can use your own configuration source. Supply values during Nuxt development/build and to the deployed server. Generate distinct random values of at least 32 characters for `secret` and `initializationToken`, and keep them server-side. For example, run `node -e "console.log(require('node:crypto').randomBytes(32).toString('hex'))"` separately for each.
+Keep environment-specific values in Nuxt runtime configuration. The module supplies empty `runtimeConfig.cms` defaults, so a production build needs no credentials. Nitro reads these values only when the built server starts:
+
+```dotenv
+NUXT_CMS_BASE_URL=http://localhost:3000
+NUXT_CMS_DATABASE_URL=postgres://cms:cms@localhost:5432/cms
+NUXT_CMS_INITIALIZATION_TOKEN=replace-with-a-distinct-32-character-random-token
+NUXT_CMS_SECRET=replace-with-at-least-32-random-characters
+NUXT_CMS_MEDIA_BUCKET=cms-media
+NUXT_CMS_MEDIA_PUBLIC_BASE_URL=http://localhost:8333/cms-media
+NUXT_CMS_MEDIA_REGION=us-east-1
+NUXT_CMS_MEDIA_ENDPOINT=http://localhost:8333
+NUXT_CMS_MEDIA_FORCE_PATH_STYLE=true
+NUXT_CMS_MEDIA_ACCESS_KEY_ID=cms-media
+NUXT_CMS_MEDIA_SECRET_ACCESS_KEY=cms-media-secret
+```
+
+Generate distinct random values of at least 32 characters for the secret and initialization token, and keep them server-side. The same built artifact can be started against another environment by changing only these runtime values.
+
+For storage using the AWS credential chain, omit both credential variables. Set `NUXT_CMS_MEDIA_PROVISION_BUCKET=true` to create a missing bucket automatically and grant bucket-creation permission. Set authored `installation.media: false` to build without uploads.
+
+The PostgreSQL schema and S3 prefix are the installation's ownership boundary. CMS creates and migrates only the configured schema, and every media object stays under the configured prefix.
+
+## Local development lifecycle
+
+Use the supported lifecycle before starting Nuxt:
+
+```sh
+cms dev doctor
+CMS_EMAIL=admin@example.test CMS_PASSWORD=admin@example.test cms dev bootstrap --content ./content --publish
+cms dev reset --database --media
+cms dev reset --database --media --yes --bootstrap --content ./content --publish
+```
+
+All lifecycle commands accept `--root <directory>`, `--env-file <path>`, `--verbose`, and `--json`. Values already present in the process override the explicit environment file, which overrides `<root>/.env`, which overrides Nuxt runtime-config defaults.
 
-For storage using the AWS credential chain, omit `credentials`. To create a missing bucket automatically, set `provisionBucket: true` and grant bucket-creation permission. Set `media: false` to start without uploads.
+`doctor` is read-only and reports pass, fail, or not-verified for configuration, PostgreSQL, migrations, S3, public media, packaged assets, readiness, and WebSockets. Add `--full` to validate pending migrations in a rolled-back transaction and probe database writes plus an actual publicly readable S3 object, or `--json` for editor and CI integrations. `bootstrap` prepares the Nuxt authoring catalog, provisions infrastructure, runs migrations, creates or updates the requested local administrator, and optionally plans and applies content without requiring a running server. Passwords come from `CMS_PASSWORD` or a private prompt.
+
+`reset` is a dry run unless `--yes` is present. It refuses to run while the configured CMS is live and can remove only the configured PostgreSQL schema and S3 prefix. Choose `--database`, `--media`, or both.
 
 ## Content CLI
 
@@ -93,6 +110,30 @@ For a folder without `.cms-content.json`, the CLI reads nested `.md` and `.mdc`
 
 The command tree is intentionally shared: future CMS operations can be added beside `content` without separate executables.
 
+The same workflow is available to Node scripts without parsing CLI output:
+
+```ts
+import { createCmsContentClient, readCmsContentDirectory } from '@phtngyn/cms/Content'
+
+const source = await readCmsContentDirectory('./content')
+const client = createCmsContentClient({
+  baseUrl: 'http://localhost:3000',
+  credentials: {
+    email: process.env.CMS_EMAIL!,
+    password: process.env.CMS_PASSWORD!,
+  },
+})
+
+const plan = await client.plan(source, { overwrite: false, publish: true })
+
+if (plan.valid) await client.apply(plan)
+
+const document = await client.readDocument('8c62d2a7-b839-450a-bc08-5eccb420dc60')
+await client.export({ directory: './content' })
+```
+
+Plans expose creates, updates, publications, conflicts, issues, unchanged entries, and target-only sources. They are bound to their client, source, options, and generation; `apply(plan)` never replans. `readDocument(id)` returns the authored Markdown and exact publication state. `CmsContentError.code` provides stable authentication, not-found, conflict, validation, generation, filesystem, response, and network failure categories.
+
 ## Search and sharing
 
 The module installs the focused Nuxt robots, sitemap, schema.org, and SEO utility modules. Published CMS pages receive canonical, robots, social-sharing, and structured-data metadata automatically. The sitemap contains only published, indexable documents and uses their publication revision time for `lastmod`; localized variants are emitted as alternatives when they share a document key.
@@ -130,6 +171,24 @@ Keep raw robots directives and Nuxt module configuration in application code. Th
 
 Collections use **Standard Schema V1** for validation and **Standard JSON Schema V1** for the input structure Studio renders. This lets you keep your chosen validation library. Both contracts must be available on the collection schema; Standard Schema validation alone cannot describe controls. Studio requests draft 2020-12 JSON Schema input, resolves non-recursive local references, and runs the original validator when validating documents.
 
+The public standards types come directly from `@standard-schema/spec`. For a validator whose JSON Schema adapter is separate, `defineCmsSchema()` combines both contracts and applies library-neutral presentation to nested field paths:
+
+```ts
+import { defineCmsSchema } from '@phtngyn/cms/DocumentModel'
+
+const pageSchema = defineCmsSchema({
+  validator: page,
+  jsonSchema: {
+    input: () => createInputSchema(page),
+    output: () => createOutputSchema(page),
+  },
+  fields: {
+    description: { label: 'Description', input: 'textarea' },
+    'seo.description': { input: 'textarea' },
+  },
+})
+```
+
 For a validator that already implements both standards, pass it directly as `schema`. Otherwise, adapt its validator and input/output JSON Schema converters:
 
 ```ts
@@ -149,19 +208,17 @@ Supply actual draft 2020-12 schemas from the chosen library, using its input and
 Effect schemas are also accepted directly. The CMS derives Studio inputs from their encoded structure and runs the original decoder, preserving defaults, transformations, and asynchronous validation. Decoders must not require external Effect services, and their output must be a JSON-compatible object.
 
 ```ts
-import { Effect, Schema } from 'effect'
+import { Schema } from 'effect'
 import { CalendarDate, field } from '@phtngyn/cms/DocumentModel'
 
 const pageSchema = Schema.Struct({
-  description: field(Schema.String.annotate({ default: '' }), { input: 'textarea' }).pipe(
-    Schema.withDecodingDefaultKey(Effect.succeed('')),
-  ),
+  description: field(Schema.String, { default: '', input: 'textarea' }),
   publishedAt: Schema.optionalKey(field(CalendarDate, { label: 'Published on' })),
   title: Schema.NonEmptyString,
 })
 ```
 
-Use `Schema.optionalKey` for optional fields and `Schema.Finite` for numeric fields. An encoded `default` annotation supplies Studio's initial value; `Schema.withDecodingDefaultKey` applies that default during validation. `CalendarDate` validates calendar dates stored as `YYYY-MM-DD` strings. `field` adds presentation annotations to the encoded side of an Effect schema.
+Use `Schema.optionalKey` for optional fields and `Schema.Finite` for numeric fields. A `field` default supplies Studio's initial value and applies only when the containing key is absent; invalid explicit values still fail. `CalendarDate` validates calendar dates stored as `YYYY-MM-DD` strings. Advanced Effect schemas, transformations, and defaults remain supported directly. `effect` is an intentional runtime dependency and is installed explicitly because authored schemas expose its public types.
 
 Studio supports strings, calendar dates, finite numbers, booleans, string arrays, choices, and nested objects. Non-recursive local references are resolved. Ambiguous unions, structural intersections, recursive schemas, and unsupported field shapes fail configuration rather than producing incomplete forms.
 
@@ -186,6 +243,20 @@ Draft delivery requires the current Studio session and document access permissio
 - Import `defineCmsBlock` from `@phtngyn/cms/Authoring` to declare editable props and slots in your Nuxt Vue components.
 - Import Markdown folders with `cms content plan` and `cms content apply` after creating the first administrator.
 
+Nuxt generates `#cms/types` whenever configuration, collection schemas, or authored blocks change. It includes collection, form, block, locale, message-key, and interpolation-parameter types. Collection schema outputs flow through `useDocument<'pages'>()` and `useDocumentQuery()`, including typed filter and sort paths. Registered form names and configured capabilities narrow `CmsFormDefinition<'contact-form'>`.
+
+```ts
+import type { CmsCollection, CmsFormDefinition, CmsLocale } from '#cms/types'
+
+const page: CmsCollection<'pages'> | null = useDocument<'pages'>('/').data.value
+const locale: CmsLocale = 'de'
+const form = {} as CmsFormDefinition<'contact-form'>
+```
+
+`useCmsI18n().t()` autocompletes configured keys and requires the exact placeholders in each message. Nuxt preparation rejects extra locale keys and inconsistent placeholders. Missing translations are allowed only when the configured fallback locale supplies the canonical message.
+
+CMS also synchronizes owned document routes with Nuxt Site Config. The delivered document locale wins, the route prefix applies while delivery resolves, and non-CMS routes retain the application's Site Config. Set `i18n.siteConfig: 'localized-routes'` to give CMS-derived language metadata to custom localized routes too; document canonical URLs, alternates, and SEO remain document-only. The default `documents` scope avoids conflicts with another application i18n module.
+
 ## Studio and authoring during development
 
 Studio at `/_cms/app` is a separate HTML document, Vue application, and Tailwind build. It owns its Nuxt UI settings, styles, and overlays independently of the website. Your app root and layouts apply only to the website. Both applications use the same Nuxt server; no separate Studio server or port is required.
@@ -267,9 +338,10 @@ forms: {
       fieldTypes: ['text', 'email', 'textarea', 'number', 'checkbox', 'select'],
       rules: ['required', 'minLength', 'maxLength', 'min', 'max'],
     }),
-    onSubmit: async ({ form, values }) => {
+    onSubmit: async ({ form, request, values }) => {
       // Server only: deliver or persist validated answers here.
       // values are keyed by stable question IDs; form.steps contains their labels.
+      return { status: 'accepted', reference: request.id }
     },
   },
 },
@@ -280,24 +352,25 @@ Create `ContactForm.vue` with an optional `cmsForm?: CmsFormDefinition` prop. Th
 A valid authored form receives `cmsForm` from `DocumentRenderer`. Incomplete drafts do not; show a helpful placeholder until the form is valid. Mount your custom form contents only when that definition exists:
 
 ```ts
-import type { CmsFormDefinition } from '@phtngyn/cms/Forms'
-import { useCmsForm } from '@phtngyn/cms/Forms'
+import type { CmsFormDefinition } from '#cms/types'
 
-const props = defineProps<{ definition: CmsFormDefinition }>()
+const props = defineProps<{ definition: CmsFormDefinition<'contact-form'> }>()
 const {
-  fields,
   steps,
-  values,
   errors,
   currentStep,
   stepIndex,
   isFirstStep,
   isLastStep,
-  isSubmitting,
+  submitting,
   isSuccess,
   isPreview,
-  error,
-  fieldState,
+  submitError,
+  canSubmit,
+  visibleControls,
+  invalidControls,
+  firstInvalidControlId,
+  control,
   next,
   previous,
   validate,
@@ -306,13 +379,13 @@ const {
 } = useCmsForm(() => props.definition)
 ```
 
-The composable accepts a value, ref, or getter and returns destructurable refs and functions. Use `fieldState(field)` for each visible question. It returns the current `value`, `error`, normalized `setValue(input)`, and `inputAttrs` with an ID, name, required state, and ARIA error/help references. Render help with `id=state.helpId` and errors with `id=state.errorId` so those references have matching elements. For example, a native control can use `v-bind="state.inputAttrs"`, `:value="state.value"`, and `@input="state.setValue($event.target.value)"`. Checkbox controls should pass their checked boolean. Valid number answers become numbers, empty answers become null, and invalid number text remains visible to validation. Empty optional answers reach the server handler as null. `values` and `errors` remain available for custom renderers; `_form` holds a form-wide error. Render accessible labels, error announcements, progress, and focus behavior in your application.
+The composable accepts a value, ref, or getter and returns destructurable refs and functions. Iterate `visibleControls`; each reactive control exposes plain template properties: `field`, writable `value`, `dirty`, `touched`, `valid`, `error`, `attrs`, `helpAttrs`, `errorAttrs`, and `touch()`. Bind `attrs` to the native control. CMS keeps stable IDs and ARIA relationships aligned without nested `.value` access inside a `v-for`. Valid number answers become numbers, empty answers become null, and invalid number text remains visible to validation. `canSubmit`, `invalidControls`, and `firstInvalidControlId` centralize form-level behavior, while `submitError` and `errors._form` cover transport and server failures.
 
 `next()` validates the current step, `previous()` preserves answers, and `submit()` validates every step and returns whether submission succeeded. A required checkbox must be checked.
 
 Definition replacements preserve answers for matching IDs and field types within the same form, clear validation state, and cancel pending client requests. `reset()` clears answers and submission state. The composable prevents overlapping submissions and repeat submission after success until reset. Scope disposal cancels client work. Cancellation cannot undo a server handler that has already started. An optional `submit(payload, signal)` transport override supports advanced integrations; it must return `CmsFormResult` and preserve server-side validation.
 
-The endpoint resolves the current published form and checks its exact serialized revision, including capabilities and question settings. Stale pages must reload. Draft preview validates locally without invoking the handler. Invalid structure prevents publication; invalid answers and unknown answer keys never reach the handler. Dynamic editor-created questions have runtime-validated answer types, not compile-time-known answer keys.
+The endpoint resolves the current published form and checks its exact serialized revision, including capabilities and question settings. Stale pages must reload. Draft preview validates locally without invoking the handler. Invalid structure prevents publication; invalid answers and unknown answer keys never reach the handler. The application handler explicitly returns `accepted`, `invalid`, or `unavailable`; trusted validation errors may target current field IDs or `_form`. Unexpected failures are correlated by request ID in server logs without recording answers and return only a generic public failure.
 
 Requests are limited to 128 KiB and 60 submissions per minute per server process, shared across forms. Browser requests with a foreign Origin are rejected. For deployments with multiple replicas or stronger spam protection, enforce a shared limit or challenge at your edge. There is no automatic retry, durable deduplication, inbox, email delivery, upload, branching, or save-and-resume in this release. Application handlers should account for retries after an uncertain network outcome. Configuration changes use Nuxt's restart lifecycle.
 

package/package.json

@@ -17,13 +17,14 @@
     "directory": "packages/nuxt"
   },
   "name": "@phtngyn/cms",
-  "version": "0.1.0-beta.5",
+  "version": "0.2.0-beta.2",
   "type": "module",
   "files": [
     "bin",
     "studio",
     "src",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "exports": {
@@ -43,6 +44,10 @@
       "types": "./src/DocumentModel.d.ts",
       "import": "./src/DocumentModel.js"
     },
+    "./ApplicationTypes": {
+      "types": "./src/ApplicationTypes.d.ts",
+      "import": "./src/ApplicationTypes.js"
+    },
     "./I18n": {
       "types": "./src/I18n.d.ts",
       "import": "./src/I18n.js"
@@ -50,6 +55,10 @@
     "./Forms": {
       "types": "./src/Forms.d.ts",
       "import": "./src/Forms.js"
+    },
+    "./Content": {
+      "types": "./src/Content.d.ts",
+      "import": "./src/Content.js"
     }
   },
   "dependencies": {
@@ -63,11 +72,13 @@
     "@nuxt/schema": "^4.5.2",
     "@nuxtjs/robots": "^6.2.2",
     "@nuxtjs/sitemap": "^8.5.1",
+    "@standard-schema/spec": "^1.1.0",
     "@tiptap/core": "^3.31.3",
     "@tiptap/starter-kit": "^3.31.3",
     "@tiptap/y-tiptap": "^3.0.9",
     "@vue/compiler-sfc": "^3.6.0-rc.8",
     "better-auth": "^1.7.4",
+    "c12": "^3.3.4",
     "comark": "^0.7.0",
     "diff": "^9.0.0",
     "drizzle-orm": "^1.0.0-rc.5-169397b",
@@ -77,6 +88,7 @@
     "nitropack": "^2.13.4",
     "nuxt-schema-org": "^6.3.1",
     "nuxt-seo-utils": "^8.5.0",
+    "nuxt-site-config": "^4.2.3",
     "pg": "^8.23.0",
     "typescript": "npm:typescript-native-bridge@6.0.3-bridge.16.tsgo.7.0.2",
     "vite": "^8.3.0",

package/src/ApplicationTypes.d.ts

@@ -0,0 +1,84 @@
+import { a as FormStep, n as FormDefinition, r as FormField } from "./Forms-R0HoTR-o.js";
+import { a as CmsMessageParameters, i as CmsMessageKey, r as CmsLocale } from "./I18n-zbqpWxki.js";
+import { n as DeliveryDocumentPage, t as DeliveryDocument } from "./types-DutFRtaG.js";
+import { Schema } from "effect";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/ApplicationTypes.d.ts
+/** Nuxt augments this registry from the authored CMS configuration and component catalog. */
+export interface CmsApplicationRegistry {}
+type AuthoredConfiguration = CmsApplicationRegistry extends {
+  configuration: infer Configuration;
+} ? Configuration : never;
+type AuthoredCollections = AuthoredConfiguration extends {
+  documents: {
+    collections: infer Collections;
+  };
+} ? Collections : Record<string, never>;
+type AuthoredForms = AuthoredConfiguration extends {
+  forms: infer Forms;
+} ? NonNullable<Forms> : Record<string, never>;
+type CollectionSchema<Name extends keyof AuthoredCollections> = AuthoredCollections[Name] extends {
+  schema: infer CollectionSchema;
+} ? CollectionSchema : never;
+type SchemaOutput<Value> = Value extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Value> : Value extends Schema.Top ? Value['Type'] : never;
+type JsonOutput<Value> = Value extends object ? Value : Record<string, never>;
+export type CmsCollectionName = Extract<keyof AuthoredCollections, string>;
+export type CmsFormName = Extract<keyof AuthoredForms, string>;
+export type CmsBlockName = CmsApplicationRegistry extends {
+  blockName: infer Name extends string;
+} ? Name : string;
+export type CmsCollection<Name extends CmsCollectionName> = Omit<DeliveryDocument, 'body' | 'collection' | 'data' | 'locale'> & {
+  readonly body: Omit<DeliveryDocument['body'], 'frontmatter'> & {
+    readonly frontmatter: JsonOutput<SchemaOutput<CollectionSchema<Name>>>;
+  };
+  readonly collection: Name;
+  readonly data: JsonOutput<SchemaOutput<CollectionSchema<Name>>>;
+  readonly locale?: CmsLocale;
+};
+type FormCapabilities<Name extends CmsFormName> = AuthoredForms[Name] extends {
+  definition: infer Capabilities;
+} ? Capabilities : never;
+type FormFieldType<Name extends CmsFormName> = FormCapabilities<Name> extends {
+  fieldTypes: ReadonlyArray<infer FieldType>;
+} ? Extract<FieldType, FormField['type']> : never;
+type FormRuleProperty<Rule> = Rule extends 'required' ? 'required' : Rule extends 'minLength' ? 'minLength' : Rule extends 'maxLength' ? 'maxLength' : Rule extends 'min' ? 'min' : Rule extends 'max' ? 'max' : never;
+type AllowedFormRuleProperty<Name extends CmsFormName> = FormRuleProperty<FormCapabilities<Name> extends {
+  rules: ReadonlyArray<infer Rule>;
+} ? Rule : never>;
+type RestrictFormRules<Field, Name extends CmsFormName> = Field extends FormField ? Omit<Field, Exclude<'max' | 'maxLength' | 'min' | 'minLength' | 'required', AllowedFormRuleProperty<Name>>> : never;
+type CmsFormField<Name extends CmsFormName> = RestrictFormRules<Extract<FormField, {
+  readonly type: FormFieldType<Name>;
+}>, Name>;
+type CmsFormStep<Name extends CmsFormName> = Omit<FormStep, 'fields'> & {
+  readonly fields: ReadonlyArray<CmsFormField<Name>>;
+};
+export type CmsFormDefinition<Name extends CmsFormName = CmsFormName> = Omit<FormDefinition, 'name' | 'steps'> & {
+  readonly name: Name;
+  readonly steps: ReadonlyArray<CmsFormStep<Name>>;
+};
+type Scalar = boolean | number | string | null;
+type FieldPaths<Value> = Value extends ReadonlyArray<unknown> ? never : Value extends object ? { [Key in Extract<keyof Value, string>]: NonNullable<Value[Key]> extends Scalar | ReadonlyArray<Scalar> ? Key : `${Key}.${FieldPaths<NonNullable<Value[Key]>>}`; }[Extract<keyof Value, string>] : never;
+type CollectionDataField<Name extends CmsCollectionName> = Extract<FieldPaths<CmsCollection<Name>['data']>, string>;
+type FieldValue<Value, Path extends string> = Path extends `${infer Head}.${infer Tail}` ? Head extends keyof Value ? FieldValue<NonNullable<Value[Head]>, Tail> : never : Path extends keyof Value ? Value[Path] : never;
+type DocumentField<Name extends CmsCollectionName> = 'collection' | 'description' | 'id' | 'key' | 'locale' | 'path' | 'source.path' | 'title' | CollectionDataField<Name> | `data.${CollectionDataField<Name>}`;
+type DocumentFieldValue<Name extends CmsCollectionName, Field extends DocumentField<Name>> = Field extends `data.${infer Path}` ? FieldValue<CmsCollection<Name>['data'], Path> : Field extends CollectionDataField<Name> ? FieldValue<CmsCollection<Name>['data'], Field> : Field extends 'collection' ? Name : Field extends 'locale' ? CmsLocale : Field extends 'source.path' ? CmsCollection<Name>['source']['path'] : Field extends keyof CmsCollection<Name> ? CmsCollection<Name>[Field] : never;
+type FilterValue<Value> = NonNullable<Value> extends ReadonlyArray<infer Item> ? Extract<NonNullable<Item>, Scalar> | ReadonlyArray<Extract<NonNullable<Item>, Scalar>> : Extract<NonNullable<Value>, Scalar> | ReadonlyArray<Extract<NonNullable<Value>, Scalar>>;
+type CmsDocumentQueryWhere<Name extends CmsCollectionName> = { readonly [Field in DocumentField<Name>]?: FilterValue<DocumentFieldValue<Name, Field>>; };
+export interface CmsDocumentQuerySort<Name extends CmsCollectionName> {
+  readonly direction?: 'asc' | 'desc';
+  readonly field: DocumentField<Name>;
+}
+export interface CmsDocumentQuery<Name extends CmsCollectionName = CmsCollectionName> {
+  readonly collection?: Name;
+  readonly locale?: CmsLocale;
+  readonly limit: number;
+  readonly offset?: number;
+  readonly sort?: CmsDocumentQuerySort<Name> | ReadonlyArray<CmsDocumentQuerySort<Name>>;
+  readonly where?: CmsDocumentQueryWhere<Name>;
+}
+export interface CmsDocumentPage<Name extends CmsCollectionName> extends Omit<DeliveryDocumentPage, 'items'> {
+  readonly items: ReadonlyArray<CmsCollection<Name>>;
+}
+//#endregion
+export type { CmsLocale, CmsMessageKey, CmsMessageParameters };
+//# sourceMappingURL=ApplicationTypes.d.ts.map

package/src/ApplicationTypes.js

@@ -0,0 +1 @@
+export {  };

package/src/{Configuration-CDMYfTre.js → Configuration-BU-UyGoH.js}

@@ -1,6 +1,6 @@
-import { r as FormCapabilities } from "./Forms-CfcI3tPU.js";
-import { c as resolveCmsComarkAttributes, d as createCmsComarkRenderData, l as withCmsComarkProps, r as formStructureIssues, s as projectCmsEditorComponentAttributes } from "./Forms-Dj6NuW66.js";
-import { Ct as CollectionName, St as AddressPattern, Tt as SourceDirectory, b as MarkdownNode, n as CmsMarkdownDocument, wt as Locale } from "./models-Bah5B3bT.js";
+import { Ct as CollectionName, St as AddressPattern, Tt as SourceDirectory, b as MarkdownNode, n as CmsMarkdownDocument, wt as Locale } from "./models-ChRxBChy.js";
+import { r as FormCapabilities } from "./Forms-BbkE7QfC.js";
+import { c as resolveCmsComarkAttributes, d as createCmsComarkRenderData, l as withCmsComarkProps, r as formStructureIssues, s as projectCmsEditorComponentAttributes } from "./Forms-DoB56hfe.js";
 import { a as createEditorNodeId, n as editorMetadata, o as editorNodeId } from "./metadata-BEZPWh-3.js";
 import { Effect, Option, Predicate, Schema } from "effect";
 import { Extension } from "@tiptap/core";
@@ -1030,4 +1030,4 @@ const MediaConfiguration = Schema.Struct({
 
 //#endregion
 export { finiteNumberAttribute as C, compactJsonAttributes as S, comarkTagForEditorMark as _, BlockAuthoring as a, encodeEditorImageAttributes as b, parseAuthoringContent as c, EditorRenderFailed as d, DOCUMENT_ENGINE_FINGERPRINT as f, EDITOR_MARK_TYPES as g, comarkToEditor as h, MediaConfiguration as i, validateCollectionBody as l, SOURCE_MAPPINGS_META_KEY as m, ComponentDefinition as n, createAuthoringDocumentValidator as o, createDocumentParser as p, DocumentConfiguration as r, createAuthoringSchema as s, AuthoringCatalog as t, EditorDocumentInvalid as u, isEditorMark as v, nonEmptyStringAttribute as w, normalizeEditorImageLayout as x, EDITOR_IMAGE_LAYOUT_ATTRIBUTE as y };
-//# sourceMappingURL=Configuration-CDMYfTre.js.map
+//# sourceMappingURL=Configuration-BU-UyGoH.js.map