riverbankcms 0.9.0 → 0.11.0

package/dist/{local-sync-DF-2DL_D.mjs → local-sync-7ecbT9He.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { Nt as asAppearancePresetId, S as eventBookingOfferIntentSchema, V as buttonStyleSelectionSchema, c as stableStringify, dt as themeSchema, n as sdkEventOccurrenceInputSchema } from "./sdk-event-upsert-BNxbxaA0.mjs";
-import { A as parseFooterCompositionV1, At as unsafeAsPositiveSeconds, Bt as unsafeAsUserId, Ct as unsafeAsEventOfferingId, Dt as unsafeAsOccurrenceId, Et as unsafeAsMediaAssetId, Ft as unsafeAsSiteScopedStoragePath, Ht as ok, K as parseUtcIsoDateTimeString, Lt as unsafeAsStorageBucketName, Mt as unsafeAsSafeDownloadFilename, Nt as unsafeAsSiteFontId, Ot as unsafeAsOriginalFilename, Pt as unsafeAsSiteId, Rt as unsafeAsStoragePath, St as unsafeAsEntitlementId, Tt as unsafeAsFileChecksumSha256, Vt as err, _t as unsafeAsBookingRequirementId, a as parseVerticalId, i as canonicalizeConfiguredBookingVerticalConfig, jt as unsafeAsProductId, kt as unsafeAsPositiveByteCount, l as EVENT_PRESET_VALUES, lt as assertNever, mt as parseSiteId, o as parseVerticalPresetId, ot as fromArray, s as resolveSiteVerticalBookingConfig, st as mapNonEmptyArray, v as exposeSecret, vt as unsafeAsBookingSessionId, wt as unsafeAsEventSeriesId, xt as unsafeAsDetectedMimeType, yt as unsafeAsDeclaredMimeType, zt as unsafeAsUploadSessionId } from "./src-DbmhanBI.mjs";
-import * as fs from "fs/promises";
+import { T as eventBookingOfferIntentSchema, an as pageDesignBoundaryTreatmentSchema, d as stableStringify, en as buttonStyleSelectionSchema, ir as asSiteStyleId, n as sdkCourseBookingSettingsSchema, on as pageDesignIntentSchemaVersion, q as themeSchema, r as sdkEventOccurrenceInputSchema, rr as asPageFlowPresetId, s as eventVisibilitySchema, tr as asAppearancePresetId } from "./sdk-event-upsert-CRQseim3.mjs";
+import { At as unsafeAsOriginalFilename, Bt as unsafeAsStoragePath, Ct as unsafeAsDetectedMimeType, Dt as unsafeAsFileChecksumSha256, Et as unsafeAsEventSeriesId, Ft as unsafeAsSiteFontId, Ht as unsafeAsUserId, It as unsafeAsSiteId, J as parseUtcIsoDateTimeString, Lt as unsafeAsSiteScopedStoragePath, Mt as unsafeAsPositiveSeconds, Nt as unsafeAsProductId, Ot as unsafeAsMediaAssetId, Pt as unsafeAsSafeDownloadFilename, Tt as unsafeAsEventOfferingId, Ut as err, Vt as unsafeAsUploadSessionId, Wt as ok, a as parseVerticalId, bt as unsafeAsBookingSessionId, ct as fromArray, dt as assertNever, gt as parseSiteId, i as canonicalizeConfiguredBookingVerticalConfig, j as parseFooterCompositionV1, jt as unsafeAsPositiveByteCount, kt as unsafeAsOccurrenceId, l as EVENT_PRESET_VALUES, lt as mapNonEmptyArray, o as parseVerticalPresetId, s as resolveSiteVerticalBookingConfig, v as exposeSecret, wt as unsafeAsEntitlementId, xt as unsafeAsDeclaredMimeType, yt as unsafeAsBookingRequirementId, zt as unsafeAsStorageBucketName } from "./src-CiZrHLCj.mjs";
+import * as fs$1 from "fs/promises";
 import * as path$1 from "path";
 import { z } from "zod";
 import { constants } from "node:fs";
@@ -185,6 +185,101 @@ const sdkEventOccurrenceResponseSchema = z.object({ occurrence: sdkManagementEve
 const sdkDeleteEventOccurrenceResponseSchema = z.object({ deleted: z.literal(true) });
 const sdkReorderResponseSchema = z.object({ reordered: z.literal(true) });
 
+//#endregion
+//#region ../api/src/sdkPageDesign.ts
+/**
+* The portable page design document (issue 1497).
+*
+* A stored `PageDesignIntent` names blocks by their database ids, so it only
+* makes sense on the page it came from. The portable document is the same
+* intent with every block reference expressed as the block's management
+* identifier (`hero-0`, `body-text-1`), which is what lets a design travel from
+* one page to another page built from the same blocks.
+*
+* A boundary is carried as its identifier pair only. Its stored `boundaryId`
+* is derived from the pair after mapping, so the two can never disagree.
+*
+* The document is parsed once, here, at the JSON boundary. Whether it fits a
+* particular destination page is a separate, semantic decision made by the
+* dashboard against that page's blocks and site style.
+*/
+const unsafeAsBlockIdentifier = (value) => value;
+const blockIdentifierSchema = z.string().min(1).transform(unsafeAsBlockIdentifier);
+const portableBlockLookPinSchema = z.object({
+	blockIdentifier: blockIdentifierSchema,
+	blockKind: z.string().min(1),
+	choice: z.object({
+		kind: z.literal("user-pinned"),
+		value: z.string().min(1).transform(asAppearancePresetId)
+	}).strict()
+}).strict();
+const portableBoundaryPinSchema = z.object({
+	previousBlockIdentifier: blockIdentifierSchema,
+	nextBlockIdentifier: blockIdentifierSchema,
+	choice: z.object({
+		kind: z.literal("user-pinned"),
+		value: pageDesignBoundaryTreatmentSchema
+	}).strict()
+}).strict();
+function isRepeated(items, same) {
+	return (item, index) => items.findIndex((other) => same(item, other)) !== index;
+}
+function refineUniquePins(design, ctx) {
+	design.blockLookPins.filter(isRepeated(design.blockLookPins, (a, b) => a.blockIdentifier === b.blockIdentifier)).forEach((pin) => ctx.addIssue({
+		code: "custom",
+		path: ["blockLookPins"],
+		message: `The design pins block "${pin.blockIdentifier}" more than once.`
+	}));
+	design.boundaryPins.filter(isRepeated(design.boundaryPins, (a, b) => a.previousBlockIdentifier === b.previousBlockIdentifier && a.nextBlockIdentifier === b.nextBlockIdentifier)).forEach((pin) => ctx.addIssue({
+		code: "custom",
+		path: ["boundaryPins"],
+		message: `The design pins the break between "${pin.previousBlockIdentifier}" and "${pin.nextBlockIdentifier}" more than once.`
+	}));
+}
+const portablePageDesignSchema = z.object({
+	schemaVersion: z.literal(pageDesignIntentSchemaVersion),
+	siteStyleId: z.string().min(1).transform(asSiteStyleId),
+	pageFlowPresetId: z.string().min(1).transform(asPageFlowPresetId),
+	blockLookPins: z.array(portableBlockLookPinSchema),
+	boundaryPins: z.array(portableBoundaryPinSchema)
+}).strict().superRefine(refineUniquePins);
+const pageDesignRevisionTokenSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("absent") }).strict(),
+	z.object({
+		kind: z.literal("draft"),
+		contentVersionId: z.string().min(1),
+		updatedAt: z.string().min(1)
+	}).strict(),
+	z.object({
+		kind: z.literal("published"),
+		contentVersionId: z.string().min(1),
+		updatedAt: z.string().min(1)
+	}).strict()
+]);
+const sdkSavePageDesignBodySchema = z.object({
+	design: portablePageDesignSchema,
+	expectedRevision: pageDesignRevisionTokenSchema
+}).strict();
+const omittedPagePinSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("look-on-missing-block"),
+	blockId: z.string().min(1)
+}), z.object({
+	kind: z.literal("boundary-on-missing-block"),
+	previousBlockId: z.string().min(1),
+	nextBlockId: z.string().min(1)
+})]);
+const sdkGetPageDesignResponseSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("absent") }), z.object({
+	kind: z.literal("stored"),
+	source: z.enum(["draft", "published"]),
+	design: portablePageDesignSchema,
+	revision: pageDesignRevisionTokenSchema,
+	omitted: z.array(omittedPagePinSchema)
+})]);
+const sdkSavePageDesignResponseSchema = z.object({
+	outcome: z.enum(["created", "updated"]),
+	revision: pageDesignRevisionTokenSchema
+});
+
 //#endregion
 //#region ../api/src/sdkMediaResponseSchemas.ts
 const identifierSchema = z.string().min(1);
