@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/Configuration-Dk2k3OIc.js

@@ -0,0 +1,73 @@
+import { i as configurationDefaults, n as ResolvedConfiguration, s as runtimeFromEnvironment } from "./Config-CMiwciub.js";
+import { Effect, Schema } from "effect";
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { loadConfig, setupDotenv } from "c12";
+//#region ../cli/src/Configuration.ts
+var ConfigurationError = class extends Schema.TaggedError()("Configuration.Error", { message: Schema.String }) {};
+/** Shared by Nuxt and every CLI command. Loading never provisions resources or writes secrets. */
+const load = Effect.fn("Configuration.load")(function* (directory, envName = "development", envFile, inherited = process.env) {
+	const project = resolve(directory);
+	const file = resolve(project, "cms.config.ts");
+	const environmentFile = resolve(project, envFile || ".env");
+	const environment = yield* Effect.tryPromise({
+		try: async () => {
+			const selected = { ...inherited };
+			if (envFile === false) return selected;
+			if (envFile && !(await stat(environmentFile)).isFile()) throw new Error("Missing environment file");
+			await setupDotenv({
+				cwd: project,
+				fileName: environmentFile,
+				env: selected,
+				interpolate: true
+			});
+			return selected;
+		},
+		catch: () => new ConfigurationError({ message: `Could not read ${environmentFile}.` })
+	});
+	const configuration = yield* Effect.gen(function* () {
+		const candidate = (yield* Effect.tryPromise({
+			try: () => loadConfig({
+				name: "cms",
+				cwd: project,
+				configFile: "cms.config.ts",
+				configFileRequired: true,
+				envName,
+				rcFile: false,
+				globalRc: false,
+				packageJson: false,
+				extend: false,
+				giget: false,
+				dotenv: false,
+				omit$Keys: true,
+				defaults: configurationDefaults
+			}),
+			catch: () => new ConfigurationError({ message: `Could not load ${file}.` })
+		})).config;
+		const configured = yield* Schema.decodeUnknownEffect(ResolvedConfiguration)(candidate, { onExcessProperty: "error" });
+		const runtime = yield* Effect.try(() => runtimeFromEnvironment(configured.runtime, environment));
+		const bootstrap = configured.bootstrap;
+		return {
+			...configured,
+			runtime,
+			...bootstrap ? { bootstrap: {
+				...bootstrap,
+				administrator: {
+					...bootstrap.administrator,
+					email: environment.NUXT_CMS_BOOTSTRAP_ADMINISTRATOR_EMAIL ?? bootstrap.administrator.email,
+					password: environment.NUXT_CMS_BOOTSTRAP_ADMINISTRATOR_PASSWORD ?? bootstrap.administrator.password
+				}
+			} } : void 0
+		};
+	}).pipe(Effect.mapError(() => new ConfigurationError({ message: `Could not load ${file}. Check the CMS configuration and NUXT_CMS_* overrides for ${envName}.` })));
+	return {
+		project,
+		configuration,
+		environment,
+		environmentFile,
+		envName,
+		site: new URL(configuration.runtime.origin)
+	};
+});
+//#endregion
+export { load as t };

package/src/DataTransfer-BmECvPHB.js

