agent-cms 0.1.0

package/dist/structured-text-service-B4xSlUg_.mjs

@@ -0,0 +1,1952 @@
+import { Data, Effect, ParseResult, Schema } from "effect";
+import { SqlClient, SqlError } from "@effect/sql";
+import * as Either from "effect/Either";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import "remark-stringify";
+import remarkGfm from "remark-gfm";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/errors.ts
+/** Model/field/record not found */
+var NotFoundError = class extends Data.TaggedError("NotFoundError") {};
+/** Validation error (field values, DAST, API input) */
+var ValidationError = class extends Data.TaggedError("ValidationError") {};
+/** Reference conflict — trying to delete something that's referenced */
+var ReferenceConflictError = class extends Data.TaggedError("ReferenceConflictError") {};
+/** Duplicate — e.g., apiKey already exists */
+var DuplicateError = class extends Data.TaggedError("DuplicateError") {};
+/** Schema engine error — DDL failed, migration issue */
+var SchemaEngineError = class extends Data.TaggedError("SchemaEngineError") {};
+/** Unauthorized access to a protected API surface */
+var UnauthorizedError = class extends Data.TaggedError("UnauthorizedError") {};
+/** Runtime type guard for CmsError — uses instanceof, no duck-typing */
+function isCmsError(error) {
+	return error instanceof NotFoundError || error instanceof ValidationError || error instanceof ReferenceConflictError || error instanceof DuplicateError || error instanceof SchemaEngineError || error instanceof UnauthorizedError;
+}
+/** Map a CMS error to an HTTP status code and JSON body */
+function errorToResponse(error) {
+	switch (error._tag) {
+		case "NotFoundError": return {
+			status: 404,
+			body: { error: `${error.entity} not found: ${error.id}` }
+		};
+		case "ValidationError": return {
+			status: 400,
+			body: { error: error.message }
+		};
+		case "ReferenceConflictError": return {
+			status: 409,
+			body: { error: error.message }
+		};
+		case "DuplicateError": return {
+			status: 409,
+			body: { error: error.message }
+		};
+		case "SchemaEngineError": return {
+			status: 500,
+			body: { error: error.message }
+		};
+		case "UnauthorizedError": return {
+			status: 401,
+			body: { error: error.message }
+		};
+	}
+}
+//#endregion
+//#region src/field-types.ts
+/**
+* Typed field type registry.
+*
+* Each field type defines its static properties in one place:
+* SQL storage, GraphQL type, filter type, validation schema, etc.
+*
+* The "type sandwich":
+* - Top: system tables (models, fields) are statically typed
+* - Middle: which fields exist on which models is dynamic (runtime)
+* - Bottom: each field type's shape is statically known (this file)
+*/
+/** Effect Schemas for composite field type validation */
+const ColorSchema = Schema.Struct({
+	red: Schema.Number.pipe(Schema.int(), Schema.between(0, 255)),
+	green: Schema.Number.pipe(Schema.int(), Schema.between(0, 255)),
+	blue: Schema.Number.pipe(Schema.int(), Schema.between(0, 255)),
+	alpha: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.between(0, 255)))
+});
+const LatLonSchema = Schema.Struct({
+	latitude: Schema.Number.pipe(Schema.between(-90, 90)),
+	longitude: Schema.Number.pipe(Schema.between(-180, 180))
+});
+const SeoSchema = Schema.Struct({
+	title: Schema.optional(Schema.String),
+	description: Schema.optional(Schema.String),
+	image: Schema.optional(Schema.String),
+	twitterCard: Schema.optional(Schema.String)
+});
+const MediaFocalPointSchema = Schema.Struct({
+	x: Schema.Number.pipe(Schema.between(0, 1)),
+	y: Schema.Number.pipe(Schema.between(0, 1))
+});
+const MediaFieldObjectSchema = Schema.Struct({
+	upload_id: Schema.String,
+	alt: Schema.optional(Schema.NullOr(Schema.String)),
+	title: Schema.optional(Schema.NullOr(Schema.String)),
+	focal_point: Schema.optional(Schema.NullOr(MediaFocalPointSchema)),
+	custom_data: Schema.optional(Schema.NullOr(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	})))
+});
+const MediaFieldSchema = Schema.Union(Schema.String, MediaFieldObjectSchema);
+const MediaGalleryFieldSchema = Schema.Array(MediaFieldSchema);
+function isValidIsoDate(value) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+	const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+	return !Number.isNaN(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
+}
+function isValidIsoDateTime(value) {
+	if (!/^\d{4}-\d{2}-\d{2}T/.test(value)) return false;
+	return !Number.isNaN(Date.parse(value));
+}
+const DateSchema = Schema.String.pipe(Schema.filter(isValidIsoDate, { message: () => "expected ISO date string YYYY-MM-DD" }));
+const DateTimeSchema = Schema.String.pipe(Schema.filter(isValidIsoDateTime, { message: () => "expected ISO datetime string" }));
+/**
+* The field type registry — one entry per field type.
+* Add a new field type here and TypeScript will enforce all properties are defined.
+*/
+const FIELD_TYPE_REGISTRY = {
+	string: {
+		sqliteType: "TEXT",
+		graphqlType: "String",
+		filterType: "StringFilter",
+		localizable: true,
+		multiLocaleType: "StringMultiLocaleField",
+		inputSchema: null,
+		jsonStored: false,
+		hasCustomResolver: false
+	},
+	text: {
+		sqliteType: "TEXT",
+		graphqlType: "String",
+		filterType: "StringFilter",
+		localizable: true,
+		multiLocaleType: "StringMultiLocaleField",
+		inputSchema: null,
+		jsonStored: false,
+		hasCustomResolver: false
+	},
+	boolean: {
+		sqliteType: "INTEGER",
+		graphqlType: "Boolean",
+		filterType: "BooleanFilter",
+		localizable: true,
+		multiLocaleType: "BooleanMultiLocaleField",
+		inputSchema: Schema.Boolean,
+		jsonStored: false,
+		hasCustomResolver: false
+	},
+	integer: {
+		sqliteType: "INTEGER",
+		graphqlType: "Int",
+		filterType: "IntFilter",
+		localizable: true,
+		multiLocaleType: "IntMultiLocaleField",
+		inputSchema: Schema.Number.pipe(Schema.int()),
+		jsonStored: false,
+		hasCustomResolver: false
+	},
+	float: {
+		sqliteType: "REAL",
+		graphqlType: "Float",
+		filterType: "FloatFilter",
+		localizable: true,
+		multiLocaleType: "FloatMultiLocaleField",
+		inputSchema: Schema.Number,
+		jsonStored: false,
+		hasCustomResolver: false
+	},
+	slug: {
+		sqliteType: "TEXT",
+		graphqlType: "String",
+		filterType: "StringFilter",
+		localizable: true,
+		multiLocaleType: "StringMultiLocaleField",
+		inputSchema: null,
+		jsonStored: false,
+		hasCustomResolver: false
+	},
+	date: {
+		sqliteType: "TEXT",
+		graphqlType: "String",
+		filterType: "StringFilter",
+		localizable: true,
+		multiLocaleType: "StringMultiLocaleField",
+		inputSchema: DateSchema,
+		jsonStored: false,
+		hasCustomResolver: false
+	},
+	date_time: {
+		sqliteType: "TEXT",
+		graphqlType: "String",
+		filterType: "StringFilter",
+		localizable: true,
+		multiLocaleType: "StringMultiLocaleField",
+		inputSchema: DateTimeSchema,
+		jsonStored: false,
+		hasCustomResolver: false
+	},
+	media: {
+		sqliteType: "TEXT",
+		graphqlType: "Asset",
+		filterType: "LinkFilter",
+		localizable: false,
+		multiLocaleType: "StringMultiLocaleField",
+		inputSchema: MediaFieldSchema,
+		jsonStored: false,
+		hasCustomResolver: true
+	},
+	media_gallery: {
+		sqliteType: "TEXT",
+		graphqlType: "[Asset!]",
+		filterType: "LinksFilter",
+		localizable: false,
+		multiLocaleType: "JsonMultiLocaleField",
+		inputSchema: MediaGalleryFieldSchema,
+		jsonStored: true,
+		hasCustomResolver: true
+	},
+	link: {
+		sqliteType: "TEXT",
+		graphqlType: null,
+		filterType: "LinkFilter",
+		localizable: false,
+		multiLocaleType: "StringMultiLocaleField",
+		inputSchema: null,
+		jsonStored: false,
+		hasCustomResolver: true
+	},
+	links: {
+		sqliteType: "TEXT",
+		graphqlType: null,
+		filterType: "LinksFilter",
+		localizable: false,
+		multiLocaleType: "JsonMultiLocaleField",
+		inputSchema: null,
+		jsonStored: true,
+		hasCustomResolver: true
+	},
+	structured_text: {
+		sqliteType: "TEXT",
+		graphqlType: "StructuredText",
+		filterType: "TextFilter",
+		localizable: false,
+		multiLocaleType: "JsonMultiLocaleField",
+		inputSchema: null,
+		jsonStored: true,
+		hasCustomResolver: true
+	},
+	seo: {
+		sqliteType: "TEXT",
+		graphqlType: "SeoField",
+		filterType: "ExistsFilter",
+		localizable: false,
+		multiLocaleType: "SeoMultiLocaleField",
+		inputSchema: SeoSchema,
+		jsonStored: true,
+		hasCustomResolver: true
+	},
+	json: {
+		sqliteType: "TEXT",
+		graphqlType: "JSON",
+		filterType: "ExistsFilter",
+		localizable: false,
+		multiLocaleType: "JsonMultiLocaleField",
+		inputSchema: null,
+		jsonStored: true,
+		hasCustomResolver: false
+	},
+	color: {
+		sqliteType: "TEXT",
+		graphqlType: "ColorField",
+		filterType: "ExistsFilter",
+		localizable: false,
+		multiLocaleType: "JsonMultiLocaleField",
+		inputSchema: ColorSchema,
+		jsonStored: true,
+		hasCustomResolver: true
+	},
+	lat_lon: {
+		sqliteType: "TEXT",
+		graphqlType: "LatLonField",
+		filterType: "LatLonFilter",
+		localizable: false,
+		multiLocaleType: "JsonMultiLocaleField",
+		inputSchema: LatLonSchema,
+		jsonStored: true,
+		hasCustomResolver: true
+	},
+	video: {
+		sqliteType: "TEXT",
+		graphqlType: "VideoField",
+		filterType: "ExistsFilter",
+		localizable: false,
+		multiLocaleType: "JsonMultiLocaleField",
+		inputSchema: null,
+		jsonStored: false,
+		hasCustomResolver: true
+	}
+};
+/** Get the registry definition for a field type */
+function getFieldTypeDef(fieldType) {
+	return FIELD_TYPE_REGISTRY[fieldType];
+}
+//#endregion
+//#region src/json.ts
+const UnknownJson = Schema.parseJson();
+const JsonRecord = Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+});
+const JsonRecordString = Schema.parseJson(JsonRecord);
+function encodeJson(value) {
+	return Schema.encodeSync(UnknownJson)(value);
+}
+function decodeJsonString(input) {
+	return Schema.decodeUnknownSync(UnknownJson)(input);
+}
+function tryDecodeJsonString(input) {
+	const result = Schema.decodeUnknownEither(UnknownJson)(input);
+	return Either.isRight(result) ? {
+		ok: true,
+		value: result.right
+	} : { ok: false };
+}
+function decodeJsonStringOr(input, fallback) {
+	const parsed = tryDecodeJsonString(input);
+	return parsed.ok ? parsed.value : fallback;
+}
+function decodeJsonRecordStringOr(input, fallback) {
+	const result = Schema.decodeUnknownEither(JsonRecordString)(input);
+	return Either.isRight(result) ? result.right : fallback;
+}
+function decodeJsonIfString(value) {
+	if (typeof value !== "string") return value;
+	return decodeJsonStringOr(value, value);
+}
+//#endregion
+//#region src/media-field.ts
+function parseMediaFieldReference(value) {
+	const parsed = decodeJsonIfString(value);
+	if (typeof parsed === "string") return parsed.length > 0 ? { uploadId: parsed } : null;
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+	const objectValue = parsed;
+	const uploadId = typeof objectValue.upload_id === "string" ? objectValue.upload_id : null;
+	if (!uploadId) return null;
+	return {
+		uploadId,
+		alt: typeof objectValue.alt === "string" || objectValue.alt === null ? objectValue.alt : void 0,
+		title: typeof objectValue.title === "string" || objectValue.title === null ? objectValue.title : void 0,
+		focalPoint: isFocalPoint(objectValue.focal_point) || objectValue.focal_point === null ? objectValue.focal_point ?? null : void 0,
+		customData: isJsonRecord(objectValue.custom_data) || objectValue.custom_data === null ? objectValue.custom_data ?? null : void 0
+	};
+}
+function parseMediaGalleryReferences(value) {
+	const parsed = decodeJsonIfString(value);
+	if (!Array.isArray(parsed)) return [];
+	return parsed.map((entry) => parseMediaFieldReference(entry)).filter((entry) => entry !== null);
+}
+function mergeAssetWithMediaReference(asset, reference, assetUrl) {
+	const defaultCustomData = asset.custom_data ? decodeJsonStringOr(asset.custom_data, null) : null;
+	const defaultFocalPoint = asset.focal_point ? decodeJsonStringOr(asset.focal_point, null) : null;
+	return {
+		id: asset.id,
+		filename: asset.filename,
+		mimeType: asset.mime_type,
+		size: asset.size,
+		width: asset.width,
+		height: asset.height,
+		alt: reference?.alt ?? asset.alt,
+		title: reference?.title ?? asset.title,
+		blurhash: asset.blurhash ?? null,
+		focalPoint: isFocalPoint(reference?.focalPoint) ? reference.focalPoint : isFocalPoint(defaultFocalPoint) ? defaultFocalPoint : null,
+		customData: isJsonRecord(reference?.customData) ? reference.customData : isJsonRecord(defaultCustomData) ? defaultCustomData : null,
+		tags: Array.isArray(decodeJsonStringOr(asset.tags, [])) ? decodeJsonStringOr(asset.tags, []).filter((value) => typeof value === "string") : [],
+		url: assetUrl(asset.r2_key),
+		_createdAt: asset.created_at,
+		_updatedAt: asset.updated_at,
+		_createdBy: asset.created_by,
+		_updatedBy: asset.updated_by
+	};
+}
+function isJsonRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFocalPoint(value) {
+	return isJsonRecord(value) && typeof value.x === "number" && typeof value.y === "number";
+}
+//#endregion
+//#region src/db/validators.ts
+/**
+* Typed access to field validator properties.
+* Instead of casting with `as`, these functions safely extract
+* known validator properties with runtime checks.
+*/
+/** Safely get the slug source field from validators */
+function getSlugSource(validators) {
+	const v = validators.slug_source;
+	return typeof v === "string" ? v : void 0;
+}
+/** Safely get the structured_text_blocks whitelist */
+function getBlockWhitelist(validators) {
+	const v = validators.structured_text_blocks;
+	return Array.isArray(v) && v.every((x) => typeof x === "string") ? v : void 0;
+}
+/** Safely get the blocks_only flag */
+function getBlocksOnly(validators) {
+	return validators.blocks_only === true;
+}
+/** Safely check if field is required */
+function isRequired(validators) {
+	return validators.required === true;
+}
+/** Safely check if field must be unique */
+function isUnique(validators) {
+	return validators.unique === true;
+}
+/** Safely get link target model types (for `link` fields) */
+function getLinkTargets(validators) {
+	const v = validators.item_item_type;
+	return Array.isArray(v) && v.every((x) => typeof x === "string") ? v : void 0;
+}
+/** Safely get links target model types (for `links` fields) */
+function getLinksTargets(validators) {
+	const v = validators.items_item_type;
+	return Array.isArray(v) && v.every((x) => typeof x === "string") ? v : void 0;
+}
+/** Check if field is searchable (default: true — opt out with {"searchable": false}) */
+function isSearchable(validators) {
+	return validators.searchable !== false;
+}
+/** Field types where exact-value uniqueness is supported */
+function supportsUniqueValidation(fieldType) {
+	return [
+		"string",
+		"text",
+		"slug",
+		"integer",
+		"float",
+		"boolean",
+		"date",
+		"date_time",
+		"link",
+		"media"
+	].includes(fieldType);
+}
+/**
+* Compute whether a record is valid (all required fields have values).
+* For localized required fields, checks the default locale key in the JSON map.
+* When allLocales is provided, checks all locale keys (for all_locales_required models).
+* Returns { valid, missingFields } where missingFields lists api_keys that are missing.
+*/
+function computeIsValid(record, fields, defaultLocale, allLocales) {
+	const missingFields = [];
+	for (const field of fields) {
+		const value = record[field.api_key];
+		let fieldInvalid = false;
+		if (field.localized && defaultLocale) {
+			let localeMap = value;
+			if (typeof localeMap === "string") try {
+				localeMap = JSON.parse(localeMap);
+			} catch {
+				missingFields.push(field.api_key);
+				continue;
+			}
+			if (typeof localeMap !== "object" || localeMap === null) {
+				missingFields.push(field.api_key);
+				continue;
+			}
+			const map = localeMap;
+			const localesToCheck = allLocales ?? [defaultLocale];
+			for (const locale of localesToCheck) {
+				const locValue = map[locale];
+				if (!isValueValidForField(locValue, field.field_type, field.validators)) {
+					fieldInvalid = true;
+					break;
+				}
+			}
+		} else fieldInvalid = !isValueValidForField(value, field.field_type, field.validators);
+		if (fieldInvalid) missingFields.push(field.api_key);
+	}
+	return {
+		valid: missingFields.length === 0,
+		missingFields
+	};
+}
+function isValueValidForField(value, fieldType, validators) {
+	if (isRequired(validators) && !hasMeaningfulValue(value)) return false;
+	if (!hasMeaningfulValue(value)) return true;
+	if (!passesEnumValidation(value, validators)) return false;
+	if (!passesLengthValidation(value, fieldType, validators)) return false;
+	if (!passesNumberRangeValidation(value, fieldType, validators)) return false;
+	if (!passesFormatValidation(value, fieldType, validators)) return false;
+	if (!passesDateRangeValidation(value, fieldType, validators)) return false;
+	return true;
+}
+function passesEnumValidation(value, validators) {
+	const enumValues = validators.enum;
+	if (!Array.isArray(enumValues) || !enumValues.every((entry) => typeof entry === "string")) return true;
+	return typeof value === "string" && enumValues.includes(value);
+}
+function passesLengthValidation(value, fieldType, validators) {
+	if (![
+		"string",
+		"text",
+		"slug"
+	].includes(fieldType)) return true;
+	const lengthConfig = validators.length;
+	if (typeof lengthConfig !== "object" || lengthConfig === null || Array.isArray(lengthConfig)) return true;
+	const length = lengthConfig;
+	if (typeof value !== "string") return false;
+	const min = typeof length.min === "number" ? length.min : void 0;
+	const max = typeof length.max === "number" ? length.max : void 0;
+	if (min !== void 0 && value.length < min) return false;
+	if (max !== void 0 && value.length > max) return false;
+	return true;
+}
+function passesNumberRangeValidation(value, fieldType, validators) {
+	if (!["integer", "float"].includes(fieldType)) return true;
+	const rangeConfig = validators.number_range;
+	if (typeof rangeConfig !== "object" || rangeConfig === null || Array.isArray(rangeConfig)) return true;
+	const range = rangeConfig;
+	if (typeof value !== "number") return false;
+	const min = typeof range.min === "number" ? range.min : void 0;
+	const max = typeof range.max === "number" ? range.max : void 0;
+	if (min !== void 0 && value < min) return false;
+	if (max !== void 0 && value > max) return false;
+	return true;
+}
+function passesFormatValidation(value, fieldType, validators) {
+	if (![
+		"string",
+		"text",
+		"slug"
+	].includes(fieldType) || typeof value !== "string") return true;
+	const format = validators.format;
+	if (!format) return true;
+	if (format === "email") return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+	if (format === "url") try {
+		const parsed = new URL(value);
+		return parsed.protocol === "http:" || parsed.protocol === "https:";
+	} catch {
+		return false;
+	}
+	if (typeof format === "object" && !Array.isArray(format) && typeof format.custom_pattern === "string") try {
+		return new RegExp(format.custom_pattern).test(value);
+	} catch {
+		return false;
+	}
+	return true;
+}
+function passesDateRangeValidation(value, fieldType, validators) {
+	if (!["date", "date_time"].includes(fieldType) || typeof value !== "string") return true;
+	const rangeConfig = validators.date_range;
+	if (typeof rangeConfig !== "object" || rangeConfig === null || Array.isArray(rangeConfig)) return true;
+	const range = rangeConfig;
+	const valueTime = parseDateValue(value);
+	if (valueTime === null) return false;
+	const minTime = parseDateBoundary(range.min);
+	const maxTime = parseDateBoundary(range.max);
+	if (minTime !== null && valueTime < minTime) return false;
+	if (maxTime !== null && valueTime > maxTime) return false;
+	return true;
+}
+function parseDateValue(value) {
+	const time = Date.parse(value);
+	return Number.isNaN(time) ? null : time;
+}
+function parseDateBoundary(value) {
+	if (value === void 0) return null;
+	if (value === "now") return Date.now();
+	if (typeof value !== "string") return null;
+	return parseDateValue(value);
+}
+function findUniqueConstraintViolations(options) {
+	return Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		const invalidFields = /* @__PURE__ */ new Set();
+		for (const field of options.fields) {
+			if (!isUnique(field.validators) || !supportsUniqueValidation(field.field_type)) continue;
+			if (options.onlyFieldApiKeys && !options.onlyFieldApiKeys.has(field.api_key)) continue;
+			const value = options.record[field.api_key];
+			if (field.localized) {
+				const localeMap = parseLocaleMap(value);
+				for (const [localeCode, localeValue] of Object.entries(localeMap)) {
+					if (!hasMeaningfulValue(localeValue)) continue;
+					const path = `$."${localeCode.replace(/"/g, "\\\"")}"`;
+					if ((yield* sql.unsafe(`SELECT id FROM "${options.tableName}" WHERE json_extract("${field.api_key}", ?) = ?${options.excludeId ? " AND id != ?" : ""} LIMIT 1`, options.excludeId ? [
+						path,
+						serializeUniqueValue(localeValue),
+						options.excludeId
+					] : [path, serializeUniqueValue(localeValue)])).length > 0) {
+						invalidFields.add(field.api_key);
+						break;
+					}
+				}
+				continue;
+			}
+			if (!hasMeaningfulValue(value)) continue;
+			const comparableValue = field.field_type === "media" ? parseMediaFieldReference(value)?.uploadId ?? value : value;
+			if ((yield* sql.unsafe(`SELECT id FROM "${options.tableName}" WHERE (CASE WHEN json_valid("${field.api_key}") AND json_type("${field.api_key}") = 'object' THEN json_extract("${field.api_key}", '$.upload_id') ELSE "${field.api_key}" END) = ?${options.excludeId ? " AND id != ?" : ""} LIMIT 1`, options.excludeId ? [serializeUniqueValue(comparableValue), options.excludeId] : [serializeUniqueValue(comparableValue)])).length > 0) invalidFields.add(field.api_key);
+		}
+		return [...invalidFields];
+	});
+}
+function parseLocaleMap(value) {
+	if (value === null || value === void 0) return {};
+	return typeof value === "string" ? decodeJsonRecordStringOr(value, {}) : value;
+}
+function hasMeaningfulValue(value) {
+	return value !== null && value !== void 0 && value !== "";
+}
+function serializeUniqueValue(value) {
+	if (typeof value === "boolean") return value ? 1 : 0;
+	return value;
+}
+//#endregion
+//#region src/db/row-types.ts
+function isContentRow(row) {
+	return typeof row === "object" && row !== null && "id" in row && "_status" in row;
+}
+/** Runtime check that a value is a plain object record */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Safely parse JSON to a Record, returning empty object on failure */
+function parseJsonRecord(json) {
+	if (!json) return {};
+	try {
+		const parsed = JSON.parse(json);
+		if (isRecord(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+/** Parse a FieldRow's validators from JSON string to object */
+function parseFieldValidators(field) {
+	return {
+		...field,
+		validators: parseJsonRecord(field.validators)
+	};
+}
+//#endregion
+//#region src/dast/schema.ts
+/**
+* Effect Schema definitions for DAST documents.
+* Comprehensive recursive schemas for full validation of DAST nodes.
+*/
+const MarkSchema = Schema.Literal("strong", "emphasis", "underline", "strikethrough", "code", "highlight");
+const LinkMetaEntry = Schema.Struct({
+	id: Schema.String,
+	value: Schema.String
+});
+const SpanNodeSchema = Schema.Struct({
+	type: Schema.Literal("span"),
+	value: Schema.String,
+	marks: Schema.optionalWith(Schema.Array(MarkSchema), { exact: true })
+});
+const LinkNodeSchema = Schema.Struct({
+	type: Schema.Literal("link"),
+	url: Schema.NonEmptyString,
+	meta: Schema.optionalWith(Schema.Array(LinkMetaEntry), { exact: true }),
+	children: Schema.Array(SpanNodeSchema)
+});
+const ItemLinkNodeSchema = Schema.Struct({
+	type: Schema.Literal("itemLink"),
+	item: Schema.NonEmptyString,
+	meta: Schema.optionalWith(Schema.Array(LinkMetaEntry), { exact: true }),
+	children: Schema.Array(SpanNodeSchema)
+});
+const InlineItemNodeSchema = Schema.Struct({
+	type: Schema.Literal("inlineItem"),
+	item: Schema.NonEmptyString
+});
+const InlineBlockNodeSchema = Schema.Struct({
+	type: Schema.Literal("inlineBlock"),
+	item: Schema.NonEmptyString
+});
+const InlineNodeSchema = Schema.Union(SpanNodeSchema, LinkNodeSchema, ItemLinkNodeSchema, InlineItemNodeSchema, InlineBlockNodeSchema);
+const ParagraphNodeSchema = Schema.Struct({
+	type: Schema.Literal("paragraph"),
+	style: Schema.optionalWith(Schema.String, { exact: true }),
+	children: Schema.Array(InlineNodeSchema)
+});
+const HeadingLevel = Schema.Number.pipe(Schema.int(), Schema.greaterThanOrEqualTo(1), Schema.lessThanOrEqualTo(6));
+const HeadingNodeSchema = Schema.Struct({
+	type: Schema.Literal("heading"),
+	level: HeadingLevel,
+	style: Schema.optionalWith(Schema.String, { exact: true }),
+	children: Schema.Array(InlineNodeSchema)
+});
+const ListNodeSchema = Schema.suspend(() => Schema.Struct({
+	type: Schema.Literal("list"),
+	style: Schema.Literal("bulleted", "numbered"),
+	children: Schema.Array(ListItemNodeSchema)
+}));
+const ListItemNodeSchema = Schema.suspend(() => Schema.Struct({
+	type: Schema.Literal("listItem"),
+	children: Schema.Array(Schema.Union(ParagraphNodeSchema, ListNodeSchema))
+}));
+const BlockquoteNodeSchema = Schema.Struct({
+	type: Schema.Literal("blockquote"),
+	attribution: Schema.optionalWith(Schema.String, { exact: true }),
+	children: Schema.Array(ParagraphNodeSchema)
+});
+const CodeNodeSchema = Schema.Struct({
+	type: Schema.Literal("code"),
+	code: Schema.String,
+	language: Schema.optionalWith(Schema.String, { exact: true }),
+	highlight: Schema.optionalWith(Schema.Array(Schema.Number), { exact: true })
+});
+const ThematicBreakNodeSchema = Schema.Struct({ type: Schema.Literal("thematicBreak") });
+const BlockRefNodeSchema = Schema.Struct({
+	type: Schema.Literal("block"),
+	item: Schema.NonEmptyString
+});
+const TableCellNodeSchema = Schema.Struct({
+	type: Schema.Literal("tableCell"),
+	children: Schema.Array(Schema.Union(ParagraphNodeSchema, InlineNodeSchema))
+});
+const TableRowNodeSchema = Schema.Struct({
+	type: Schema.Literal("tableRow"),
+	children: Schema.NonEmptyArray(TableCellNodeSchema)
+});
+const TableNodeSchema = Schema.Struct({
+	type: Schema.Literal("table"),
+	children: Schema.NonEmptyArray(TableRowNodeSchema)
+});
+const BlockLevelNodeSchema = Schema.Union(ParagraphNodeSchema, HeadingNodeSchema, ListNodeSchema, BlockquoteNodeSchema, CodeNodeSchema, ThematicBreakNodeSchema, BlockRefNodeSchema, TableNodeSchema);
+const RootNodeSchema = Schema.Struct({
+	type: Schema.Literal("root"),
+	children: Schema.Array(BlockLevelNodeSchema)
+});
+const DastDocumentSchema = Schema.Struct({
+	schema: Schema.Literal("dast"),
+	document: RootNodeSchema
+});
+/** Decode a StructuredText write payload */
+const StructuredTextWriteInput = Schema.Struct({
+	value: DastDocumentSchema,
+	blocks: Schema.optionalWith(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	}), { default: () => ({}) })
+});
+//#endregion
+//#region src/dast/validate.ts
+/**
+* Validate that a DAST document only contains block nodes at root level.
+*/
+function validateBlocksOnly(doc) {
+	const decoded = Schema.decodeUnknownEither(DastDocumentSchema)(doc);
+	if (decoded._tag === "Left") return [];
+	return decoded.right.document.children.flatMap((child, index) => child.type === "block" ? [] : [{
+		path: `document.children[${index}]`,
+		message: `Only block nodes are allowed at root level in a blocks-only field. Found "${child.type}" node.`
+	}]);
+}
+function visitDastNode(node, visit) {
+	visit(node);
+	if ("children" in node) for (const child of node.children) visitDastNode(child, visit);
+}
+/**
+* Extract all block-level block IDs (type "block") from a DAST document.
+*/
+function extractBlockIds(doc) {
+	const ids = [];
+	visitDastNode({
+		type: "root",
+		children: doc.document.children
+	}, (node) => {
+		if (node.type === "block") ids.push(node.item);
+	});
+	return ids;
+}
+/**
+* Extract all inline block IDs (type "inlineBlock") from a DAST document.
+*/
+function extractInlineBlockIds(doc) {
+	const ids = [];
+	visitDastNode({
+		type: "root",
+		children: doc.document.children
+	}, (node) => {
+		if (node.type === "inlineBlock") ids.push(node.item);
+	});
+	return ids;
+}
+/**
+* Extract ALL block IDs (both "block" and "inlineBlock") from a DAST document.
+* Used for write orchestration where both types need to be stored.
+*/
+function extractAllBlockIds(doc) {
+	const ids = [];
+	visitDastNode({
+		type: "root",
+		children: doc.document.children
+	}, (node) => {
+		if (node.type === "block" || node.type === "inlineBlock") ids.push(node.item);
+	});
+	return ids;
+}
+/**
+* Extract all record link IDs referenced in a DAST document.
+*/
+function extractLinkIds(doc) {
+	const ids = [];
+	visitDastNode({
+		type: "root",
+		children: doc.document.children
+	}, (node) => {
+		if (node.type === "itemLink" || node.type === "inlineItem") ids.push(node.item);
+	});
+	return ids;
+}
+/**
+* Remove block/inlineBlock nodes whose item ID is in the given set.
+* Returns a deep-cloned document with those nodes pruned from the tree.
+*/
+function pruneBlockNodes(doc, blockIdsToRemove) {
+	function isSpanOnlyChildren(node) {
+		return node.type === "link" || node.type === "itemLink";
+	}
+	function pruneInlineNode(node) {
+		if (node.type === "inlineBlock" && blockIdsToRemove.has(node.item)) return null;
+		if (isSpanOnlyChildren(node)) return node;
+		return node;
+	}
+	function pruneParagraphNode(node) {
+		return {
+			...node,
+			children: node.children.map((child) => pruneInlineNode(child)).filter((child) => child !== null)
+		};
+	}
+	function pruneBlockLevelNode(node) {
+		if (node.type === "block" && blockIdsToRemove.has(node.item)) return null;
+		switch (node.type) {
+			case "paragraph": return pruneParagraphNode(node);
+			case "heading": return {
+				...node,
+				children: node.children.map((child) => pruneInlineNode(child)).filter((child) => child !== null)
+			};
+			case "list": return {
+				...node,
+				children: node.children.map((child) => ({
+					...child,
+					children: child.children.map((nested) => pruneBlockLevelNode(nested)).filter((nested) => nested !== null && (nested.type === "paragraph" || nested.type === "list"))
+				}))
+			};
+			case "blockquote": return {
+				...node,
+				children: node.children.map((child) => pruneParagraphNode(child))
+			};
+			case "table": return {
+				...node,
+				children: node.children.map((row) => ({
+					...row,
+					children: row.children.map((cell) => ({
+						...cell,
+						children: cell.children.map((child) => "item" in child || "url" in child || "value" in child ? pruneInlineNode(child) : pruneBlockLevelNode(child)).filter((child) => child !== null)
+					}))
+				}))
+			};
+			default: return node;
+		}
+	}
+	return {
+		schema: "dast",
+		document: {
+			type: "root",
+			children: doc.document.children.map((child) => pruneBlockLevelNode(child)).filter((child) => child !== null)
+		}
+	};
+}
+//#endregion
+//#region src/dast/markdown.ts
+/**
+* Editable DAST ↔ Markdown projection.
+*
+* This is NOT a generic serializer. Markdown is a projection of DAST for
+* editing text structure. DAST remains the source of truth.
+*
+* Contract:
+* - Block refs, inline refs survive as stable sentinels
+* - Deleting a sentinel deletes the ref; moving it reorders it
+* - Unsupported DAST metadata (link.meta, paragraph.style, heading.style,
+*   blockquote.attribution, code.highlight) is preserved in a sidecar map
+*   and re-attached on round-trip if the node is untouched
+* - No new blocks can be authored from markdown
+* - No block payloads are editable from markdown
+*
+* API:
+*   dastToEditableMarkdown(doc) → { markdown, preservation }
+*   editableMarkdownToDast(markdown, preservation) → DastDocument
+*
+* Legacy wrappers dastToMarkdown/markdownToDast are preserved for
+* non-editing use cases (export, display).
+*/
+const BLOCK_SENTINEL_RE = /^<!--\s*cms:block:(\S+)\s*-->$/;
+const NODE_SENTINEL_RE = /^<!--\s*cms:n(\d+)\s*-->$/;
+const INLINE_ITEM_SENTINEL_RE = /^<!--\s*cms:inlineItem:(\S+)\s*-->$/;
+const INLINE_BLOCK_SENTINEL_RE = /^<!--\s*cms:inlineBlock:(\S+)\s*-->$/;
+const LINK_META_SENTINEL_RE = /^<!--\s*cms:linkMeta:(\S+)\s*-->$/;
+const ITEM_LINK_META_SENTINEL_RE = /^<!--\s*cms:itemLinkMeta:(\S+)\s*-->$/;
+const ITEM_LINK_PREFIX = "itemLink:";
+const MARK_RE = /^<mark>([\s\S]*)<\/mark>$/;
+const UNDERLINE_RE = /^<u>([\s\S]*)<\/u>$/;
+function decodeSentinelValue(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+function escapeHtmlText(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function decodeHtmlText(value) {
+	return value.replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+}
+/** Map of opening HTML tags to DAST marks */
+const HTML_TAG_TO_MARK = {
+	"<u>": "underline",
+	"<mark>": "highlight"
+};
+const HTML_CLOSING_TAGS = new Set(["</u>", "</mark>"]);
+function isOpeningMarkTag(value) {
+	return value in HTML_TAG_TO_MARK;
+}
+function isClosingMarkTag(value) {
+	return HTML_CLOSING_TAGS.has(value);
+}
+function mergeHtmlTagSequences(nodes) {
+	const result = [];
+	let i = 0;
+	while (i < nodes.length) {
+		const node = nodes[i];
+		if (node.type === "html" && isOpeningMarkTag(node.value)) {
+			let depth = 1;
+			let raw = node.value;
+			i++;
+			while (i < nodes.length) {
+				const current = nodes[i];
+				if (current.type === "html") {
+					raw += current.value;
+					if (isOpeningMarkTag(current.value)) depth++;
+					else if (isClosingMarkTag(current.value)) {
+						depth--;
+						i++;
+						if (depth === 0) break;
+						continue;
+					}
+				} else if (current.type === "text") raw += escapeHtmlText(current.value);
+				else if (current.type === "inlineCode") raw += escapeHtmlText(current.value);
+				else {
+					result.push(node);
+					i++;
+					break;
+				}
+				i++;
+			}
+			if (depth === 0) result.push({
+				type: "html",
+				value: raw
+			});
+		} else {
+			result.push(node);
+			i++;
+		}
+	}
+	return result;
+}
+function addMark(inline, mark) {
+	if (inline.type !== "span") return inline;
+	const existing = inline.marks ?? [];
+	if (existing.includes(mark)) return inline;
+	return {
+		...inline,
+		marks: [...existing, mark]
+	};
+}
+function mdastPhrasingToSpans(nodes, pres) {
+	return mdastPhrasingToDastInlines(nodes, pres).map((inline) => inline.type === "span" ? inline : {
+		type: "span",
+		value: extractText(inline)
+	});
+}
+function extractLinkMetaId(children, pattern) {
+	let metaId = null;
+	const remaining = [];
+	for (const child of children) {
+		if (child.type === "html") {
+			const match = pattern.exec(child.value);
+			if (match) {
+				metaId = decodeSentinelValue(match[1]);
+				continue;
+			}
+		}
+		remaining.push(child);
+	}
+	return {
+		metaId,
+		children: remaining
+	};
+}
+function extractText(node) {
+	switch (node.type) {
+		case "span": return node.value;
+		case "link":
+		case "itemLink": return node.children.map((c) => c.value).join("");
+		case "inlineItem":
+		case "inlineBlock": return "";
+	}
+}
+function mdastPhrasingToDastInlines(rawNodes, pres) {
+	const nodes = mergeHtmlTagSequences(rawNodes);
+	const result = [];
+	let pendingLinkMetaId = null;
+	let pendingItemLinkMetaId = null;
+	for (const node of nodes) switch (node.type) {
+		case "text":
+			result.push({
+				type: "span",
+				value: node.value
+			});
+			break;
+		case "inlineCode":
+			result.push({
+				type: "span",
+				value: node.value,
+				marks: ["code"]
+			});
+			break;
+		case "strong":
+			for (const inline of mdastPhrasingToDastInlines(node.children, pres)) result.push(addMark(inline, "strong"));
+			break;
+		case "emphasis":
+			for (const inline of mdastPhrasingToDastInlines(node.children, pres)) result.push(addMark(inline, "emphasis"));
+			break;
+		case "delete":
+			for (const inline of mdastPhrasingToDastInlines(node.children, pres)) result.push(addMark(inline, "strikethrough"));
+			break;
+		case "link":
+			if (node.url.startsWith(ITEM_LINK_PREFIX)) {
+				const itemId = node.url.slice(9);
+				const extracted = extractLinkMetaId(node.children, ITEM_LINK_META_SENTINEL_RE);
+				const children = mdastPhrasingToSpans(extracted.children, pres);
+				const preserved = extracted.metaId ? pres.itemLinks[extracted.metaId] : pendingItemLinkMetaId ? pres.itemLinks[pendingItemLinkMetaId] : void 0;
+				const itemLink = {
+					type: "itemLink",
+					item: itemId,
+					children,
+					...preserved?.meta ? { meta: preserved.meta } : {}
+				};
+				result.push(itemLink);
+				pendingItemLinkMetaId = null;
+			} else {
+				const extracted = extractLinkMetaId(node.children, LINK_META_SENTINEL_RE);
+				const children = mdastPhrasingToSpans(extracted.children, pres);
+				const preserved = extracted.metaId ? pres.links[extracted.metaId] : pendingLinkMetaId ? pres.links[pendingLinkMetaId] : void 0;
+				const link = {
+					type: "link",
+					url: node.url,
+					children,
+					...preserved?.meta ? { meta: preserved.meta } : {}
+				};
+				result.push(link);
+				pendingLinkMetaId = null;
+			}
+			break;
+		case "html": {
+			const linkMetaMatch = LINK_META_SENTINEL_RE.exec(node.value);
+			if (linkMetaMatch) {
+				pendingLinkMetaId = decodeSentinelValue(linkMetaMatch[1]);
+				break;
+			}
+			const itemLinkMetaMatch = ITEM_LINK_META_SENTINEL_RE.exec(node.value);
+			if (itemLinkMetaMatch) {
+				pendingItemLinkMetaId = decodeSentinelValue(itemLinkMetaMatch[1]);
+				break;
+			}
+			const m1 = INLINE_ITEM_SENTINEL_RE.exec(node.value);
+			if (m1) {
+				result.push({
+					type: "inlineItem",
+					item: decodeSentinelValue(m1[1])
+				});
+				break;
+			}
+			const m2 = INLINE_BLOCK_SENTINEL_RE.exec(node.value);
+			if (m2) {
+				result.push({
+					type: "inlineBlock",
+					item: decodeSentinelValue(m2[1])
+				});
+				break;
+			}
+			const marked = parseMarkedHtml(node.value);
+			if (marked) {
+				result.push(marked);
+				break;
+			}
+			result.push({
+				type: "span",
+				value: node.value
+			});
+			break;
+		}
+		case "break":
+			result.push({
+				type: "span",
+				value: "\n"
+			});
+			break;
+		default: break;
+	}
+	return result;
+}
+function parseMarkedHtml(value) {
+	const marks = [];
+	let current = value;
+	for (;;) {
+		const underlineMatch = UNDERLINE_RE.exec(current);
+		if (underlineMatch) {
+			marks.push("underline");
+			current = underlineMatch[1];
+			continue;
+		}
+		const highlightMatch = MARK_RE.exec(current);
+		if (highlightMatch) {
+			marks.push("highlight");
+			current = highlightMatch[1];
+			continue;
+		}
+		break;
+	}
+	if (marks.length === 0) return null;
+	return {
+		type: "span",
+		value: decodeHtmlText(current),
+		marks
+	};
+}
+/**
+* Parse markdown back into DAST, re-attaching preserved metadata.
+* The `pendingNodeId` is set when we encounter a `<!-- cms:nX -->` sentinel,
+* and consumed by the next block-level node.
+*/
+function mdastBlockToDast(node, pres, nodeId) {
+	const meta = nodeId ? pres.nodes[nodeId] : void 0;
+	switch (node.type) {
+		case "paragraph": return {
+			type: "paragraph",
+			children: mdastPhrasingToDastInlines(node.children, pres),
+			...meta?.style !== void 0 ? { style: meta.style } : {}
+		};
+		case "heading": return {
+			type: "heading",
+			level: node.depth,
+			children: mdastPhrasingToDastInlines(node.children, pres),
+			...meta?.style !== void 0 ? { style: meta.style } : {}
+		};
+		case "list": return {
+			type: "list",
+			style: node.ordered ? "numbered" : "bulleted",
+			children: node.children.map((item) => mdastListItemToDast(item, pres))
+		};
+		case "blockquote": return {
+			type: "blockquote",
+			children: node.children.filter((c) => c.type === "paragraph").map((p) => ({
+				type: "paragraph",
+				children: mdastPhrasingToDastInlines(p.children, pres)
+			})),
+			...meta?.attribution !== void 0 ? { attribution: meta.attribution } : {}
+		};
+		case "code": return {
+			type: "code",
+			code: node.value,
+			...node.lang ? { language: node.lang } : {},
+			...meta?.highlight !== void 0 ? { highlight: meta.highlight } : {}
+		};
+		case "thematicBreak": return { type: "thematicBreak" };
+		case "html": {
+			const blockMatch = BLOCK_SENTINEL_RE.exec(node.value);
+			if (blockMatch) return {
+				type: "block",
+				item: decodeSentinelValue(blockMatch[1])
+			};
+			return {
+				type: "paragraph",
+				children: [{
+					type: "span",
+					value: node.value
+				}]
+			};
+		}
+		case "table": return {
+			type: "table",
+			children: node.children.map((row) => mdastTableRowToDast(row, pres))
+		};
+		default: return null;
+	}
+}
+function mdastListItemToDast(item, pres) {
+	const children = [];
+	for (const child of item.children) if (child.type === "paragraph") children.push({
+		type: "paragraph",
+		children: mdastPhrasingToDastInlines(child.children, pres)
+	});
+	else if (child.type === "list") children.push({
+		type: "list",
+		style: child.ordered ? "numbered" : "bulleted",
+		children: child.children.map((li) => mdastListItemToDast(li, pres))
+	});
+	return {
+		type: "listItem",
+		children
+	};
+}
+function mdastTableRowToDast(row, pres) {
+	return {
+		type: "tableRow",
+		children: row.children.map((cell) => mdastTableCellToDast(cell, pres))
+	};
+}
+function mdastTableCellToDast(cell, pres) {
+	const inlines = mdastPhrasingToDastInlines(cell.children, pres);
+	if (inlines.length === 0) return {
+		type: "tableCell",
+		children: [{
+			type: "paragraph",
+			children: [{
+				type: "span",
+				value: ""
+			}]
+		}]
+	};
+	return {
+		type: "tableCell",
+		children: [{
+			type: "paragraph",
+			children: inlines
+		}]
+	};
+}
+/**
+* Parse edited markdown back into DAST, re-attaching preserved metadata
+* from the sidecar. Sentinels that were deleted are omitted; sentinels
+* that were reordered are reflected in the output order.
+*/
+function editableMarkdownToDast(markdown, preservation) {
+	const mdastRoot = unified().use(remarkParse).use(remarkGfm).parse(markdown);
+	const children = [];
+	let pendingNodeId = null;
+	let pendingInlineSentinels = [];
+	for (const child of mdastRoot.children) {
+		if (child.type === "html") {
+			const nodeMatch = NODE_SENTINEL_RE.exec(child.value);
+			if (nodeMatch) {
+				pendingNodeId = `n${nodeMatch[1]}`;
+				continue;
+			}
+			if (LINK_META_SENTINEL_RE.test(child.value) || ITEM_LINK_META_SENTINEL_RE.test(child.value)) {
+				pendingInlineSentinels.push(child);
+				continue;
+			}
+		}
+		const childWithPendingSentinels = pendingInlineSentinels.length > 0 && (child.type === "paragraph" || child.type === "heading") ? {
+			...child,
+			children: [...pendingInlineSentinels, ...child.children]
+		} : child;
+		pendingInlineSentinels = [];
+		const dastNode = mdastBlockToDast(childWithPendingSentinels, preservation, pendingNodeId);
+		pendingNodeId = null;
+		if (dastNode) children.push(dastNode);
+	}
+	return {
+		schema: "dast",
+		document: {
+			type: "root",
+			children
+		}
+	};
+}
+/** Parse a CommonMark markdown string into a DAST document (no preservation). */
+function markdownToDast(markdown) {
+	return editableMarkdownToDast(markdown, {
+		nodes: {},
+		links: {},
+		itemLinks: {}
+	});
+}
+//#endregion
+//#region src/graphql/sql-metrics.ts
+const sqlMetricsStorage = new AsyncLocalStorage();
+function withSqlMetrics(run) {
+	return sqlMetricsStorage.run({
+		statementCount: 0,
+		hopCount: 0,
+		batchHopCount: 0,
+		batchedStatementCount: 0,
+		totalDurationMs: 0,
+		slowestSamplesMs: [],
+		byPhase: /* @__PURE__ */ new Map()
+	}, run);
+}
+function recordSqlMetrics(durationMs, options) {
+	const store = sqlMetricsStorage.getStore();
+	if (!store) return;
+	const statementCount = options?.statementCount ?? 1;
+	const hopCount = options?.hopCount ?? 1;
+	const batchHopCount = options?.batchHopCount ?? 0;
+	const batchedStatementCount = options?.batchedStatementCount ?? 0;
+	store.statementCount += statementCount;
+	store.hopCount += hopCount;
+	store.batchHopCount += batchHopCount;
+	store.batchedStatementCount += batchedStatementCount;
+	store.totalDurationMs += durationMs;
+	store.slowestSamplesMs.push(Number(durationMs.toFixed(3)));
+	store.slowestSamplesMs.sort((a, b) => b - a);
+	if (store.slowestSamplesMs.length > 5) store.slowestSamplesMs.length = 5;
+	const phase = options?.phase;
+	if (phase) {
+		const current = store.byPhase.get(phase) ?? {
+			statementCount: 0,
+			hopCount: 0,
+			batchHopCount: 0,
+			batchedStatementCount: 0,
+			totalDurationMs: 0
+		};
+		current.statementCount += statementCount;
+		current.hopCount += hopCount;
+		current.batchHopCount += batchHopCount;
+		current.batchedStatementCount += batchedStatementCount;
+		current.totalDurationMs += durationMs;
+		store.byPhase.set(phase, current);
+	}
+}
+function getSqlMetrics() {
+	const store = sqlMetricsStorage.getStore();
+	if (!store) return null;
+	return {
+		statementCount: store.statementCount,
+		hopCount: store.hopCount,
+		batchHopCount: store.batchHopCount,
+		batchedStatementCount: store.batchedStatementCount,
+		totalDurationMs: Number(store.totalDurationMs.toFixed(3)),
+		slowestSamplesMs: store.slowestSamplesMs,
+		byPhase: Object.fromEntries([...store.byPhase.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([phase, value]) => [phase, {
+			statementCount: value.statementCount,
+			hopCount: value.hopCount,
+			batchHopCount: value.batchHopCount,
+			batchedStatementCount: value.batchedStatementCount,
+			totalDurationMs: Number(value.totalDurationMs.toFixed(3))
+		}]))
+	};
+}
+//#endregion
+//#region src/db/run-batched-queries.ts
+function isD1Database(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return typeof Reflect.get(value, "prepare") === "function" && typeof Reflect.get(value, "batch") === "function";
+}
+function isD1ClientLike(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const config = Reflect.get(value, "config");
+	if (typeof config !== "object" || config === null) return false;
+	return isD1Database(Reflect.get(config, "db"));
+}
+function runBatchedQueries(queries, options) {
+	return Effect.gen(function* () {
+		if (queries.length === 0) return [];
+		const startedAt = performance.now();
+		const sql = yield* SqlClient.SqlClient;
+		if (isD1ClientLike(sql)) return yield* Effect.tryPromise({
+			try: async () => {
+				const statements = queries.map((query) => sql.config.db.prepare(query.sql).bind(...query.params));
+				const results = await sql.config.db.batch(statements);
+				recordSqlMetrics(performance.now() - startedAt, {
+					statementCount: queries.length,
+					hopCount: 1,
+					batchHopCount: 1,
+					batchedStatementCount: queries.length,
+					phase: options?.phase
+				});
+				return results.map((result) => result.results);
+			},
+			catch: (cause) => new SqlError.SqlError({
+				cause,
+				message: "Failed to execute D1 batch query"
+			})
+		});
+		const results = yield* Effect.all(queries.map((query) => sql.unsafe(query.sql, query.params)), { concurrency: 1 });
+		recordSqlMetrics(performance.now() - startedAt, {
+			statementCount: queries.length,
+			hopCount: 1,
+			batchHopCount: 1,
+			batchedStatementCount: queries.length,
+			phase: options?.phase
+		});
+		return results;
+	});
+}
+//#endregion
+//#region src/types.ts
+/** Field types supported in v1 */
+const FIELD_TYPES = [
+	"string",
+	"text",
+	"boolean",
+	"integer",
+	"slug",
+	"media",
+	"media_gallery",
+	"link",
+	"links",
+	"structured_text",
+	"seo",
+	"json",
+	"float",
+	"date",
+	"date_time",
+	"color",
+	"lat_lon",
+	"video"
+];
+/** Type guard for FieldType */
+function isFieldType(value) {
+	return FIELD_TYPES.includes(value);
+}
+//#endregion
+//#region src/services/structured-text-service.ts
+function getStructuredTextStorageKey(fieldApiKey, localeCode) {
+	return localeCode ? `${fieldApiKey}:${localeCode}` : fieldApiKey;
+}
+function mergeRowMaps(target, source) {
+	for (const [tableName, rows] of source) {
+		const existing = target.get(tableName);
+		if (existing) existing.push(...rows);
+		else target.set(tableName, [...rows]);
+	}
+}
+function serializeValue(value) {
+	if (value === void 0 || value === null) return null;
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (typeof value === "object") return encodeJson(value);
+	return value;
+}
+function deserializeValue(value) {
+	if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) return decodeJsonStringOr(value, value);
+	return value;
+}
+function decodeStructuredTextInput(fieldApiKey, value) {
+	return Schema.decodeUnknown(StructuredTextWriteInput)(value).pipe(Effect.mapError((e) => new ValidationError({
+		message: `Invalid StructuredText for field '${fieldApiKey}': ${e.message}`,
+		field: fieldApiKey
+	})));
+}
+function getParsedFields(sql, modelId) {
+	return Effect.gen(function* () {
+		return (yield* sql.unsafe("SELECT * FROM fields WHERE model_id = ? ORDER BY position", [modelId])).map(parseFieldValidators);
+	});
+}
+function getBlockModelSchema(sql, blockApiKey) {
+	return Effect.gen(function* () {
+		const rows = yield* sql.unsafe("SELECT id, api_key FROM models WHERE api_key = ? AND is_block = 1", [blockApiKey]);
+		if (rows.length === 0) return yield* new ValidationError({ message: `Block type '${blockApiKey}' does not exist` });
+		const model = rows[0];
+		const fields = yield* getParsedFields(sql, model.id);
+		const structuredTextAllowedBlockApiKeysByField = /* @__PURE__ */ new Map();
+		for (const field of fields) {
+			if (field.field_type !== "structured_text") continue;
+			structuredTextAllowedBlockApiKeysByField.set(field.api_key, getBlockWhitelist(field.validators) ?? []);
+		}
+		return {
+			id: model.id,
+			apiKey: model.api_key,
+			fields,
+			structuredTextAllowedBlockApiKeysByField
+		};
+	});
+}
+function getBlockModelSchemaCached(ctx, sql, blockApiKey) {
+	return Effect.gen(function* () {
+		const cached = ctx.blockModelSchemas.get(blockApiKey);
+		if (cached) return cached;
+		const schema = yield* getBlockModelSchema(sql, blockApiKey);
+		ctx.blockModelSchemas.set(blockApiKey, schema);
+		return schema;
+	});
+}
+function fetchBlockModelsCached(ctx, sql) {
+	return Effect.gen(function* () {
+		if (ctx.blockModels) return ctx.blockModels;
+		const blockModels = yield* fetchBlockModels(sql);
+		ctx.blockModels = blockModels;
+		return blockModels;
+	});
+}
+function getCandidateBlockModelsCached(ctx, blockModels, allowedBlockApiKeys) {
+	const cacheKey = allowedBlockApiKeys && allowedBlockApiKeys.length > 0 ? allowedBlockApiKeys.join(",") : "*";
+	const cached = ctx.candidateBlockModels.get(cacheKey);
+	if (cached) return cached;
+	const candidateBlockModels = allowedBlockApiKeys && allowedBlockApiKeys.length > 0 ? blockModels.filter((model) => allowedBlockApiKeys.includes(model.api_key)) : blockModels;
+	ctx.candidateBlockModels.set(cacheKey, candidateBlockModels);
+	return candidateBlockModels;
+}
+function runHotBlockQueries(queries) {
+	return runBatchedQueries(queries, { phase: "st_frontier" });
+}
+function formatDastParseErrors(error) {
+	return ParseResult.ArrayFormatter.formatErrorSync(error).map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
+}
+function validateDastForField(fieldApiKey, value, blocksOnly) {
+	return Effect.gen(function* () {
+		const dast = yield* Schema.decodeUnknown(DastDocumentSchema)(value).pipe(Effect.mapError((e) => new ValidationError({
+			message: `Invalid DAST document: ${formatDastParseErrors(e)}`,
+			field: fieldApiKey
+		})));
+		if (blocksOnly) {
+			const blocksOnlyErrors = validateBlocksOnly(value);
+			if (blocksOnlyErrors.length > 0) return yield* new ValidationError({
+				message: `Blocks-only field '${fieldApiKey}': ${blocksOnlyErrors.map((e) => e.message).join("; ")}`,
+				field: fieldApiKey
+			});
+		}
+		return dast;
+	});
+}
+function compileStructuredText(ctx, container, params) {
+	return Effect.gen(function* () {
+		const { sql, seenBlockIds } = ctx;
+		const { fieldApiKey, input, allowedBlockTypes, blocksOnly } = params;
+		const dast = yield* validateDastForField(fieldApiKey, input.value, blocksOnly);
+		const referencedBlockIds = extractAllBlockIds(dast);
+		const providedBlockIds = Object.keys(input.blocks);
+		for (const blockId of referencedBlockIds) if (!input.blocks[blockId]) return yield* new ValidationError({
+			message: `DAST references block '${blockId}' but no block data provided for it`,
+			field: fieldApiKey
+		});
+		for (const blockId of providedBlockIds) if (!referencedBlockIds.includes(blockId)) return yield* new ValidationError({
+			message: `StructuredText field '${fieldApiKey}' includes unreferenced block '${blockId}'`,
+			field: fieldApiKey
+		});
+		const rowsByTable = /* @__PURE__ */ new Map();
+		for (const blockId of referencedBlockIds) {
+			if (seenBlockIds.has(blockId)) return yield* new ValidationError({
+				message: `StructuredText graph reuses block id '${blockId}' multiple times`,
+				field: fieldApiKey
+			});
+			seenBlockIds.add(blockId);
+			const rawBlock = input.blocks[blockId];
+			if (typeof rawBlock !== "object" || rawBlock === null || Array.isArray(rawBlock)) return yield* new ValidationError({
+				message: `Block '${blockId}' must be an object`,
+				field: fieldApiKey
+			});
+			const blockData = rawBlock;
+			if (typeof blockData._type !== "string" || blockData._type.length === 0) return yield* new ValidationError({
+				message: `Block '${blockId}' must have a _type property`,
+				field: fieldApiKey
+			});
+			if (allowedBlockTypes.length > 0 && !allowedBlockTypes.includes(blockData._type)) return yield* new ValidationError({
+				message: `Block type '${blockData._type}' is not allowed in field '${fieldApiKey}'. Allowed: ${allowedBlockTypes.join(", ")}`,
+				field: fieldApiKey
+			});
+			const blockModel = yield* getBlockModelSchema(sql, blockData._type);
+			const row = {
+				id: blockId,
+				_root_record_id: ctx.rootRecordId,
+				_root_field_api_key: ctx.rootFieldApiKey,
+				_parent_container_model_api_key: container.parentContainerModelApiKey,
+				_parent_block_id: container.parentBlockId,
+				_parent_field_api_key: container.parentFieldApiKey,
+				_depth: container.depth
+			};
+			const nestedRows = /* @__PURE__ */ new Map();
+			for (const field of blockModel.fields) {
+				const value = blockData[field.api_key];
+				if (value === void 0) continue;
+				if (field.field_type === "structured_text") {
+					if (value === null) {
+						row[field.api_key] = null;
+						continue;
+					}
+					const nestedInput = yield* decodeStructuredTextInput(field.api_key, value);
+					const nestedCompiled = yield* compileStructuredText(ctx, {
+						parentContainerModelApiKey: blockModel.apiKey,
+						parentBlockId: blockId,
+						parentFieldApiKey: field.api_key,
+						depth: container.depth + 1
+					}, {
+						fieldApiKey: field.api_key,
+						input: nestedInput,
+						allowedBlockTypes: getBlockWhitelist(field.validators) ?? [],
+						blocksOnly: getBlocksOnly(field.validators)
+					});
+					row[field.api_key] = nestedCompiled.dast;
+					mergeRowMaps(nestedRows, nestedCompiled.rowsByTable);
+					continue;
+				}
+				if (isFieldType(field.field_type)) {
+					const fieldDef = getFieldTypeDef(field.field_type);
+					if (fieldDef.inputSchema) yield* Schema.decodeUnknown(fieldDef.inputSchema)(value).pipe(Effect.mapError((e) => new ValidationError({
+						message: `Invalid ${field.field_type} for block field '${field.api_key}': ${e.message}`,
+						field: field.api_key
+					})));
+				}
+				row[field.api_key] = value;
+			}
+			const tableName = `block_${blockModel.apiKey}`;
+			const rows = rowsByTable.get(tableName);
+			if (rows) rows.push(row);
+			else rowsByTable.set(tableName, [row]);
+			mergeRowMaps(rowsByTable, nestedRows);
+		}
+		return {
+			dast,
+			rowsByTable
+		};
+	});
+}
+function insertCompiledRows(sql, rowsByTable) {
+	return Effect.gen(function* () {
+		for (const [tableName, rows] of rowsByTable) for (const row of rows) {
+			const columns = Object.keys(row);
+			const colList = columns.map((c) => `"${c}"`).join(", ");
+			const placeholders = columns.map(() => "?").join(", ");
+			const values = columns.map((c) => serializeValue(row[c]));
+			yield* sql.unsafe(`INSERT INTO "${tableName}" (${colList}) VALUES (${placeholders})`, values);
+		}
+	});
+}
+function fetchBlockModels(sql) {
+	return sql.unsafe("SELECT api_key FROM models WHERE is_block = 1 ORDER BY api_key");
+}
+function collectDescendantBlockIds(sql, startIds) {
+	return Effect.gen(function* () {
+		const blockModels = yield* fetchBlockModels(sql);
+		const allIds = new Set(startIds);
+		let frontier = [...startIds];
+		while (frontier.length > 0) {
+			const next = /* @__PURE__ */ new Set();
+			const placeholders = frontier.map(() => "?").join(", ");
+			for (const model of blockModels) {
+				const rows = yield* sql.unsafe(`SELECT id FROM "block_${model.api_key}" WHERE _parent_block_id IN (${placeholders})`, frontier);
+				for (const row of rows) if (!allIds.has(row.id)) {
+					allIds.add(row.id);
+					next.add(row.id);
+				}
+			}
+			frontier = [...next];
+		}
+		return allIds;
+	});
+}
+function writeStructuredText(params) {
+	return Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		const input = yield* decodeStructuredTextInput(params.fieldApiKey, {
+			value: params.value,
+			blocks: params.blocks ?? {}
+		});
+		const compiled = yield* compileStructuredText({
+			sql,
+			rootRecordId: params.rootRecordId,
+			rootFieldApiKey: params.rootFieldStorageKey ?? params.fieldApiKey,
+			rootModelApiKey: params.rootModelApiKey,
+			seenBlockIds: /* @__PURE__ */ new Set()
+		}, {
+			parentContainerModelApiKey: params.rootModelApiKey,
+			parentBlockId: null,
+			parentFieldApiKey: params.fieldApiKey,
+			depth: 0
+		}, {
+			fieldApiKey: params.fieldApiKey,
+			input,
+			allowedBlockTypes: params.allowedBlockTypes ?? [],
+			blocksOnly: params.blocksOnly ?? false
+		});
+		yield* insertCompiledRows(sql, compiled.rowsByTable);
+		return compiled.dast;
+	});
+}
+function deleteBlocksForField(params) {
+	return Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		const blockModels = yield* fetchBlockModels(sql);
+		for (const model of blockModels) if (params.includeLocalizedVariants) yield* sql.unsafe(`DELETE FROM "block_${model.api_key}"
+           WHERE _root_record_id = ?
+             AND (_root_field_api_key = ? OR _root_field_api_key LIKE ?)`, [
+			params.rootRecordId,
+			params.fieldApiKey,
+			`${params.fieldApiKey}:%`
+		]);
+		else yield* sql.unsafe(`DELETE FROM "block_${model.api_key}" WHERE _root_record_id = ? AND _root_field_api_key = ?`, [params.rootRecordId, params.fieldApiKey]);
+	});
+}
+function deleteBlockSubtrees(params) {
+	return Effect.gen(function* () {
+		if (params.blockIds.length === 0) return;
+		const sql = yield* SqlClient.SqlClient;
+		const blockModels = yield* fetchBlockModels(sql);
+		const ids = [...yield* collectDescendantBlockIds(sql, params.blockIds)];
+		const placeholders = ids.map(() => "?").join(", ");
+		for (const model of blockModels) yield* sql.unsafe(`DELETE FROM "block_${model.api_key}" WHERE id IN (${placeholders})`, ids);
+	});
+}
+function parseMaterializeStructuredTextRequest(request) {
+	const dast = decodeJsonIfString(request.rawValue);
+	if (!dast || typeof dast !== "object") return null;
+	if (!("document" in dast) || typeof dast.document !== "object" || dast.document === null || !("children" in dast.document)) return null;
+	const doc = dast;
+	const blockIds = extractAllBlockIds(doc);
+	return {
+		requestKey: request.requestKey,
+		params: request,
+		doc,
+		blockIds,
+		blockIdSet: new Set(blockIds)
+	};
+}
+function getMaterializeBatchGroupKey(params) {
+	const allowed = params.allowedBlockApiKeys?.join(",") ?? "*";
+	const planKey = serializeMaterializePlan(params.selectedNestedFieldsPlan);
+	return [
+		params.parentContainerModelApiKey,
+		params.parentFieldApiKey,
+		params.rootFieldApiKey,
+		params.parentBlockId === null ? "root" : "nested",
+		allowed,
+		planKey
+	].join(":");
+}
+function serializeMaterializePlan(plan) {
+	if (!plan) return "*";
+	return [...plan.fieldsByBlockApiKey.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([blockApiKey, fieldPlans]) => [blockApiKey, [...fieldPlans.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([fieldApiKey, nestedPlan]) => `${fieldApiKey}(${serializeMaterializePlan(nestedPlan)})`).join(",")]).map(([blockApiKey, nested]) => `${blockApiKey}[${nested}]`).join("|");
+}
+function buildMaterializeQueries(params) {
+	const rootRecordPlaceholders = params.rootRecordIds.map(() => "?").join(", ");
+	const blockPlaceholders = params.blockIds.map(() => "?").join(", ");
+	const parentBlockPlaceholders = params.parentBlockIds.map(() => "?").join(", ");
+	return params.blockModels.map((model) => {
+		const payloadParts = model.fields.map((field) => `'${field.api_key}', "${field.api_key}"`).join(", ");
+		return {
+			sql: `SELECT id, _root_record_id, _root_field_api_key, _parent_block_id, '${model.apiKey}' AS __block_api_key, json_object(${payloadParts}) AS __payload
+       FROM "block_${model.apiKey}"
+       WHERE _root_record_id IN (${rootRecordPlaceholders})
+         AND _root_field_api_key = ?
+         AND _parent_container_model_api_key = ?
+         AND _parent_field_api_key = ?
+         AND ${params.parentBlockIds.length === 0 ? "_parent_block_id IS NULL" : `_parent_block_id IN (${parentBlockPlaceholders})`}
+         AND id IN (${blockPlaceholders})`,
+			params: [
+				...params.rootRecordIds,
+				params.rootFieldApiKey,
+				params.parentContainerModelApiKey,
+				params.parentFieldApiKey,
+				...params.parentBlockIds.length === 0 ? [] : params.parentBlockIds,
+				...params.blockIds
+			]
+		};
+	});
+}
+function materializeStructuredTextValues(params) {
+	return Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		const materializeContext = params.materializeContext ?? {
+			blockModelSchemas: /* @__PURE__ */ new Map(),
+			candidateBlockModels: /* @__PURE__ */ new Map()
+		};
+		const results = /* @__PURE__ */ new Map();
+		const parsedRequests = [];
+		for (const request of params.requests) {
+			const parsed = parseMaterializeStructuredTextRequest(request);
+			if (!parsed) {
+				results.set(request.requestKey, null);
+				continue;
+			}
+			if (parsed.blockIds.length === 0) {
+				results.set(parsed.requestKey, {
+					value: parsed.doc,
+					blocks: {}
+				});
+				continue;
+			}
+			parsedRequests.push(parsed);
+		}
+		if (parsedRequests.length === 0) return results;
+		const blockModels = yield* fetchBlockModelsCached(materializeContext, sql);
+		const requestsByGroup = /* @__PURE__ */ new Map();
+		for (const request of parsedRequests) {
+			const groupKey = getMaterializeBatchGroupKey(request.params);
+			const group = requestsByGroup.get(groupKey);
+			if (group) group.push(request);
+			else requestsByGroup.set(groupKey, [request]);
+			results.set(request.requestKey, {
+				value: request.doc,
+				blocks: {}
+			});
+		}
+		const nestedRequests = [];
+		const nestedAssignments = [];
+		for (const requests of requestsByGroup.values()) {
+			const sample = requests[0];
+			if (!sample) continue;
+			const requestByParentKey = /* @__PURE__ */ new Map();
+			const requestBlockIds = /* @__PURE__ */ new Map();
+			const allBlockIds = /* @__PURE__ */ new Set();
+			const rootRecordIds = /* @__PURE__ */ new Set();
+			const parentBlockIds = /* @__PURE__ */ new Set();
+			for (const request of requests) {
+				const parentKey = `${request.params.rootRecordId}:${request.params.parentBlockId ?? "root"}`;
+				requestByParentKey.set(parentKey, request);
+				requestBlockIds.set(request.requestKey, request.blockIdSet);
+				rootRecordIds.add(request.params.rootRecordId);
+				if (request.params.parentBlockId !== null) parentBlockIds.add(request.params.parentBlockId);
+				for (const blockId of request.blockIds) allBlockIds.add(blockId);
+			}
+			const candidateBlockModels = getCandidateBlockModelsCached(materializeContext, blockModels, sample.params.allowedBlockApiKeys);
+			const blockModelSchemas = yield* Effect.all(candidateBlockModels.map((model) => getBlockModelSchemaCached(materializeContext, sql, model.api_key)), { concurrency: "unbounded" });
+			const blockModelByApiKey = new Map(blockModelSchemas.map((model) => [model.apiKey, model]));
+			const rootRecordIdList = [...rootRecordIds];
+			const blockIds = [...allBlockIds];
+			const parentBlockIdList = [...parentBlockIds];
+			const rows = (yield* runHotBlockQueries(buildMaterializeQueries({
+				blockModels: blockModelSchemas,
+				rootRecordIds: rootRecordIdList,
+				rootFieldApiKey: sample.params.rootFieldApiKey,
+				parentContainerModelApiKey: sample.params.parentContainerModelApiKey,
+				parentFieldApiKey: sample.params.parentFieldApiKey,
+				parentBlockIds: parentBlockIdList,
+				blockIds
+			}))).flat();
+			if (rows.length === 0) continue;
+			for (const row of rows) {
+				const rootRecordId = String(row._root_record_id);
+				const parentBlockId = typeof row._parent_block_id === "string" ? row._parent_block_id : "root";
+				const request = requestByParentKey.get(`${rootRecordId}:${parentBlockId}`);
+				if (!request) continue;
+				const allowedBlockIds = requestBlockIds.get(request.requestKey);
+				const rowId = String(row.id);
+				if (!allowedBlockIds?.has(rowId)) continue;
+				const blockApiKey = typeof row.__block_api_key === "string" ? row.__block_api_key : null;
+				if (!blockApiKey) continue;
+				const blockModel = blockModelByApiKey.get(blockApiKey);
+				if (!blockModel) continue;
+				const rawPayload = decodeJsonIfString(row.__payload);
+				if (typeof rawPayload !== "object" || rawPayload === null || Array.isArray(rawPayload)) continue;
+				const payload = { _type: blockApiKey };
+				const selectedFieldPlans = request.params.selectedNestedFieldsPlan?.fieldsByBlockApiKey.get(blockApiKey);
+				for (const field of blockModel.fields) {
+					const rawValue = deserializeValue(Reflect.get(rawPayload, field.api_key));
+					if (rawValue === void 0) continue;
+					if (field.field_type === "structured_text" && rawValue !== null) {
+						const nestedPlan = selectedFieldPlans?.get(field.api_key);
+						if (request.params.selectedNestedFieldsPlan && !nestedPlan) continue;
+						const requestKey = `nested:${nestedAssignments.length}`;
+						nestedRequests.push({
+							requestKey,
+							materializeContext,
+							allowedBlockApiKeys: blockModel.structuredTextAllowedBlockApiKeysByField.get(field.api_key) ?? [],
+							selectedNestedFieldsPlan: nestedPlan,
+							parentContainerModelApiKey: blockApiKey,
+							parentBlockId: rowId,
+							parentFieldApiKey: field.api_key,
+							rootRecordId,
+							rootFieldApiKey: String(row._root_field_api_key),
+							rawValue
+						});
+						nestedAssignments.push({
+							requestKey,
+							target: payload,
+							fieldApiKey: field.api_key
+						});
+						continue;
+					}
+					payload[field.api_key] = rawValue;
+				}
+				const envelope = results.get(request.requestKey);
+				if (envelope) envelope.blocks[rowId] = payload;
+			}
+		}
+		if (nestedRequests.length > 0) {
+			const nestedResults = yield* materializeStructuredTextValues({
+				materializeContext,
+				requests: nestedRequests
+			});
+			for (const assignment of nestedAssignments) assignment.target[assignment.fieldApiKey] = nestedResults.get(assignment.requestKey) ?? null;
+		}
+		return results;
+	});
+}
+function materializeStructuredTextValue(params) {
+	return Effect.gen(function* () {
+		return (yield* materializeStructuredTextValues({
+			materializeContext: params.materializeContext,
+			requests: [{
+				requestKey: "single",
+				...params
+			}]
+		})).get("single") ?? null;
+	});
+}
+function materializeRecordStructuredTextFields(params) {
+	return Effect.gen(function* () {
+		const materialized = { ...params.record };
+		for (const field of params.fields) {
+			if (field.field_type !== "structured_text") continue;
+			const rawValue = params.record[field.api_key];
+			if (rawValue === null || rawValue === void 0) continue;
+			const materializeContext = {
+				blockModelSchemas: /* @__PURE__ */ new Map(),
+				candidateBlockModels: /* @__PURE__ */ new Map()
+			};
+			if (field.localized) {
+				const localeMap = decodeJsonIfString(rawValue);
+				if (typeof localeMap !== "object" || localeMap === null || Array.isArray(localeMap)) continue;
+				const localized = {};
+				for (const [localeCode, localeValue] of Object.entries(localeMap)) {
+					if (localeValue === null || localeValue === void 0) {
+						localized[localeCode] = localeValue;
+						continue;
+					}
+					localized[localeCode] = yield* materializeStructuredTextValue({
+						allowedBlockApiKeys: getBlockWhitelist(field.validators) ?? [],
+						parentContainerModelApiKey: params.modelApiKey,
+						materializeContext,
+						parentBlockId: null,
+						parentFieldApiKey: field.api_key,
+						rootRecordId: String(params.record.id),
+						rootFieldApiKey: getStructuredTextStorageKey(field.api_key, localeCode),
+						rawValue: localeValue
+					});
+				}
+				materialized[field.api_key] = localized;
+				continue;
+			}
+			const envelope = yield* materializeStructuredTextValue({
+				allowedBlockApiKeys: getBlockWhitelist(field.validators) ?? [],
+				parentContainerModelApiKey: params.modelApiKey,
+				materializeContext,
+				parentBlockId: null,
+				parentFieldApiKey: field.api_key,
+				rootRecordId: String(params.record.id),
+				rootFieldApiKey: field.api_key,
+				rawValue
+			});
+			materialized[field.api_key] = envelope;
+		}
+		return materialized;
+	});
+}
+//#endregion
+export { isSearchable as A, encodeJson as B, findUniqueConstraintViolations as C, getLinksTargets as D, getLinkTargets as E, parseMediaGalleryReferences as F, ReferenceConflictError as G, getFieldTypeDef as H, decodeJsonIfString as I, ValidationError as J, SchemaEngineError as K, decodeJsonRecordStringOr as L, supportsUniqueValidation as M, mergeAssetWithMediaReference as N, getSlugSource as O, parseMediaFieldReference as P, decodeJsonString as R, computeIsValid as S, getBlocksOnly as T, DuplicateError as U, FIELD_TYPE_REGISTRY as V, NotFoundError as W, isCmsError as X, errorToResponse as Y, extractLinkIds as _, materializeStructuredTextValue as a, isContentRow as b, FIELD_TYPES as c, getSqlMetrics as d, recordSqlMetrics as f, extractInlineBlockIds as g, extractBlockIds as h, materializeRecordStructuredTextFields as i, isUnique as j, isRequired as k, isFieldType as l, markdownToDast as m, deleteBlocksForField as n, materializeStructuredTextValues as o, withSqlMetrics as p, UnauthorizedError as q, getStructuredTextStorageKey as r, writeStructuredText as s, deleteBlockSubtrees as t, runBatchedQueries as u, pruneBlockNodes as v, getBlockWhitelist as w, parseFieldValidators as x, StructuredTextWriteInput as y, decodeJsonStringOr as z };
+
+//# sourceMappingURL=structured-text-service-B4xSlUg_.mjs.map