@@ -682,6 +777,7 @@ const sdkEventScheduleSchema = z.object({
 });
 const sdkPullEventSchema = z.object({
 	identifier: sdkIdentifierSchema$1,
+	courseBooking: sdkCourseBookingSettingsSchema.optional(),
 	administrativeStatus: z.enum(["active", "archived"]),
 	title: z.string(),
 	slug: sdkIdentifierSchema$1,
@@ -705,11 +801,7 @@ const sdkPullEventRunSchema = z.object({
 		"cancelled",
 		"completed"
 	]),
-	visibility: z.enum([
-		"private",
-		"public",
-		"unlisted"
-	]),
+	visibility: eventVisibilitySchema.optional(),
 	bookingScope: z.enum(["single_occurrence", "whole_series"]),
 	occurrences: z.array(sdkEventOccurrenceInputSchema),
 	capacity: z.number().int().nonnegative().nullable(),
@@ -912,7 +1004,10 @@ const sdkUpsertSettingsResponseSchema = sdkCommandApplicationResultSchema(sdkPul
 const sdkUpsertFormResponseSchema = sdkCommandApplicationResultSchema(sdkPullFormSchemaWithId);
 const sdkUpsertVenueResponseSchema = sdkCommandApplicationResultSchema(sdkPullVenueSchema.extend({ id: sdkIdentifierSchema }));
 const sdkUpsertEventCategoryResponseSchema = sdkCommandApplicationResultSchema(sdkPullEventCategorySchema.extend({ id: sdkIdentifierSchema }));
-const sdkManagementEventSchema = sdkPullEventSchema.extend({ id: sdkIdentifierSchema.transform(unsafeAsEventOfferingId) });
+const sdkManagementEventSchema = sdkPullEventSchema.extend({
+	id: sdkIdentifierSchema.transform(unsafeAsEventOfferingId),
+	pageState: z.enum(["online", "offline"]).optional()
+});
 const sdkManagementEventRunSchema = sdkPullEventRunSchema.extend({
 	id: sdkIdentifierSchema.transform(unsafeAsEventSeriesId),
 	eventId: sdkIdentifierSchema.transform(unsafeAsEventOfferingId),
@@ -927,6 +1022,24 @@ const sdkListEventsResponseSchema = z.object({
 	eventRuns: z.array(sdkManagementEventRunSchema)
 });
 const sdkGetEventResponseSchema = sdkManagementEventGraphSchema;
+const sdkEventSeriesIdSchema = sdkIdentifierSchema.transform(unsafeAsEventSeriesId);
+/**
+* The lifecycle outcome for `POST /sdk/{siteId}/events/{identifier}/lifecycle`.
+* `applied` always changed something: at least one run, or the Event page.
+*/
+const sdkTakeEventOfflineResponseSchema = z.union([
+	z.object({
+		kind: z.literal("applied"),
+		changedRunIds: z.tuple([sdkEventSeriesIdSchema], sdkEventSeriesIdSchema),
+		pageTakenOffline: z.boolean()
+	}),
+	z.object({
+		kind: z.literal("applied"),
+		changedRunIds: z.tuple([]),
+		pageTakenOffline: z.literal(true)
+	}),
+	z.object({ kind: z.literal("already-offline") })
+]);
 const sdkUpsertEventResponseSchema = sdkCommandApplicationResultSchema(sdkManagementEventGraphSchema);
 const sdkUpsertThemeResponseSchema = sdkCommandApplicationResultSchema(z.object({
 	themeId: sdkIdentifierSchema,
@@ -1054,6 +1167,145 @@ function validateManagementResponse(value, schema) {
 	};
 }
 
+//#endregion
+//#region ../management-client/src/transportFailure.ts
+/**
+* Sanitised transport failures (issue 1496).
+*
+* When `fetch` rejects, the caught value can carry anything the platform put
+* there: a message naming the host and port, a cause chain, a stack, and in
+* some runtimes echoes of the request. None of that may leave the client. The
+* caught value is inspected here, and only here, for one thing: whether its
+* platform code (`cause.code`, else `code`) is one of an allow-listed set of
+* Node and undici codes. The result is a closed union whose `code` is always
+* one of those literals, and a fixed message per kind. Nothing else from the caught value is kept.
+*
+* Code lists were checked against Node 24.18 (undici bundled with it) by
+* provoking each failure: DNS lookups fail with `ENOTFOUND`/`EAI_AGAIN`, a
+* closed port with `ECONNREFUSED` (an `AggregateError` carrying the same code
+* when happy-eyeballs tries several addresses), an unroutable host with
+* undici's `UND_ERR_CONNECT_TIMEOUT`, a peer reset with `ECONNRESET`, a peer
+* closing mid-response with `UND_ERR_SOCKET`, and TLS failures with the
+* OpenSSL verification codes and `ERR_TLS_CERT_ALTNAME_INVALID`.
+*
+* Bun puts its code on the error itself rather than on `cause`, so that is read
+* as a fallback. Bun 1.3 reports resets and TLS failures with the same codes
+* as Node; it reports refused connections *and* failed DNS lookups alike as
+* `ConnectionRefused`, which is deliberately not listed and stays `unknown`.
+*/
+const DNS_CODES = ["ENOTFOUND", "EAI_AGAIN"];
+const CONNECT_CODES = [
+	"ECONNREFUSED",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"ECONNABORTED",
+	"EHOSTUNREACH",
+	"ENETUNREACH"
+];
+const RESET_CODES = [
+	"ECONNRESET",
+	"EPIPE",
+	"UND_ERR_SOCKET"
+];
+const TLS_CODES = [
+	"CERT_HAS_EXPIRED",
+	"DEPTH_ZERO_SELF_SIGNED_CERT",
+	"SELF_SIGNED_CERT_IN_CHAIN",
+	"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+	"UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+	"ERR_TLS_CERT_ALTNAME_INVALID",
+	"ERR_SSL_WRONG_VERSION_NUMBER"
+];
+const TIMEOUT_CODES = [
+	"UND_ERR_HEADERS_TIMEOUT",
+	"UND_ERR_BODY_TIMEOUT",
+	"ETIMEDOUT"
+];
+function isOneOf$1(values, value) {
+	return values.includes(value);
+}
+/**
+* Read one property of an arbitrary value. A throwing getter or a hostile
+* proxy yields `undefined`, so inspection can never throw past the boundary.
+*/
+function readProperty(value, key) {
+	if (typeof value !== "object" || value === null) return undefined;
+	try {
+		return Reflect.get(value, key);
+	} catch {
+		return undefined;
+	}
+}
+function stringCode(value) {
+	const code = readProperty(value, "code");
+	return typeof code === "string" ? code : undefined;
+}
+/**
+* The platform code for a rejected `fetch`: Node/undici put it on `cause`;
+* Bun puts its own on the error itself. Nothing else is read.
+*/
+function platformCode(caught) {
+	return stringCode(readProperty(caught, "cause")) ?? stringCode(caught);
+}
+/** Map a raw code onto the closed union; anything unlisted is `unknown`. */
+function transportFailureFromCode(code) {
+	if (code === undefined) return { kind: "unknown" };
+	if (isOneOf$1(DNS_CODES, code)) return {
+		kind: "dns",
+		code
+	};
+	if (isOneOf$1(CONNECT_CODES, code)) return {
+		kind: "connect",
+		code
+	};
+	if (isOneOf$1(RESET_CODES, code)) return {
+		kind: "reset",
+		code
+	};
+	if (isOneOf$1(TLS_CODES, code)) return {
+		kind: "tls",
+		code
+	};
+	if (isOneOf$1(TIMEOUT_CODES, code)) return {
+		kind: "timeout",
+		code
+	};
+	return { kind: "unknown" };
+}
+/** True when the client's own `AbortSignal.timeout` ended the request. */
+function isClientTimeout(caught) {
+	return readProperty(caught, "name") === "TimeoutError";
+}
+/**
+* Classify a rejected `fetch` or body read. The caught value is read only for
+* its `name` and platform code (guarded, see `readProperty`). `timeoutMs` is
+* the limit the client itself applied, so the timeout message can name it.
+*/
+function classifyTransportFailure(caught, timeoutMs) {
+	return isClientTimeout(caught) ? {
+		code: "sdk:timeout",
+		transport: { kind: "timeout" },
+		timeoutMs
+	} : {
+		code: "sdk:network-error",
+		transport: transportFailureFromCode(platformCode(caught))
+	};
+}
+/** The fixed message for a classified failure. */
+function transportErrorMessage(failure) {
+	return failure.code === "sdk:timeout" ? `Request timed out after ${failure.timeoutMs}ms` : transportFailureMessage(failure.transport);
+}
+/** The fixed, safe message for each kind of network failure. */
+function transportFailureMessage(failure) {
+	switch (failure.kind) {
+		case "dns": return "Could not resolve the dashboard hostname";
+		case "connect": return "Could not open a connection to the dashboard";
+		case "reset": return "The connection to the dashboard closed before a response arrived";
+		case "tls": return "The TLS handshake with the dashboard failed";
+		case "timeout": return "The connection to the dashboard timed out";
+		case "unknown": return "Network request failed";
+	}
+}
+
 //#endregion
 //#region ../management-client/src/http.ts
 /**
@@ -1081,6 +1333,29 @@ var ManagementInvalidResponseError = class extends ManagementApiError {
 	}
 };
 /**
+* The request never produced a dashboard answer. The message is fixed per
+* failure kind and nothing from the platform error (its message, cause, stack
+* or anything echoing the request) is kept: `transport` is the only diagnostic.
+*/
+var ManagementTransportError = class extends ManagementApiError {
+	/** The message is derived from the classification; no free text is accepted. */
+	constructor(classified, request) {
+		super(transportErrorMessage(classified), classified.code, undefined, undefined, request);
+		this.details = undefined;
+		this.name = "ManagementTransportError";
+		this.code = classified.code;
+		this.transport = classified.transport;
+	}
+};
+/**
+* Turn a rejected `fetch` or body read into a {@link ManagementTransportError}.
+* Every catch site around a management `fetch` or response-body read goes
+* through here so none of them can leak the platform error.
+*/
+function managementTransportError(caught, timeoutMs, request) {
+	return new ManagementTransportError(classifyTransportFailure(caught, timeoutMs), request);
+}
+/**
 * Type guard to check if an error is a 404 Not Found response.
 * Use this to handle "resource not found" scenarios gracefully.
 *
@@ -1150,6 +1425,7 @@ function parseApiResponse(value) {
 function buildRequestInfo(options) {
 	return {
 		method: options.method,
+		intent: options.intent,
 		path: options.path,
 		url: options.url,
 		baseUrl: options.baseUrl,
@@ -1157,9 +1433,20 @@ function buildRequestInfo(options) {
 		siteId: options.siteId
 	};
 }
-async function readApiResponse(response, requestInfo, options = {}) {
+/**
+* Read a response body as text. A body that fails mid-read (a reset, undici's
+* body timeout, the client's own abort) is a transport failure like any other.
+*/
+async function readResponseText(response, timeoutMs, requestInfo) {
+	try {
+		return await response.text();
+	} catch (error) {
+		throw managementTransportError(error, timeoutMs, requestInfo);
+	}
+}
+async function readApiResponse(response, requestInfo, options) {
 	const contentType = response.headers.get("content-type");
-	const text = await response.text().catch(() => "");
+	const text = await readResponseText(response, options.timeoutMs, requestInfo);
 	if (!contentType?.includes("application/json")) {
 		if (response.ok && options.allowNonJsonOk) return undefined;
 		if (response.ok && options.invalidOkResponse) {
@@ -1199,6 +1486,10 @@ function requestUrl(baseUrl, path$2, params) {
 	const query = new URLSearchParams(params).toString();
 	return `${baseUrl}${path$2}?${query}`;
 }
+const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+function requestTimeoutMs(config) {
+	return config.timeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
+}
 function requestFetchOptions(config, method, body) {
 	const options = {
 		method,
@@ -1206,14 +1497,15 @@ function requestFetchOptions(config, method, body) {
 			Authorization: `Bearer ${exposeSecret(config.managementApiKey)}`,
 			"Content-Type": "application/json"
 		},
-		signal: AbortSignal.timeout(config.timeout ?? 3e4)
+		signal: AbortSignal.timeout(requestTimeoutMs(config))
 	};
 	if (body !== undefined && method !== "GET") options.body = JSON.stringify(body);
 	return options;
 }
-async function fetchManagementResponse(config, method, path$2, url, baseUrl, options) {
+async function fetchManagementResponse(config, method, intent, path$2, url, baseUrl, options) {
 	const requestInfo = buildRequestInfo({
 		method,
+		intent,
 		path: path$2,
 		url,
 		baseUrl,
@@ -1226,10 +1518,7 @@ async function fetchManagementResponse(config, method, path$2, url, baseUrl, opt
 			requestInfo
 		};
 	} catch (error) {
-		if (error instanceof Error && error.name === "TimeoutError") {
-			throw new ManagementApiError(`Request timed out after ${config.timeout ?? 3e4}ms`, "sdk:timeout", undefined, undefined, requestInfo);
-		}
-		throw new ManagementApiError(error instanceof Error ? error.message : "Network request failed", "sdk:network-error", undefined, undefined, requestInfo);
+		throw managementTransportError(error, requestTimeoutMs(config), requestInfo);
 	}
 }
 function throwApiError(response, json, requestInfo) {
@@ -1242,53 +1531,61 @@ function throwApiError(response, json, requestInfo) {
 }
 async function requestWithConfig(config, method, path$2, options) {
 	const baseUrl = `${config.dashboardUrl}/api/sdk/${config.siteId}`;
-	const url = requestUrl(baseUrl, path$2, options?.params);
-	const fetchOptions = requestFetchOptions(config, method, options?.body);
-	const { response, requestInfo } = await fetchManagementResponse(config, method, path$2, url, baseUrl, fetchOptions);
-	const responseSchema = options?.responseSchema ?? schemaForManagementRequest(method, path$2, options?.body);
-	const json = responseSchema ? await readApiResponse(response, requestInfo, { invalidOkResponse: true }) : await readApiResponse(response, requestInfo, { allowNonJsonOk: true });
+	const url = requestUrl(baseUrl, path$2, options.params);
+	const fetchOptions = requestFetchOptions(config, method, options.body);
+	const { response, requestInfo } = await fetchManagementResponse(config, method, options.intent, path$2, url, baseUrl, fetchOptions);
+	const responseSchema = options.responseSchema ?? schemaForManagementRequest(method, path$2, options.body);
+	const timeoutMs = requestTimeoutMs(config);
+	const json = responseSchema ? await readApiResponse(response, requestInfo, {
+		timeoutMs,
+		invalidOkResponse: true
+	}) : await readApiResponse(response, requestInfo, {
+		timeoutMs,
+		allowNonJsonOk: true
+	});
 	if (!json) return undefined;
 	throwApiError(response, json, requestInfo);
 	return responseSchema ? parseRuntimeResponse(json.data, responseSchema, requestInfo, response.status) : json.data;
 }
 function createHttpClient(config) {
+	const send = (method, path$2, options) => requestWithConfig(config, method, path$2, options);
 	return {
-		async get(path$2, params) {
-			return requestWithConfig(config, "GET", path$2, { params });
-		},
-		async post(path$2, body) {
-			return requestWithConfig(config, "POST", path$2, { body });
-		},
-		async patch(path$2, body) {
-			return requestWithConfig(config, "PATCH", path$2, { body });
-		},
-		async delete(path$2, body) {
-			return requestWithConfig(config, "DELETE", path$2, { body });
-		},
-		async getValidated(path$2, schema, params) {
-			return requestWithConfig(config, "GET", path$2, {
-				params,
-				responseSchema: schema
-			});
-		},
-		async postValidated(path$2, schema, body) {
-			return requestWithConfig(config, "POST", path$2, {
-				body,
-				responseSchema: schema
-			});
-		},
-		async patchValidated(path$2, schema, body) {
-			return requestWithConfig(config, "PATCH", path$2, {
-				body,
-				responseSchema: schema
-			});
-		},
-		async deleteValidated(path$2, schema, body) {
-			return requestWithConfig(config, "DELETE", path$2, {
-				body,
-				responseSchema: schema
-			});
-		}
+		get: (path$2, params) => send("GET", path$2, {
+			intent: "read",
+			params
+		}),
+		post: (path$2, body, intent) => send("POST", path$2, {
+			intent,
+			body
+		}),
+		patch: (path$2, body) => send("PATCH", path$2, {
+			intent: "write",
+			body
+		}),
+		delete: (path$2, body) => send("DELETE", path$2, {
+			intent: "write",
+			body
+		}),
+		getValidated: (path$2, responseSchema, params) => send("GET", path$2, {
+			intent: "read",
+			params,
+			responseSchema
+		}),
+		postValidated: (path$2, responseSchema, body, intent) => send("POST", path$2, {
+			intent,
+			body,
+			responseSchema
+		}),
+		patchValidated: (path$2, responseSchema, body) => send("PATCH", path$2, {
+			intent: "write",
+			body,
+			responseSchema
+		}),
+		deleteValidated: (path$2, responseSchema, body) => send("DELETE", path$2, {
+			intent: "write",
+			body,
+			responseSchema
+		})
 	};
 }
 
@@ -7353,7 +7650,7 @@ const MANIFEST_VERSION = 2;
 const getManifestPath = (contentDir) => path$1.join(contentDir, "media", ".manifest.json");
 const ensureDir = async (dirPath) => {
 	try {
-		await fs.mkdir(dirPath, { recursive: true });
+		await fs$1.mkdir(dirPath, { recursive: true });
 	} catch (error) {
 		if (error.code !== "EEXIST") {
 			throw error;
@@ -7362,7 +7659,7 @@ const ensureDir = async (dirPath) => {
 };
 const writeJsonFile = async (filePath, data) => {
 	const content = JSON.stringify(data, null, 2) + "\n";
-	await fs.writeFile(filePath, content, "utf-8");
+	await fs$1.writeFile(filePath, content, "utf-8");
 };
 const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const hasManifestShape = (value) => {
@@ -7431,7 +7728,7 @@ const createEmptyMediaManifest = () => ({
 async function readMediaManifest(contentDir) {
 	const manifestPath = getManifestPath(contentDir);
 	try {
-		const content = await fs.readFile(manifestPath, "utf-8");
+		const content = await fs$1.readFile(manifestPath, "utf-8");
 		return parseManifest(content) ?? createEmptyMediaManifest();
 	} catch (error) {
 		const nodeError = error;
@@ -8493,7 +8790,7 @@ async function writeBinaryFileAtomic(filePath, data, options) {
 const MEDIA_DIR_NAME = "media";
 const fileExists = async (filePath) => {
 	try {
-		await fs.access(filePath);
+		await fs$1.access(filePath);
 		return true;
 	} catch {
 		return false;
@@ -8501,7 +8798,7 @@ const fileExists = async (filePath) => {
 };
 const listMediaDirFiles = async (mediaDir) => {
 	try {
-		return await fs.readdir(mediaDir);
+		return await fs$1.readdir(mediaDir);
 	} catch (error) {
 		const nodeError = error;
 		if (nodeError.code === "ENOENT") return [];
@@ -8557,7 +8854,7 @@ async function loadLocalMediaFile(contentDir, identifier, manifest) {
 }
 async function writeLocalMediaFile(contentDir, filename, data) {
 	const mediaDir = path$1.join(contentDir, MEDIA_DIR_NAME);
-	await fs.mkdir(mediaDir, { recursive: true });
+	await fs$1.mkdir(mediaDir, { recursive: true });
 	const filePath = path$1.join(mediaDir, filename);
 	const written = await writeBinaryFileAtomic(filePath, data, {
 		overwrite: "allow",
@@ -9824,7 +10121,7 @@ const removeStaleLocalFile = async (options) => {
 	}
 	const previousPath = path$1.join(options.contentDir, "media", options.previousFilename);
 	if (await localMediaFileExists(previousPath)) {
-		await fs.unlink(previousPath).catch(() => {});
+		await fs$1.unlink(previousPath).catch(() => {});
 	}
 };
 const applySkipDecision = (decision, context, local, existingEntry) => {
@@ -10057,4 +10354,4 @@ async function syncLocalMediaForPush(options) {
 }
 
 //#endregion
-export { sdkUpsertEventResponseSchema as $, resolveMediaTransformForAspect as A, asRecord as B, walkAndCollectImageAttrs as C, normalizeWidthCandidates as D, rotateNormalizedPoint as E, buildMediaIdentifierFromFilename as F, parseSafeDownloadFilename as G, FILE_SIZE_LIMITS as H, parseMediaIdentifier as I, createHttpClient as J, ManagementApiError as K, deriveVideoSlotPolicy as L, getDirectImageUrlForSiteScopedPath as M, getImageUrl as N, isExplicitRectCrop as O, isSiteScopedDirectImageStoragePath as P, sdkListEventsResponseSchema as Q, resolveVideoSelectionIntentForMediaField as R, buildRenderableMediaAssetIndex as S, looksLikeUuid as T, classifyKnownMimeType as U, parseRelativeStoragePath as V, managementMediaLibraryUploadLimitForMimeType as W, sdkConfigureBookingVerticalResponseSchema as X, is404Error as Y, sdkGetEventResponseSchema as Z, buildSettingsUpdateInput as _, sdkConfiguredBookingVerticalConfigSchema as _t, prepareLocalMediaForPush as a, externalLinkSchema$1 as at, isMediaValue as b, writeBinaryFileAtomic as c, internalRouteOnlyLinkSchema as ct, normalizeMediaValueToIdentifierOnly as d, linkSchema as dt, sdkSettingsUpdateSchema as et, walkLocalContentMedia as f, pageLinkSchema$1 as ft, SETTINGS_FILE_FIELDS as g, sdkReorderResponseSchema as gt, extractMediaIdentifiers as h, sdkListEventOccurrencesResponseSchema as ht, applyLocalMediaPush as i, entryLinkSchema$1 as it, getDirectImageUrlForRelativePath as j, parseAspectRatioValue as k, sha256 as l, isInternalResolvedLinkValue as lt, downloadMedia as m, sdkEventOccurrenceResponseSchema as mt, syncLocalMediaForPush as n, RESOLVED_INTERNAL_LINK_ENTITY_TYPES as nt, admitBinaryWriteDestination as o, internalLinkSchema as ot, buildStorageUrl as p, sdkDeleteEventOccurrenceResponseSchema as pt, buildRequestInfo as q, syncLocalMediaForPull as r, customLinkSchema$1 as rt, readStableBinaryFile as s, internalResolvedLinkSchema as st, revalidateLocalMediaPushPlan as t, linkPayloadSchema as tt, normalizeMediaIdentifierInput as u, isResolvedInternalLinkEntityType as ut, hasOwnSettingsField as v, deleteEnvSpecificKeys as w, attachRenderableMediaAssetFields as x, writeMediaManifest as y, getMimeType as z };
+export { sdkListEventsResponseSchema as $, resolveMediaTransformForAspect as A, asRecord as B, walkAndCollectImageAttrs as C, normalizeWidthCandidates as D, rotateNormalizedPoint as E, buildMediaIdentifierFromFilename as F, parseSafeDownloadFilename as G, FILE_SIZE_LIMITS as H, parseMediaIdentifier as I, createHttpClient as J, ManagementApiError as K, deriveVideoSlotPolicy as L, getDirectImageUrlForSiteScopedPath as M, getImageUrl as N, isExplicitRectCrop as O, isSiteScopedDirectImageStoragePath as P, sdkGetEventResponseSchema as Q, resolveVideoSelectionIntentForMediaField as R, buildRenderableMediaAssetIndex as S, sdkConfiguredBookingVerticalConfigSchema as St, looksLikeUuid as T, classifyKnownMimeType as U, parseRelativeStoragePath as V, managementMediaLibraryUploadLimitForMimeType as W, managementTransportError as X, is404Error as Y, sdkConfigureBookingVerticalResponseSchema as Z, buildSettingsUpdateInput as _, sdkSavePageDesignResponseSchema as _t, prepareLocalMediaForPush as a, customLinkSchema$1 as at, isMediaValue as b, sdkListEventOccurrencesResponseSchema as bt, writeBinaryFileAtomic as c, internalLinkSchema as ct, normalizeMediaValueToIdentifierOnly as d, isInternalResolvedLinkValue as dt, sdkTakeEventOfflineResponseSchema as et, walkLocalContentMedia as f, isResolvedInternalLinkEntityType as ft, SETTINGS_FILE_FIELDS as g, sdkGetPageDesignResponseSchema as gt, extractMediaIdentifiers as h, portablePageDesignSchema as ht, applyLocalMediaPush as i, RESOLVED_INTERNAL_LINK_ENTITY_TYPES as it, getDirectImageUrlForRelativePath as j, parseAspectRatioValue as k, sha256 as l, internalResolvedLinkSchema as lt, downloadMedia as m, pageLinkSchema$1 as mt, syncLocalMediaForPush as n, sdkSettingsUpdateSchema as nt, admitBinaryWriteDestination as o, entryLinkSchema$1 as ot, buildStorageUrl as p, linkSchema as pt, buildRequestInfo as q, syncLocalMediaForPull as r, linkPayloadSchema as rt, readStableBinaryFile as s, externalLinkSchema$1 as st, revalidateLocalMediaPushPlan as t, sdkUpsertEventResponseSchema as tt, normalizeMediaIdentifierInput as u, internalRouteOnlyLinkSchema as ut, hasOwnSettingsField as v, sdkDeleteEventOccurrenceResponseSchema as vt, deleteEnvSpecificKeys as w, attachRenderableMediaAssetFields as x, sdkReorderResponseSchema as xt, writeMediaManifest as y, sdkEventOccurrenceResponseSchema as yt, getMimeType as z };

package/dist/{plan-By0bjnd3.mjs → plan-BIwseF-X.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { Ht as ok, Vt as err, mt as parseSiteId } from "./src-DbmhanBI.mjs";
+import { Ut as err, Wt as ok, gt as parseSiteId } from "./src-CiZrHLCj.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/scaffold/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "../src-DbmhanBI.mjs";
-import { a as prepareScaffoldExecution, d as loadGeneratedPackageRanges, i as preflightScaffoldTargets, l as deriveGeneratedPackageRanges, o as writeScaffoldFiles, r as preflightScaffoldPlan, s as deriveScaffoldLocalManifest, t as deriveScaffoldPlan, u as findPackageManifestPath } from "../plan-By0bjnd3.mjs";
+import "../src-CiZrHLCj.mjs";
+import { a as prepareScaffoldExecution, d as loadGeneratedPackageRanges, i as preflightScaffoldTargets, l as deriveGeneratedPackageRanges, o as writeScaffoldFiles, r as preflightScaffoldPlan, s as deriveScaffoldLocalManifest, t as deriveScaffoldPlan, u as findPackageManifestPath } from "../plan-BIwseF-X.mjs";
 
 export { deriveGeneratedPackageRanges, deriveScaffoldLocalManifest, deriveScaffoldPlan, findPackageManifestPath, loadGeneratedPackageRanges, preflightScaffoldPlan, preflightScaffoldTargets, prepareScaffoldExecution, writeScaffoldFiles };