@@ -0,0 +1,488 @@
+import { i as MediaId } from "./Media-DSyvd14o.js";
+import { h as CmsData, m as errors, p as api, t as ApiError } from "./StudioApi-CXLwwocX.js";
+import { Effect, FileSystem, Layer, Path, Schema, Stream } from "effect";
+import { Cookies, FetchHttpClient, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { HttpApiClient } from "effect/http-api";
+import { createHash } from "node:crypto";
+import { PassThrough, Readable } from "node:stream";
+import { crc32 } from "node:zlib";
+import * as NodeStream from "@effect/platform-node/NodeStream";
+import { openPromise } from "yauzl";
+import { ZipFile } from "yazl";
+//#region ../model/src/Readiness.ts
+/** Public diagnostics contain recovery guidance, never provider errors or installation secrets. */
+const Check = Schema.Struct({
+	status: Schema.Literals([
+		"passed",
+		"failed",
+		"skipped"
+	]),
+	code: Schema.NonEmptyString,
+	message: Schema.NonEmptyString,
+	action: Schema.Literals([
+		"none",
+		"retry",
+		"check_configuration",
+		"check_database",
+		"check_media",
+		"restart"
+	])
+});
+const Report = Schema.Struct({
+	status: Schema.Literals(["ready", "unavailable"]),
+	checks: Schema.Struct({
+		configuration: Check,
+		database: Check,
+		media: Check,
+		installation: Check
+	})
+}).check(Schema.makeFilter((report) => report.status === "ready" === Object.values(report.checks).every((check) => check.status === "passed")));
+//#endregion
+//#region ../cli/src/internal/connection.ts
+const layer = FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.RequestInit, { redirect: "error" })));
+var ClientError = class extends Schema.TaggedError()("Client.Error", {
+	message: Schema.String,
+	status: Schema.optionalKey(Schema.Int),
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+var ReadinessError = class extends Schema.TaggedError()("Client.ReadinessError", {
+	code: Schema.String,
+	message: Schema.String,
+	action: Check.fields.action
+}) {};
+const make$1 = Effect.fn("Client.connect")(function* (site, initialSession = "") {
+	const loopback = [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(site.hostname);
+	if (site.protocol !== "https:" && !(site.protocol === "http:" && loopback)) return yield* new ClientError({ message: "Use HTTPS for a deployed CMS. HTTP is allowed only on localhost." });
+	if (site.username || site.password) return yield* new ClientError({ message: "Supply credentials separately from the installation URL." });
+	const transport = yield* HttpClient.HttpClient;
+	let session = initialSession;
+	const authenticated = transport.pipe(HttpClient.mapRequest((request) => {
+		let input = session ? HttpClientRequest.setHeader("cookie", session)(request) : request;
+		if (request.method !== "GET" && request.method !== "HEAD") input = HttpClientRequest.setHeader("origin", site.origin)(input);
+		return input;
+	}), HttpClient.withScope);
+	const api$1 = yield* HttpApiClient.makeWith(api, {
+		baseUrl: site,
+		httpClient: authenticated
+	});
+	const authRequest = Effect.fn("Client.authRequest")(function* (action, body) {
+		const request = HttpClientRequest.post(new URL(`/_cms/auth/${action}`, site)).pipe(HttpClientRequest.bodyJsonUnsafe(body));
+		const response = yield* authenticated.execute(request);
+		if (response.status < 200 || response.status >= 300) {
+			const details = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
+			return yield* new ClientError({
+				message: `Authentication failed (${response.status}): ${details.slice(0, 2e3)}`,
+				status: response.status
+			});
+		}
+		return response;
+	});
+	const signIn = Effect.fn("Client.signIn")(function* (email, password) {
+		const response = yield* authRequest("sign-in/email", {
+			email,
+			password
+		});
+		const cookie = Cookies.toCookieHeader(response.cookies);
+		if (!cookie) return yield* new ClientError({ message: "Sign-in did not return a session." });
+		session = cookie;
+		return yield* api$1.connection.user();
+	}, Effect.scoped);
+	return {
+		api: api$1,
+		readiness: Effect.fn("Client.readiness")(function* () {
+			const response = yield* transport.get(new URL("/_cms/health/ready", site)).pipe(Effect.mapError(() => new ReadinessError({
+				code: "connection_failed",
+				action: "retry",
+				message: "Could not reach the CMS readiness endpoint. Check the configured origin and start the server."
+			})));
+			if (response.status !== 200 && response.status !== 503) return yield* new ReadinessError({
+				code: "response_rejected",
+				action: "check_configuration",
+				message: `The readiness endpoint returned HTTP ${response.status}. Check the origin, CMS route, and reverse proxy.`
+			});
+			const report = yield* HttpClientResponse.schemaBodyJson(Report)(response).pipe(Effect.mapError(() => new ReadinessError({
+				code: "response_invalid",
+				action: "check_configuration",
+				message: "The readiness endpoint returned an invalid report. Check the origin and deployed CMS version."
+			})));
+			if (response.status === 200 !== (report.status === "ready")) return yield* new ReadinessError({
+				code: "response_invalid",
+				action: "check_configuration",
+				message: "The readiness HTTP status disagrees with its report. Check the CMS route and reverse proxy."
+			});
+			return report;
+		}, (effect) => effect.pipe(Effect.timeoutOrElse({
+			duration: "5 seconds",
+			orElse: () => Effect.fail(new ReadinessError({
+				code: "connection_timeout",
+				action: "retry",
+				message: "The readiness request timed out after five seconds. Check server startup and proxy logs, then retry cms doctor."
+			}))
+		}), Effect.scoped)),
+		get session() {
+			return session;
+		},
+		signIn,
+		initialize: Effect.fn("Client.initialize")(function* (input) {
+			yield* api$1.session.initialize({ payload: input });
+			return yield* signIn(input.email, input.password);
+		}, Effect.scoped),
+		signOut: Effect.fn("Client.signOut")(function* () {
+			yield* authRequest("sign-out", {});
+			session = "";
+		}, Effect.scoped),
+		resetPassword: Effect.fn("Client.resetPassword")(function* (token, newPassword) {
+			yield* authRequest("reset-password", {
+				token,
+				newPassword
+			});
+		}, Effect.scoped),
+		mediaAsset: (id) => api$1.media.get({ params: { id } }).pipe(Effect.catchTag("Studio.NotFound", () => Effect.succeed(null))),
+		mediaStream: (id) => Stream.unwrap(authenticated.get(new URL(`/_cms/media/${id}`, site)).pipe(Effect.flatMap((response) => {
+			if (response.status !== 200) return new ClientError({
+				message: `Could not read media ${id}.`,
+				status: response.status
+			});
+			return Effect.succeed(response.stream);
+		}))),
+		uploadMedia: Effect.fn("Client.uploadMedia")(function* (input) {
+			const fs = yield* FileSystem.FileSystem;
+			return yield* (yield* HttpApiClient.makeWith(api, {
+				baseUrl: site,
+				httpClient: authenticated.pipe(HttpClient.mapRequest((request) => HttpClientRequest.setBody(request, HttpBody.stream(fs.stream(input.filePath), input.mimeType, input.byteSize))))
+			})).media.upload({ headers: {
+				"content-type": input.mimeType,
+				"x-cms-media-id": input.id,
+				"x-cms-media-name": encodeURIComponent(input.name),
+				"x-cms-media-folder": encodeURIComponent(input.folder),
+				"x-cms-media-size": input.byteSize,
+				"x-cms-media-sha256": input.sha256
+			} });
+		}, Effect.scoped)
+	};
+});
+//#endregion
+//#region ../cli/src/DataArchive.ts
+var SnapshotError = class extends Schema.TaggedError()("Data.InvalidSnapshot", {
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+const mediaPath = (asset) => `media/${asset.sha256}`;
+const verifiedMedia = (asset, source) => Stream.suspend(() => {
+	const hash = createHash("sha256");
+	let byteSize = 0;
+	return source.pipe(Stream.mapEffect((chunk) => {
+		byteSize += chunk.byteLength;
+		if (byteSize > asset.byteSize) return Effect.fail(new SnapshotError({ message: `Media ${asset.id} exceeds its exported size.` }));
+		hash.update(chunk);
+		return Effect.succeed(chunk);
+	}), Stream.concat(Stream.fromEffect(Effect.suspend(() => byteSize === asset.byteSize && hash.digest("hex") === asset.sha256 ? Effect.succeed(/* @__PURE__ */ new Uint8Array(0)) : Effect.fail(new SnapshotError({ message: `Media ${asset.id} has incorrect exported bytes.` }))))));
+});
+const entryStream = (archive, entry) => Stream.unwrap(Effect.gen(function* () {
+	const input = yield* Effect.acquireRelease(Effect.tryPromise({
+		try: () => archive.openReadStreamPromise(entry),
+		catch: (cause) => new SnapshotError({
+			message: `Could not read ${entry.fileName}.`,
+			cause
+		})
+	}), (input) => Effect.sync(() => input.destroy()));
+	let checksum = 0;
+	return NodeStream.fromReadable({
+		evaluate: () => input,
+		onError: (cause) => new SnapshotError({
+			message: `Invalid ZIP entry ${entry.fileName}.`,
+			cause
+		})
+	}).pipe(Stream.map((chunk) => {
+		checksum = crc32(chunk, checksum);
+		return chunk;
+	}), Stream.concat(Stream.fromEffect(Effect.suspend(() => checksum === entry.crc32 ? Effect.succeed(/* @__PURE__ */ new Uint8Array(0)) : Effect.fail(new SnapshotError({ message: `ZIP checksum mismatch for ${entry.fileName}.` }))))));
+}));
+/** Validate the complete snapshot in private staging before any network mutation. */
+const readSnapshot = Effect.fn("DataArchive.read")(function* (location) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const file = path.resolve(location);
+	const archive = yield* Effect.acquireRelease(Effect.tryPromise({
+		try: () => openPromise(file, {
+			autoClose: false,
+			strictFileNames: true
+		}),
+		catch: (cause) => new SnapshotError({
+			message: `Could not open snapshot ${file}.`,
+			cause
+		})
+	}), (archive) => Effect.sync(() => archive.close()));
+	const entries = /* @__PURE__ */ new Map();
+	yield* Stream.fromAsyncIterable(archive.eachEntry(), (cause) => new SnapshotError({
+		message: `Invalid snapshot ${file}.`,
+		cause
+	})).pipe(Stream.runForEach((entry) => Effect.gen(function* () {
+		const kind = entry.externalFileAttributes >>> 16 & 61440;
+		if (entries.has(entry.fileName) || entry.fileName !== "snapshot.json" && !/^media\/[a-f0-9]{64}$/u.test(entry.fileName) || kind !== 0 && kind !== 32768) return yield* new SnapshotError({ message: `Unexpected or duplicate ZIP entry ${entry.fileName}.` });
+		entries.set(entry.fileName, entry);
+	})));
+	const metadata = entries.get("snapshot.json");
+	if (!metadata) return yield* new SnapshotError({ message: "The snapshot is missing snapshot.json." });
+	const json = yield* entryStream(archive, metadata).pipe(Stream.decodeText, Stream.mkString);
+	const data = yield* Schema.decodeEffect(Schema.fromJsonString(CmsData), { onExcessProperty: "error" })(json).pipe(Effect.mapError((cause) => new SnapshotError({
+		message: `Invalid CMS state in ${file}: ${cause.message}`,
+		cause
+	})));
+	const staging = yield* fs.makeTempDirectoryScoped({ prefix: "cms-import-" });
+	const verified = /* @__PURE__ */ new Map();
+	const media = [];
+	for (const asset of data.media) {
+		const name = mediaPath(asset);
+		const entry = entries.get(name);
+		if (!entry || entry.uncompressedSize !== asset.byteSize) return yield* new SnapshotError({ message: `Missing or incorrect media bytes for ${asset.id}.` });
+		let filePath = verified.get(name);
+		if (!filePath) {
+			filePath = path.join(staging, asset.sha256);
+			yield* verifiedMedia(asset, entryStream(archive, entry)).pipe(Stream.run(fs.sink(filePath, {
+				flag: "wx",
+				mode: 384
+			})));
+			verified.set(name, filePath);
+		}
+		media.push({
+			metadata: asset,
+			filePath
+		});
+	}
+	if (entries.size !== verified.size + 1) return yield* new SnapshotError({ message: "The snapshot contains media absent from snapshot.json." });
+	return {
+		data,
+		media
+	};
+});
+/** Stream a complete ZIP into private staging, then publish it atomically. */
+const writeSnapshot = Effect.fn("DataArchive.write")(function* (location, data, readMedia, force = false) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const file = path.resolve(location);
+	if ((yield* fs.exists(file)) && !force) return yield* new SnapshotError({ message: `${file} already exists. Use --force to overwrite the snapshot.` });
+	yield* fs.makeDirectory(path.dirname(file), { recursive: true });
+	const staging = yield* fs.makeTempDirectoryScoped({
+		directory: path.dirname(file),
+		prefix: ".cms-export-"
+	});
+	const temporary = path.join(staging, "snapshot.zip");
+	const encoded = yield* Schema.encodeEffect(CmsData)(data);
+	const files = /* @__PURE__ */ new Map();
+	for (const asset of data.media) files.set(mediaPath(asset), asset);
+	yield* Effect.scoped(Effect.gen(function* () {
+		const inputs = [];
+		const options = {
+			mtime: new Date(1980, 0, 1),
+			forceDosTimestamp: true,
+			mode: 33152
+		};
+		yield* Effect.addFinalizer(() => Effect.sync(() => inputs.forEach(({ input }) => input.destroy())));
+		const metadata = Readable.from([Buffer.from(JSON.stringify(encoded))]);
+		inputs.push({
+			name: "snapshot.json",
+			input: metadata
+		});
+		for (const [name, asset] of files) {
+			const input = yield* NodeStream.toReadable(verifiedMedia(asset, readMedia(asset.id)));
+			inputs.push({
+				name,
+				input,
+				size: asset.byteSize
+			});
+		}
+		const fileHandle = yield* fs.open(temporary, {
+			flag: "wx",
+			mode: 384
+		});
+		const stream = NodeStream.fromReadable({
+			evaluate: () => {
+				const archive = new ZipFile();
+				const output = new PassThrough();
+				archive.on("error", (error) => output.destroy(error));
+				archive.outputStream.pipe(output);
+				for (const { name, input, size } of inputs) {
+					input.on("error", (error) => archive.emit("error", error));
+					archive.addReadStream(input, name, {
+						...options,
+						compress: size === void 0,
+						size
+					});
+				}
+				archive.end();
+				return output;
+			},
+			onError: (cause) => new SnapshotError({
+				message: `Could not write snapshot ${file}.`,
+				cause
+			})
+		});
+		yield* Stream.runForEach(stream, (chunk) => fileHandle.writeAll(chunk));
+		yield* fileHandle.sync;
+	}));
+	if (force) yield* fs.rename(temporary, file);
+	else yield* fs.link(temporary, file);
+	return {
+		file,
+		documents: data.documents.length,
+		revisions: data.documents.reduce((total, document) => total + document.revisions.length, 0),
+		media: data.media.length
+	};
+}, Effect.scoped);
+//#endregion
+//#region ../cli/src/Errors.ts
+const ErrorDetails = Schema.Struct({
+	code: Schema.String,
+	message: Schema.String,
+	status: Schema.optionalKey(Schema.Int),
+	details: Schema.optionalKey(Schema.Json)
+});
+function errorDetails(error) {
+	for (const definition of errors) if (Schema.is(definition)(error)) return {
+		code: error._tag,
+		message: error.error,
+		status: Schema.resolveAnnotations(definition)?.httpApiStatus ?? 500,
+		details: Schema.encodeSync(ApiError)(error)
+	};
+	if (HttpClientError.isHttpClientError(error)) {
+		if (error.reason instanceof HttpClientError.TransportError) return {
+			code: "Client.NetworkError",
+			message: "Could not reach the CMS."
+		};
+		if (error.reason instanceof HttpClientError.DecodeError || error.reason instanceof HttpClientError.EmptyBodyError) return {
+			code: "Client.InvalidResponse",
+			message: "The CMS returned an invalid response.",
+			status: error.reason.response.status
+		};
+		if (error.reason instanceof HttpClientError.StatusCodeError) return {
+			code: "Client.ResponseError",
+			message: "The CMS rejected the request.",
+			status: error.reason.response.status
+		};
+		return {
+			code: "Client.RequestError",
+			message: "Could not construct the CMS request."
+		};
+	}
+	if (Schema.is(Schema.Struct({
+		_tag: Schema.String,
+		message: Schema.String,
+		status: Schema.optionalKey(Schema.Int)
+	}))(error)) return error.status === void 0 ? {
+		code: error._tag,
+		message: error.message
+	} : {
+		code: error._tag,
+		message: error.message,
+		status: error.status
+	};
+	return {
+		code: "Client.UnexpectedError",
+		message: error instanceof Error ? error.message : "CMS request failed."
+	};
+}
+//#endregion
+//#region ../cli/src/DataTransfer.ts
+var ImportError = class extends Schema.TaggedError()("Data.ImportFailed", {
+	message: Schema.String,
+	phase: Schema.Literals([
+		"prepare",
+		"upload",
+		"apply"
+	]),
+	outcome: Schema.Literals([
+		"not-applied",
+		"partial",
+		"unknown"
+	]),
+	uploadedMedia: Schema.Array(MediaId),
+	uncertainMediaId: Schema.NullOr(MediaId),
+	error: ErrorDetails
+}) {};
+function make(connection) {
+	return {
+		export: Effect.fn("DataTransfer.export")(function* (file, force = false) {
+			const data = yield* connection.api.data.snapshot();
+			return yield* writeSnapshot(file, data, connection.mediaStream, force);
+		}),
+		import: Effect.fn("DataTransfer.import")((file, options = {}) => {
+			let phase = "prepare";
+			const uploadedMedia = [];
+			let uncertainMediaId = null;
+			return Effect.gen(function* () {
+				const bundle = yield* readSnapshot(file);
+				const input = {
+					data: bundle.data,
+					replace: options.replace ?? false
+				};
+				const plan = yield* connection.api.data.plan({ payload: input });
+				const media = yield* Effect.forEach(bundle.media, (file) => connection.mediaAsset(file.metadata.id).pipe(Effect.map((remote) => ({
+					file,
+					remote
+				}))));
+				if (media.some(({ file: { metadata }, remote }) => remote && (remote.mimeType !== metadata.mimeType || remote.byteSize !== metadata.byteSize || remote.sha256 !== metadata.sha256))) return yield* new ImportError({
+					message: "A media ID has different bytes in the target CMS.",
+					phase,
+					outcome: "not-applied",
+					uploadedMedia,
+					uncertainMediaId,
+					error: {
+						code: "Data.MediaConflict",
+						message: "Replace the conflicting asset with a new media identity."
+					}
+				});
+				const uploads = media.flatMap(({ file, remote }) => remote ? [] : [file]);
+				const summary = {
+					...plan,
+					media: {
+						uploaded: uploads.length,
+						unchanged: media.length - uploads.length
+					}
+				};
+				if (options.dryRun) return {
+					...summary,
+					status: "planned"
+				};
+				phase = "upload";
+				for (const upload of uploads) {
+					uncertainMediaId = upload.metadata.id;
+					yield* connection.uploadMedia({
+						...upload.metadata,
+						filePath: upload.filePath
+					});
+					uploadedMedia.push(upload.metadata.id);
+					uncertainMediaId = null;
+				}
+				phase = "apply";
+				const accepted = yield* connection.api.data.apply({ payload: {
+					...input,
+					stamp: plan.stamp
+				} });
+				return {
+					...accepted,
+					media: summary.media,
+					status: accepted.status === "unchanged" ? "unchanged" : "applied"
+				};
+			}).pipe(Effect.catch((error) => {
+				if (error instanceof ImportError) return Effect.fail(error);
+				const details = errorDetails(error);
+				const rejected = Schema.is(ApiError)(error) && details.status !== void 0 && details.status >= 400 && details.status < 500;
+				return Effect.fail(new ImportError({
+					message: details.message,
+					phase,
+					outcome: !rejected && (phase === "apply" || uncertainMediaId !== null) ? "unknown" : uploadedMedia.length ? "partial" : "not-applied",
+					uploadedMedia,
+					uncertainMediaId: rejected ? null : uncertainMediaId,
+					error: details
+				}));
+			}));
+		})
+	};
+}
+//#endregion
+export { ReadinessError as a, ClientError as i, make as n, layer as o, errorDetails as r, make$1 as s, ImportError as t };

package/src/Database-DSsNCGft.d.ts

@@ -0,0 +1,3 @@
+import { Context, Effect, Layer } from "effect";
+import { SqliteClient } from "@effect/sql-sqlite-node";
+import "drizzle-orm/effect-sqlite-node";

package/src/Delivery.d.ts

@@ -0,0 +1,28 @@
+import { r as MediaSelection } from "./Media-BQ0uL4w7.js";
+import { r as PublishedDocument, t as DeliveryRedirect } from "./Document-TgwYKJZM.js";
+import { n as AuthoredImage, t as LinkTarget } from "./Links-Dx1yOni8.js";
+import { a as ResolvedLocaleDefinition } from "./Locales-jwbmJaOp.js";
+import "./Seo-BcpqxoAs.js";
+import { i as DocumentQuerySort, n as DocumentQueryItem, r as DocumentQueryPage, t as DocumentQuery } from "./Query-C0kGJF5_.js";
+import { n as DeliveredDocumentPage, r as DeliveredQueryItem, t as DeliveredDocument } from "./forms-3xuf0Ym7.js";
+import { MaybeRefOrGetter } from "vue";
+import { useRequestFetch, useRoute } from "nuxt/app";
+//#region src/runtime/delivery/internal/useDeliveryContext.d.ts
+type DeliveryDocument = DeliveredDocument | DeliveryRedirect | DeliveredQueryItem;
+//#endregion
+//#region src/runtime/delivery/internal/nuxtDelivery.d.ts
+export declare const useCmsDocument: (path: import("vue").MaybeRefOrGetter<string>) => import("nuxt/app").AsyncData<DeliveryDocument | undefined, import("nuxt/server").NuxtError<unknown> | undefined>, useCmsDocumentQuery: (input: import("vue").MaybeRefOrGetter<DocumentQuery>) => import("nuxt/app").AsyncData<DeliveredDocumentPage, import("nuxt/server").NuxtError<unknown> | undefined>, useCmsDocumentSeo: (document: import("vue").MaybeRefOrGetter<PublishedDocument | DocumentQueryItem | DeliveryRedirect | null | undefined>) => Promise<void>;
+//#endregion
+//#region src/runtime/delivery/useCmsLocale.d.ts
+/** URL locale and site-path helpers; UI message catalogs belong to the Nuxt site. */
+export declare function useCmsLocale(): {
+  locale: import("vue").ComputedRef<string | undefined>;
+  locales: ResolvedLocaleDefinition[];
+  defaultLocale: string | undefined;
+  direction: import("vue").ComputedRef<"ltr" | "rtl">;
+  sitePath: import("vue").ComputedRef<string>;
+  localePath: (path: string, code?: string | undefined) => string;
+  switchLocalePath: (code: string, destination?: string) => string;
+};
+//#endregion
+export { AuthoredImage, type DeliveredDocument, type DeliveredDocumentPage, type DeliveredQueryItem, type DocumentQuery, type DocumentQueryPage, type DocumentQuerySort, type LinkTarget, type MediaSelection };

package/src/Delivery.js

@@ -0,0 +1,7 @@
+import { t as AuthoredImage } from "./Image-CJWPLnhP.js";
+import { n as useCmsDocumentQuery, r as useCmsDocumentSeo, t as useCmsDocument } from "./nuxtDelivery-BYX_Cddb.js";
+import "./runtime/delivery/useCmsDocument.js";
+import "./runtime/delivery/useCmsDocumentQuery.js";
+import "./runtime/delivery/useCmsDocumentSeo.js";
+import { useCmsLocale } from "./runtime/delivery/useCmsLocale.js";
+export { AuthoredImage, useCmsDocument, useCmsDocumentQuery, useCmsDocumentSeo, useCmsLocale };