@riverbankcms/sdk 0.67.0 → 0.68.0

package/dist/cli/index.mjs

@@ -18991,6 +18991,20 @@ var ENDPOINT_DEFINITIONS = {
     responseKind: "json",
     errors: ["validation:invalid_input", "billing:plan_limit_exceeded", "server:internal_error"]
   },
+  createAppointmentResourceWithAccountAccess: {
+    path: "/sites/{siteId}/bookings/resources/account-access",
+    method: "POST",
+    auth: "user",
+    responseKind: "json",
+    errors: [
+      "validation:invalid_input",
+      "auth:forbidden",
+      "billing:plan_limit_exceeded",
+      "resource:conflict",
+      "resource:not_found",
+      "server:internal_error"
+    ]
+  },
   getAppointmentResource: {
     path: "/sites/{siteId}/bookings/resources/{resourceId}",
     method: "GET",
@@ -34907,6 +34921,11 @@ init_buildThemeRuntime();
 // ../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts
 init_colorConversion();
 init_shadow2();
+init_core();
+init_core2();
+init_status();
+init_progress();
+init_blocks();
 
 // ../theme-core/src/siteChrome.tsx
 init_types2();
@@ -41576,6 +41595,43 @@ function formatSyncResult(result, dryRun) {
   return lines.join("\n");
 }
 
+// src/cli/sync/syncResultAggregation.ts
+var syncCounterKeysBySection = {
+  entries: ["created", "updated", "deleted", "failed", "published", "unpublished"],
+  pages: ["created", "updated", "failed", "published", "unpublished"],
+  blocks: ["created", "updated", "deleted", "failed"],
+  navigation: ["created", "updated", "failed"],
+  settings: ["updated", "failed"],
+  forms: ["created", "updated", "failed"],
+  footer: ["updated", "failed"]
+};
+function mergeManySyncResults(results) {
+  return results.reduce(
+    (merged, result) => mergeSyncResults(merged, result),
+    createEmptySyncResult()
+  );
+}
+function mergeSyncResults(first, second) {
+  return {
+    entries: addCounters(first.entries, second.entries, syncCounterKeysBySection.entries),
+    pages: addCounters(first.pages, second.pages, syncCounterKeysBySection.pages),
+    blocks: addCounters(first.blocks, second.blocks, syncCounterKeysBySection.blocks),
+    navigation: addCounters(first.navigation, second.navigation, syncCounterKeysBySection.navigation),
+    settings: addCounters(first.settings, second.settings, syncCounterKeysBySection.settings),
+    forms: addCounters(first.forms, second.forms, syncCounterKeysBySection.forms),
+    footer: addCounters(first.footer, second.footer, syncCounterKeysBySection.footer),
+    errors: [...first.errors, ...second.errors],
+    warnings: [...first.warnings, ...second.warnings]
+  };
+}
+function addCounters(first, second, keys) {
+  const result = {};
+  for (const key of keys) {
+    result[key] = (first[key] ?? 0) + (second[key] ?? 0);
+  }
+  return result;
+}
+
 // src/cli/commands/pull-scope-diff.ts
 function zeroEntriesSummary() {
   return { create: 0, update: 0, delete: 0, unchanged: 0, publish: 0, unpublish: 0 };
@@ -43909,6 +43965,7 @@ var resourceKinds = [
   "content",
   "staff",
   "venue",
+  "event-category",
   "event",
   "course",
   "ticket",
@@ -43955,6 +44012,18 @@ function createFormRef(parts) {
 function createFooterRef(parts) {
   return `footer:${joinRefSlugParts(parts)}`;
 }
+function createVenueRef(parts) {
+  return `venue:${joinRefSlugParts(parts)}`;
+}
+function createEventCategoryRef(parts) {
+  return `event-category:${joinRefSlugParts(parts)}`;
+}
+function createEventSeriesRef(parts) {
+  return `event:${joinRefSlugParts(parts)}`;
+}
+function createCourseRef(parts) {
+  return `course:${joinRefSlugParts(parts)}`;
+}
 function createSiteCommandSiteRef(parts) {
   return `site:${joinRefSlugParts(parts)}`;
 }
@@ -44002,6 +44071,7 @@ var footerRefSchema = resourceRefSchema("footer");
 var contentEntryRefSchema = resourceRefSchema("content");
 var staffRefSchema = resourceRefSchema("staff");
 var venueRefSchema = resourceRefSchema("venue");
+var eventCategoryRefSchema = resourceRefSchema("event-category");
 var eventSeriesRefSchema = resourceRefSchema("event");
 var courseRefSchema = resourceRefSchema("course");
 var ticketTypeRefSchema = resourceRefSchema("ticket");
@@ -44115,6 +44185,7 @@ var geoPointSchema = z.object({
 var contentSummarySchema = z.object({
   summary: z.string().min(1).optional(),
   body: z.unknown().optional(),
+  image: z.unknown().optional(),
   imageRef: mediaRefSchema.optional(),
   mediaRefs: z.array(mediaRefSchema).readonly().optional(),
   contentEntryRef: contentEntryRefSchema.optional()
@@ -44440,6 +44511,33 @@ var upsertVenueCommandSchema = z.object({
     mapEmbedUrl: z.string().url().optional()
   }).strict()
 }).strict();
+var deleteVenueCommandSchema = z.object({
+  type: z.literal("deleteVenue"),
+  ref: commandRefSchema,
+  input: z.object({
+    slug: z.string().min(1),
+    venueRef: venueRefSchema.optional()
+  }).strict()
+}).strict();
+var upsertEventCategoryCommandSchema = z.object({
+  type: z.literal("upsertEventCategory"),
+  ref: eventCategoryRefSchema,
+  input: z.object({
+    identifier: z.string().min(1).optional(),
+    name: z.string().min(1),
+    description: z.string().min(1).nullable().optional(),
+    color: z.string().min(1).nullable().optional(),
+    sortOrder: z.number().int().optional()
+  }).strict()
+}).strict();
+var deleteEventCategoryCommandSchema = z.object({
+  type: z.literal("deleteEventCategory"),
+  ref: commandRefSchema,
+  input: z.object({
+    identifier: z.string().min(1),
+    eventCategoryRef: eventCategoryRefSchema.optional()
+  }).strict()
+}).strict();
 var upsertEventSeriesCommandSchema = z.object({
   type: z.literal("upsertEventSeries"),
   ref: eventSeriesRefSchema,
@@ -44447,18 +44545,38 @@ var upsertEventSeriesCommandSchema = z.object({
     slug: z.string().min(1),
     title: z.string().min(1),
     archetype: z.enum(offeringArchetypes),
+    status: z.enum(["draft", "active", "archived", "cancelled"]).optional(),
     visibility: z.enum(offeringVisibilities),
     timezone: ianaTimezoneSchema,
     venueRef: venueRefSchema.optional(),
+    venueIdentifier: z.string().min(1).optional(),
+    categoryRef: eventCategoryRefSchema.optional(),
+    categoryIdentifier: z.string().min(1).optional(),
+    formRef: formRefSchema.optional(),
+    formIdentifier: z.string().min(1).optional(),
     capacity: offeringCapacitySchema.optional(),
     waitlist: waitlistIntentSchema.optional(),
     pricing: eventPricingIntentSchema,
+    priceDisplay: z.string().min(1).nullable().optional(),
+    acceptsPasses: z.boolean().optional(),
+    acceptsMemberships: z.boolean().optional(),
     deliveryMode: z.enum(["in_person", "online", "hybrid"]).optional(),
     occurrences: z.array(eventOccurrenceSchema).min(1).readonly(),
     content: contentSummarySchema.optional(),
+    settings: unknownRecordSchema.optional(),
+    presentation: unknownRecordSchema.nullable().optional(),
+    tags: z.array(z.string()).readonly().optional(),
     staffRefs: z.array(staffRefSchema).readonly().optional()
   }).strict()
 }).strict();
+var deleteEventSeriesCommandSchema = z.object({
+  type: z.literal("deleteEventSeries"),
+  ref: commandRefSchema,
+  input: z.object({
+    identifier: z.string().min(1),
+    eventRef: eventSeriesRefSchema.optional()
+  }).strict()
+}).strict();
 var upsertEventTicketTypeCommandSchema = z.object({
   type: z.literal("upsertEventTicketType"),
   ref: ticketTypeRefSchema,
@@ -44479,17 +44597,38 @@ var upsertCourseCommandSchema = z.object({
   input: z.object({
     slug: z.string().min(1),
     title: z.string().min(1),
+    status: z.enum(["draft", "active", "cancelled"]).optional(),
     visibility: z.enum(offeringVisibilities),
     timezone: ianaTimezoneSchema,
     venueRef: venueRefSchema.optional(),
+    venueIdentifier: z.string().min(1).optional(),
+    categoryRef: eventCategoryRefSchema.optional(),
+    categoryIdentifier: z.string().min(1).optional(),
+    formRef: formRefSchema.optional(),
+    formIdentifier: z.string().min(1).optional(),
     capacity: offeringCapacitySchema.optional(),
+    enrollmentCapacity: positiveIntegerSchema.nullable().optional(),
     waitlist: waitlistIntentSchema.optional(),
     pricing: coursePricingIntentSchema,
+    acceptsMemberships: z.boolean().optional(),
     sessions: z.array(courseSessionSchema2).min(1).readonly(),
     content: contentSummarySchema.optional(),
+    programRef: z.string().min(1).nullable().optional(),
+    program: z.object({
+      identifier: z.string().min(1).nullable().optional(),
+      data: unknownRecordSchema
+    }).strict().nullable().optional(),
     staffRefs: z.array(staffRefSchema).readonly().optional()
   }).strict()
 }).strict();
+var deleteCourseCommandSchema = z.object({
+  type: z.literal("deleteCourse"),
+  ref: commandRefSchema,
+  input: z.object({
+    identifier: z.string().min(1),
+    courseRef: courseRefSchema.optional()
+  }).strict()
+}).strict();
 var ensureTeamMemberProfileCommandSchema = z.object({
   type: z.literal("ensureTeamMemberProfile"),
   ref: contentEntryRefSchema,
@@ -44848,9 +44987,14 @@ var siteCommandSchema = z.discriminatedUnion("type", [
   upsertStaffMemberCommandSchema,
   ensureTeamMemberProfileCommandSchema,
   upsertVenueCommandSchema,
+  deleteVenueCommandSchema,
+  upsertEventCategoryCommandSchema,
+  deleteEventCategoryCommandSchema,
   upsertEventSeriesCommandSchema,
+  deleteEventSeriesCommandSchema,
   upsertEventTicketTypeCommandSchema,
   upsertCourseCommandSchema,
+  deleteCourseCommandSchema,
   upsertBookingPassProductCommandSchema,
   upsertBookingMembershipProductCommandSchema,
   seedBookingCustomerCommandSchema,
@@ -44971,7 +45115,7 @@ var siteCommandMetadata = {
     conflictPolicy: "update_existing",
     previewability: "static_preview",
     allowedRuntimes: ["development", "staging", "demo", "production"],
-    intendedExposure: ["recipe", "sdk_cli", "onboarding_planner", "ai_proposal", "internal_apply"],
+    intendedExposure: ["recipe", "sdk_cli", "onboarding_planner", "internal_apply"],
     capability: "theme.write",
     support: "supported"
   },
@@ -45209,6 +45353,45 @@ var siteCommandMetadata = {
     capability: "bookings.venues.write",
     support: "supported"
   },
+  deleteVenue: {
+    scope: "venue",
+    risk: "medium",
+    writeSemantics: "delete",
+    lifecycleIntent: "mutation",
+    idempotencyStrategy: "existing_id",
+    conflictPolicy: "update_existing",
+    previewability: "effect_required",
+    allowedRuntimes: ["development", "staging", "demo", "production"],
+    intendedExposure: ["sdk_cli", "internal_apply"],
+    capability: "bookings.venues.delete",
+    support: "supported"
+  },
+  upsertEventCategory: {
+    scope: "event_category",
+    risk: "medium",
+    writeSemantics: "upsert",
+    lifecycleIntent: "mutation",
+    idempotencyStrategy: "recipe_ref",
+    conflictPolicy: "update_existing",
+    previewability: "dry_run_only",
+    allowedRuntimes: ["development", "staging", "demo", "production"],
+    intendedExposure: ["sdk_cli", "internal_apply"],
+    capability: "bookings.event_categories.write",
+    support: "supported"
+  },
+  deleteEventCategory: {
+    scope: "event_category",
+    risk: "medium",
+    writeSemantics: "delete",
+    lifecycleIntent: "mutation",
+    idempotencyStrategy: "existing_id",
+    conflictPolicy: "update_existing",
+    previewability: "effect_required",
+    allowedRuntimes: ["development", "staging", "demo", "production"],
+    intendedExposure: ["sdk_cli", "internal_apply"],
+    capability: "bookings.event_categories.delete",
+    support: "supported"
+  },
   upsertEventSeries: {
     scope: "event",
     risk: "medium",
@@ -45222,6 +45405,19 @@ var siteCommandMetadata = {
     capability: "bookings.events.write",
     support: "supported"
   },
+  deleteEventSeries: {
+    scope: "event",
+    risk: "medium",
+    writeSemantics: "delete",
+    lifecycleIntent: "mutation",
+    idempotencyStrategy: "existing_id",
+    conflictPolicy: "update_existing",
+    previewability: "effect_required",
+    allowedRuntimes: ["development", "staging", "demo", "production"],
+    intendedExposure: ["sdk_cli", "internal_apply"],
+    capability: "bookings.events.delete",
+    support: "supported"
+  },
   upsertEventTicketType: {
     scope: "ticket",
     risk: "medium",
@@ -45248,6 +45444,19 @@ var siteCommandMetadata = {
     capability: "bookings.courses.write",
     support: "supported"
   },
+  deleteCourse: {
+    scope: "course",
+    risk: "medium",
+    writeSemantics: "delete",
+    lifecycleIntent: "mutation",
+    idempotencyStrategy: "existing_id",
+    conflictPolicy: "update_existing",
+    previewability: "effect_required",
+    allowedRuntimes: ["development", "staging", "demo", "production"],
+    intendedExposure: ["sdk_cli", "internal_apply"],
+    capability: "bookings.courses.delete",
+    support: "supported"
+  },
   upsertBookingPassProduct: {
     scope: "pass",
     risk: "medium",
@@ -45466,6 +45675,7 @@ function commandRefContributions(command) {
     case "upsertFooterContent":
     case "upsertStaffMember":
     case "upsertVenue":
+    case "upsertEventCategory":
     case "upsertBookingMembershipProduct":
     case "seedBookingCustomer":
     case "upsertAppointmentService":
@@ -45541,6 +45751,21 @@ function commandRefContributions(command) {
         provides: [{ ref: command.ref, field: "ref" }],
         requires: collectOfferingRequires(command.input, command.input.occurrences, "input.occurrences")
       };
+    case "deleteVenue":
+      return {
+        provides: [],
+        requires: optionalRef(command.input.venueRef, "input.venueRef")
+      };
+    case "deleteEventCategory":
+      return {
+        provides: [],
+        requires: optionalRef(command.input.eventCategoryRef, "input.eventCategoryRef")
+      };
+    case "deleteEventSeries":
+      return {
+        provides: [],
+        requires: optionalRef(command.input.eventRef, "input.eventRef")
+      };
     case "upsertEventTicketType":
       return {
         provides: [{ ref: command.ref, field: "ref" }],
@@ -45551,6 +45776,11 @@ function commandRefContributions(command) {
         provides: [{ ref: command.ref, field: "ref" }],
         requires: collectOfferingRequires(command.input, command.input.sessions, "input.sessions")
       };
+    case "deleteCourse":
+      return {
+        provides: [],
+        requires: optionalRef(command.input.courseRef, "input.courseRef")
+      };
     case "ensureTeamMemberProfile":
       return {
         provides: [{ ref: command.ref, field: "ref" }],
@@ -45596,7 +45826,11 @@ function commandRefContributions(command) {
     case "reorderPageBlocks":
       return {
         provides: [{ ref: command.ref, field: "ref" }],
-        requires: command.input.pageRef ? [{ ref: command.input.pageRef, field: "input.pageRef" }] : []
+        requires: command.input.pageRef ? [{ ref: command.input.pageRef, field: "input.pageRef" }] : [],
+        requiresIfProvided: command.input.blocks.map((block, index) => ({
+          ref: block.blockRef,
+          field: `input.blocks[${index}].blockRef`
+        }))
       };
     case "upsertContentEntry":
       return {
@@ -45659,6 +45893,8 @@ function portalOrderSubjectRefContribution(subject) {
 function collectOfferingRequires(input, intervals, intervalPath) {
   return [
     ...optionalRef(input.venueRef, "input.venueRef"),
+    ...optionalRef(input.categoryRef, "input.categoryRef"),
+    ...optionalRef(input.formRef, "input.formRef"),
     ...(input.content?.mediaRefs ?? []).map((ref, index) => ({
       ref,
       field: `input.content.mediaRefs[${index}]`
@@ -45888,12 +46124,22 @@ function matchSiteCommand(command, match) {
       return match(command);
     case "upsertVenue":
       return match(command);
+    case "deleteVenue":
+      return match(command);
+    case "upsertEventCategory":
+      return match(command);
+    case "deleteEventCategory":
+      return match(command);
     case "upsertEventSeries":
       return match(command);
+    case "deleteEventSeries":
+      return match(command);
     case "upsertEventTicketType":
       return match(command);
     case "upsertCourse":
       return match(command);
+    case "deleteCourse":
+      return match(command);
     case "upsertBookingPassProduct":
       return match(command);
     case "upsertBookingMembershipProduct":
@@ -45938,11 +46184,11 @@ function parseAndPlanCommandBatchForTypes(input, allowedTypes) {
 }
 function narrowSiteCommandPlan(plan, allowedTypes) {
   const allowedTypeSet = new Set(allowedTypes);
-  const unsupported = plan.commands.filter(
+  const unsupported2 = plan.commands.filter(
     (plannedCommand) => !allowedTypeSet.has(plannedCommand.command.type)
   );
-  if (unsupported.length > 0) {
-    return err(unsupported.map(({ command }) => ({
+  if (unsupported2.length > 0) {
+    return err(unsupported2.map(({ command }) => ({
       code: "unsupported_command_type_for_plan",
       commandRef: command.ref,
       commandType: command.type,
@@ -46029,7 +46275,12 @@ function validateBatchRefs(batch) {
       contributions: contributions.requires,
       errors
     });
-    contributionsByCommand.set(command.ref, { provides, requires });
+    const requiresIfProvided = parseContributions({
+      commandRef: command.ref,
+      contributions: contributions.requiresIfProvided ?? [],
+      errors
+    });
+    contributionsByCommand.set(command.ref, { provides, requires, requiresIfProvided });
     requiresByCommand.set(command.ref, [...dedupeContributions(requires)]);
     for (const { ref } of provides) {
       const existing = providerByRef.get(ref);
@@ -46044,6 +46295,12 @@ function validateBatchRefs(batch) {
       }
     }
   }
+  addInBatchProvidedRefRequirements({
+    batch,
+    providerByRef,
+    contributionsByCommand,
+    requiresByCommand
+  });
   for (const [commandRef, requires] of requiresByCommand) {
     for (const { ref, field } of requires) {
       if (!providerByRef.has(ref)) {
@@ -46064,6 +46321,33 @@ function validateBatchRefs(batch) {
     requiresByCommand
   };
 }
+function addInBatchProvidedRefRequirements(input) {
+  for (const command of input.batch.commands) {
+    const contribution = input.contributionsByCommand.get(command.ref);
+    for (const softRequirement of contribution?.requiresIfProvided ?? []) {
+      addInBatchProvidedRefRequirement({
+        commandRef: command.ref,
+        requirement: softRequirement,
+        providerByRef: input.providerByRef,
+        contributionsByCommand: input.contributionsByCommand,
+        requiresByCommand: input.requiresByCommand
+      });
+    }
+  }
+}
+function addInBatchProvidedRefRequirement(input) {
+  if (!input.providerByRef.has(input.requirement.ref)) return;
+  const currentRequires = input.requiresByCommand.get(input.commandRef) ?? [];
+  const nextRequires = [...dedupeContributions([...currentRequires, input.requirement])];
+  input.requiresByCommand.set(input.commandRef, nextRequires);
+  const contribution = input.contributionsByCommand.get(input.commandRef);
+  if (contribution) {
+    input.contributionsByCommand.set(input.commandRef, {
+      ...contribution,
+      requires: nextRequires
+    });
+  }
+}
 function parseContributions(input) {
   return input.contributions.flatMap((contribution) => {
     const parsed = parseResourceRef(contribution.ref);
@@ -46162,14 +46446,14 @@ function checkTicketPricedEventsHaveTickets(indexes) {
 }
 function checkTicketQuantitiesWithinCapacity(indexes) {
   return indexes.events.flatMap((event) => {
-    const capacity = limitedCapacityQuantity(event.input.capacity);
-    if (capacity === void 0) return [];
+    const capacity2 = limitedCapacityQuantity(event.input.capacity);
+    if (capacity2 === void 0) return [];
     const ticketQuantityTotal = (indexes.ticketsByEventRef.get(event.ref) ?? []).reduce((total, ticket) => total + (ticket.input.quantity ?? 0), 0);
-    if (ticketQuantityTotal <= capacity) return [];
+    if (ticketQuantityTotal <= capacity2) return [];
     return [commandInvariantViolation(
       event.ref,
       "input.capacity",
-      `Event ticket quantities (${ticketQuantityTotal}) cannot exceed event capacity (${capacity}).`
+      `Event ticket quantities (${ticketQuantityTotal}) cannot exceed event capacity (${capacity2}).`
     )];
   });
 }
@@ -46198,8 +46482,8 @@ function checkTicketCurrencyMatchesEvent(indexes) {
     )];
   }));
 }
-function limitedCapacityQuantity(capacity) {
-  return capacity?.kind === "limited" ? capacity.quantity : void 0;
+function limitedCapacityQuantity(capacity2) {
+  return capacity2?.kind === "limited" ? capacity2.quantity : void 0;
 }
 function commandInvariantViolation(commandRef, field, message) {
   return {
@@ -46336,6 +46620,35 @@ function countRisks(risks) {
   };
 }
 
+// ../site-commands/src/stableJson.ts
+init_src();
+function stableStringify(value) {
+  const sorted = sortValue(value);
+  switch (typeof sorted) {
+    case "bigint":
+    case "function":
+    case "symbol":
+    case "undefined":
+      return String(sorted);
+    case "boolean":
+    case "number":
+    case "object":
+    case "string":
+      return JSON.stringify(sorted);
+  }
+  return assertNever(sorted);
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value && typeof value === "object") return sortRecord(value);
+  return value;
+}
+function sortRecord(record) {
+  return Object.fromEntries(
+    Object.entries(record).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, sortValue(value)])
+  );
+}
+
 // src/cli/site-commands/commandRuntime.ts
 function createCliCommandBatchRef(input) {
   return [
@@ -46418,13 +46731,18 @@ async function executeCliCommandPlan(input) {
   return { status: "applied", applied };
 }
 function commandExecutionToReport(input) {
-  const appliedSubjects = [];
+  const outcomes = [];
   const warnings = [];
   const appliedRefs = new Set(input.execution.applied.map((command) => command.commandRef));
   for (const reportedCommand of input.reportedCommands) {
     const command = reportedCommand.plannedCommand.command;
     if (!appliedRefs.has(command.ref)) continue;
-    appliedSubjects.push(reportedCommand.reportSubject);
+    outcomes.push({
+      status: "applied",
+      commandRef: command.ref,
+      commandType: command.type,
+      subject: reportedCommand.reportSubject
+    });
   }
   if (input.execution.status === "failed") {
     const { failed } = input.execution;
@@ -46438,46 +46756,91 @@ function commandExecutionToReport(input) {
         `Stopped before applying ${skippedCount} remaining ${input.resourceLabel} command${skippedCount === 1 ? "" : "s"}.`
       );
     }
-    return {
-      appliedSubjects,
-      failure: {
-        identifier: failedCommand ? input.commandDisplayIdentifier(failedCommand) : String(failed.commandRef),
-        message: failed.message,
-        ...input.includeFailureSubject && failedIndex >= 0 ? { subject: input.reportedCommands[failedIndex]?.reportSubject } : {}
-      },
-      warnings
-    };
+    const failedSubject = failedIndex >= 0 ? input.reportedCommands[failedIndex]?.reportSubject : void 0;
+    outcomes.push({
+      status: "failed",
+      commandRef: failed.commandRef,
+      commandType: failed.commandType,
+      identifier: failedCommand ? input.commandDisplayIdentifier(failedCommand) : String(failed.commandRef),
+      message: failed.message,
+      ...input.includeFailureSubject && failedSubject ? { subject: failedSubject } : {}
+    });
+    for (const skippedCommand of failedIndex >= 0 ? input.reportedCommands.slice(failedIndex + 1) : []) {
+      outcomes.push({
+        status: "skipped_by_stop_policy",
+        commandRef: skippedCommand.plannedCommand.command.ref,
+        commandType: skippedCommand.plannedCommand.command.type,
+        identifier: input.commandDisplayIdentifier(skippedCommand.plannedCommand.command),
+        subject: skippedCommand.reportSubject
+      });
+    }
   }
-  return {
-    appliedSubjects,
-    failure: null,
-    warnings
-  };
+  return reportFromOutcomes({ outcomes, warnings });
 }
-function commandReportToSyncResult(input) {
-  const result = createEmptySyncResult();
-  for (const subject of input.report.appliedSubjects) {
-    input.incrementSuccess(result, subject);
-  }
-  if (input.report.failure) {
-    input.recordFailure(
-      result,
-      input.report.failure.identifier,
-      input.report.failure.message,
-      input.report.failure.subject
-    );
-  }
-  result.warnings.push(...input.report.warnings);
-  return result;
+function commandCompileFailureToReport(input) {
+  return reportFromOutcomes({
+    outcomes: [{
+      status: "compile_failed",
+      identifier: input.identifier,
+      message: input.message,
+      ...input.subject ? { subject: input.subject } : {}
+    }],
+    warnings: input.warnings ?? []
+  });
 }
-async function executeCompiledCliCommandPlanAsSyncResult(input) {
+async function executeCompiledCliCommandPlanAsReport(input) {
   input.onBeforeExecute?.(input.compiledPlan.plan.commands.length);
   const execution = await input.executePlan(input.compiledPlan.plan);
-  return input.executionToSyncResult({
+  return input.executionToReport({
     execution,
     compiledPlan: input.compiledPlan
   });
 }
+function reportFromOutcomes(input) {
+  const appliedSubjects = input.outcomes.flatMap(appliedSubjectFromOutcome);
+  const failureOutcome = input.outcomes.map(failureFromOutcome).find((failure) => failure !== null) ?? null;
+  return {
+    outcomes: input.outcomes,
+    appliedSubjects,
+    failure: failureOutcome ? {
+      identifier: failureOutcome.identifier,
+      message: failureOutcome.message,
+      ...failureOutcome.subject ? { subject: failureOutcome.subject } : {}
+    } : null,
+    warnings: input.warnings ?? []
+  };
+}
+function commandReportHasFailures(report) {
+  return report.outcomes.some((outcome) => failureFromOutcome(outcome) !== null);
+}
+function appliedSubjectFromOutcome(outcome) {
+  switch (outcome.status) {
+    case "applied":
+      return [outcome.subject];
+    case "failed":
+    case "skipped_by_stop_policy":
+    case "compile_failed":
+      return [];
+    default:
+      assertNever(outcome);
+  }
+}
+function failureFromOutcome(outcome) {
+  switch (outcome.status) {
+    case "failed":
+    case "compile_failed":
+      return {
+        identifier: outcome.identifier,
+        message: outcome.message,
+        ...outcome.subject ? { subject: outcome.subject } : {}
+      };
+    case "applied":
+    case "skipped_by_stop_policy":
+      return null;
+    default:
+      assertNever(outcome);
+  }
+}
 function appliedCommand(command) {
   return {
     commandRef: command.ref,
@@ -46491,6 +46854,553 @@ function reportSubjectForCommandRef(subjectsByCommandRef, commandRef) {
   throw new Error(`Internal command planning error: missing report subject for ${commandRef}.`);
 }
 
+// src/cli/site-commands/datedOfferingCommands.ts
+init_src();
+var datedOfferingSiteCommandTypes = [
+  "upsertVenue",
+  "deleteVenue",
+  "upsertEventCategory",
+  "deleteEventCategory",
+  "upsertEventSeries",
+  "deleteEventSeries",
+  "upsertCourse",
+  "deleteCourse"
+];
+function compileDatedOfferingPushCommands(input) {
+  const commandBindings = [];
+  for (const venue of input.venues?.items ?? []) {
+    const command = venueCommand(venue.item);
+    if (!command.ok) return command;
+    commandBindings.push(commandBinding(command.value, {
+      scopeCommand: "venues",
+      scopeName: "venues",
+      itemLabelSingular: "venue",
+      identifier: venue.item.slug,
+      counter: venue.exists ? "updated" : "created"
+    }));
+  }
+  for (const category of input.eventCategories?.items ?? []) {
+    commandBindings.push(commandBinding(eventCategoryCommand(category.item), {
+      scopeCommand: "event-categories",
+      scopeName: "event categories",
+      itemLabelSingular: "event category",
+      identifier: category.item.identifier,
+      counter: category.exists ? "updated" : "created"
+    }));
+  }
+  for (const event of input.events?.items ?? []) {
+    const command = eventSeriesCommand(event.item);
+    if (!command.ok) return command;
+    commandBindings.push(commandBinding(command.value, {
+      scopeCommand: "events",
+      scopeName: "events",
+      itemLabelSingular: "event",
+      identifier: event.item.identifier,
+      counter: event.exists ? "updated" : "created"
+    }));
+  }
+  for (const course of input.courses?.items ?? []) {
+    const command = courseCommand(course.item);
+    if (!command.ok) return command;
+    commandBindings.push(commandBinding(command.value, {
+      scopeCommand: "courses",
+      scopeName: "courses",
+      itemLabelSingular: "course",
+      identifier: course.item.identifier,
+      counter: course.exists ? "updated" : "created"
+    }));
+  }
+  for (const identifier of input.delete?.events ?? []) {
+    commandBindings.push(commandBinding({
+      type: "deleteEventSeries",
+      ref: createCommandRef("delete-event", [identifier]),
+      input: { identifier }
+    }, deleteSubject("events", "events", "event", identifier)));
+  }
+  for (const identifier of input.delete?.courses ?? []) {
+    commandBindings.push(commandBinding({
+      type: "deleteCourse",
+      ref: createCommandRef("delete-course", [identifier]),
+      input: { identifier }
+    }, deleteSubject("courses", "courses", "course", identifier)));
+  }
+  for (const slug of input.delete?.venues ?? []) {
+    commandBindings.push(commandBinding({
+      type: "deleteVenue",
+      ref: createCommandRef("delete-venue", [slug]),
+      input: { slug }
+    }, deleteSubject("venues", "venues", "venue", slug)));
+  }
+  for (const identifier of input.delete?.eventCategories ?? []) {
+    commandBindings.push(commandBinding({
+      type: "deleteEventCategory",
+      ref: createCommandRef("delete-event-category", [identifier]),
+      input: { identifier }
+    }, deleteSubject("event-categories", "event categories", "event category", identifier)));
+  }
+  const planned = planCliCommandBatchForBindings({
+    ...input,
+    commandTypes: datedOfferingSiteCommandTypes,
+    commandBindings
+  });
+  return planned.ok ? ok(planned.value) : err(planned.error);
+}
+async function executeDatedOfferingCommandPlanAsPushScopeResult(input) {
+  const result = {
+    status: "pushed",
+    scopeCommand: input.scopeCommand,
+    scopeName: input.scopeName,
+    created: 0,
+    updated: 0,
+    deleted: 0,
+    failed: 0,
+    errors: []
+  };
+  for (const reportedCommand of input.compiledPlan.reportedCommands) {
+    const command = reportedCommand.plannedCommand.command;
+    try {
+      await applyDatedOfferingCommand(input.client, command);
+      increment(result, reportedCommand.reportSubject.counter);
+    } catch (error) {
+      result.failed++;
+      result.errors.push({
+        identifier: reportedCommand.reportSubject.identifier,
+        error: formatManagementError(error)
+      });
+    }
+  }
+  if (result.failed > 0 && result.created === 0 && result.updated === 0 && result.deleted === 0) {
+    result.status = "failed";
+  }
+  return result;
+}
+function syncResultForDatedOfferingCommandCompileError(error, scopeCommand, scopeName) {
+  const identifier = error.code === "command_validation_failed" ? "command-validation" : error.identifier;
+  return {
+    status: "failed",
+    scopeCommand,
+    scopeName,
+    created: 0,
+    updated: 0,
+    deleted: 0,
+    failed: 1,
+    errors: [{ identifier, error: error.message }]
+  };
+}
+function commandBinding(command, reportSubject2) {
+  return { command, reportSubject: reportSubject2 };
+}
+function deleteSubject(scopeCommand, scopeName, itemLabelSingular, identifier) {
+  return {
+    scopeCommand,
+    scopeName,
+    itemLabelSingular,
+    identifier,
+    counter: "deleted"
+  };
+}
+function venueCommand(venue) {
+  if (!venue.timezone) {
+    return unsupported(venue.slug, `Venue ${venue.slug} is missing timezone; command-backed venue pushes require an IANA timezone.`);
+  }
+  if (venue.location && (typeof venue.location.lat !== "number" || typeof venue.location.lng !== "number")) {
+    return unsupported(venue.slug, `Venue ${venue.slug} has an incomplete location; command-backed venue pushes require both lat and lng.`);
+  }
+  const location2 = venue.location && typeof venue.location.lat === "number" && typeof venue.location.lng === "number" ? {
+    latitude: venue.location.lat,
+    longitude: venue.location.lng
+  } : void 0;
+  return ok({
+    type: "upsertVenue",
+    ref: createVenueRef([venue.slug]),
+    input: {
+      slug: venue.slug,
+      title: venue.title,
+      description: venue.description ?? void 0,
+      timezone: venue.timezone,
+      capacity: venue.capacity ?? void 0,
+      address: venue.address ? {
+        line1: venue.address.line1 ?? void 0,
+        line2: venue.address.line2 ?? void 0,
+        city: venue.address.city ?? void 0,
+        region: venue.address.region ?? void 0,
+        postalCode: venue.address.postcode ?? void 0,
+        country: venue.address.country ?? void 0
+      } : void 0,
+      location: location2,
+      mapEmbedUrl: venue.mapEmbed ?? void 0
+    }
+  });
+}
+function eventCategoryCommand(category) {
+  return {
+    type: "upsertEventCategory",
+    ref: createEventCategoryRef([category.identifier]),
+    input: {
+      identifier: category.identifier,
+      name: category.name,
+      description: category.description ?? null,
+      color: category.color ?? null,
+      sortOrder: category.sortOrder
+    }
+  };
+}
+function eventSeriesCommand(event) {
+  if (event.identifier !== event.slug) {
+    return unsupported(event.identifier, `Event identifier "${event.identifier}" must match slug "${event.slug}".`);
+  }
+  if (event.schedule?.recurrenceRule) {
+    return unsupported(event.identifier, `Event ${event.identifier} uses recurrenceRule; command-backed SDK pushes currently support one-off events only.`);
+  }
+  const occurrence = eventOccurrence(event);
+  if (!occurrence.ok) return occurrence;
+  const pricing = eventPricing(event);
+  if (!pricing.ok) return pricing;
+  return ok({
+    type: "upsertEventSeries",
+    ref: createEventSeriesRef([event.identifier]),
+    input: {
+      slug: event.slug,
+      title: event.title,
+      archetype: "custom",
+      status: event.status === "completed" ? void 0 : event.status,
+      visibility: offeringVisibility(event.visibility, event.status),
+      // SDK event files currently store date/time without an IANA timezone.
+      // Keep the legacy UTC interpretation until the file format can carry timezone explicitly.
+      timezone: "UTC",
+      venueIdentifier: event.venueRef ?? void 0,
+      categoryIdentifier: event.categoryRef ?? void 0,
+      formIdentifier: event.formRef ?? void 0,
+      capacity: capacity(event.capacity),
+      pricing: pricing.value,
+      priceDisplay: event.pricing?.priceDisplay ?? void 0,
+      acceptsPasses: event.pricing?.acceptsPasses,
+      acceptsMemberships: event.pricing?.acceptsMemberships,
+      occurrences: [occurrence.value],
+      content: event.content ? {
+        summary: event.content.summary ?? void 0,
+        body: event.content.body ?? void 0,
+        image: event.content.image ?? void 0
+      } : void 0,
+      settings: event.settings,
+      presentation: event.presentation,
+      tags: event.tags
+    }
+  });
+}
+function courseCommand(course) {
+  if (course.identifier !== course.slug) {
+    return unsupported(course.identifier, `Course identifier "${course.identifier}" must match slug "${course.slug}".`);
+  }
+  const pricing = coursePricing(course);
+  if (!pricing.ok) return pricing;
+  return ok({
+    type: "upsertCourse",
+    ref: createCourseRef([course.identifier]),
+    input: {
+      slug: course.slug,
+      title: course.title,
+      status: course.status === "completed" ? void 0 : course.status,
+      visibility: offeringVisibility(course.visibility, course.status),
+      // SDK course files currently store session timestamps only; keep UTC as
+      // the command-level timezone placeholder until local files carry timezone.
+      timezone: "UTC",
+      venueIdentifier: course.venueRef ?? void 0,
+      categoryIdentifier: course.categoryRef ?? void 0,
+      formIdentifier: course.formRef ?? void 0,
+      capacity: capacity(course.capacity),
+      enrollmentCapacity: course.enrollmentCapacity ?? void 0,
+      pricing: pricing.value,
+      acceptsMemberships: course.acceptsMemberships,
+      sessions: course.sessions.map((session) => ({
+        startAt: session.startsAt,
+        endAt: session.endsAt
+      })),
+      programRef: course.programRef ?? void 0,
+      program: course.program ?? void 0
+    }
+  });
+}
+function eventOccurrence(event) {
+  const startDate = event.schedule?.startDate;
+  if (!startDate) {
+    return unsupported(event.identifier, `Event ${event.identifier} is missing schedule.startDate; command-backed event pushes require a concrete occurrence.`);
+  }
+  const startTime = event.schedule?.defaultStartTime ?? "09:00:00";
+  const durationMinutes = event.schedule?.durationMinutes ?? 60;
+  const startAt = toUtcIso(startDate, startTime);
+  const endAt = new Date(Date.parse(startAt) + durationMinutes * 6e4).toISOString();
+  return ok({
+    startAt,
+    endAt
+  });
+}
+function eventPricing(event) {
+  const pricing = event.pricing;
+  if (!pricing?.requiresPayment) return ok({ kind: "free" });
+  const amount = pricing.priceAmount;
+  if (typeof amount !== "number" || amount < 0) {
+    return unsupported(event.identifier, `Event ${event.identifier} requires payment but has no valid priceAmount.`);
+  }
+  return ok({
+    kind: "fixed_price",
+    price: {
+      amountCents: amount,
+      currency: pricing.priceCurrency
+    }
+  });
+}
+function coursePricing(course) {
+  const amount = course.priceCents;
+  if (amount === void 0 || amount === null || amount === 0) return ok({ kind: "free" });
+  if (amount < 0) {
+    return unsupported(course.identifier, `Course ${course.identifier} has invalid priceCents.`);
+  }
+  return ok({
+    kind: "fixed_price",
+    price: {
+      amountCents: amount,
+      currency: course.currency
+    }
+  });
+}
+function venueUpsertInput(command) {
+  return {
+    slug: command.input.slug,
+    title: command.input.title,
+    description: command.input.description ?? null,
+    timezone: command.input.timezone,
+    capacity: command.input.capacity ?? null,
+    address: command.input.address ? {
+      line1: command.input.address.line1,
+      line2: command.input.address.line2,
+      city: command.input.address.city,
+      region: command.input.address.region,
+      postcode: command.input.address.postalCode,
+      country: command.input.address.country
+    } : void 0,
+    location: command.input.location ? {
+      lat: command.input.location.latitude,
+      lng: command.input.location.longitude
+    } : null,
+    mapEmbed: command.input.mapEmbedUrl ?? null
+  };
+}
+function eventSeriesUpsertInput(command) {
+  const occurrence = command.input.occurrences[0];
+  if (!occurrence) throw new Error(`Event command ${command.ref} has no occurrence.`);
+  return {
+    identifier: command.input.slug,
+    title: command.input.title,
+    slug: command.input.slug,
+    status: command.input.status,
+    visibility: managementVisibility(command.input.visibility),
+    schedule: scheduleFromOccurrence(occurrence),
+    capacity: capacityLimit(command.input.capacity),
+    pricing: eventPricingInput(command.input),
+    venueRef: command.input.venueIdentifier ?? (command.input.venueRef ? refSlug(command.input.venueRef) : null),
+    categoryRef: command.input.categoryIdentifier ?? (command.input.categoryRef ? refSlug(command.input.categoryRef) : null),
+    content: eventContentInput(command.input.content),
+    formRef: command.input.formIdentifier ?? (command.input.formRef ? refSlug(command.input.formRef) : null),
+    settings: command.input.settings,
+    presentation: command.input.presentation,
+    tags: command.input.tags ? [...command.input.tags] : void 0
+  };
+}
+function eventContentInput(content) {
+  if (!content) return void 0;
+  return {
+    ...content.summary ? { summary: content.summary } : {},
+    ...typeof content.body === "string" || isRecord11(content.body) ? { body: content.body } : {},
+    ...typeof content.image === "string" || isRecord11(content.image) ? { image: content.image } : {}
+  };
+}
+function courseUpsertInput(command) {
+  return {
+    identifier: command.input.slug,
+    title: command.input.title,
+    slug: command.input.slug,
+    status: command.input.status,
+    visibility: managementVisibility(command.input.visibility),
+    venueRef: command.input.venueIdentifier ?? (command.input.venueRef ? refSlug(command.input.venueRef) : null),
+    categoryRef: command.input.categoryIdentifier ?? (command.input.categoryRef ? refSlug(command.input.categoryRef) : null),
+    formRef: command.input.formIdentifier ?? (command.input.formRef ? refSlug(command.input.formRef) : null),
+    capacity: capacityLimit(command.input.capacity),
+    enrollmentCapacity: command.input.enrollmentCapacity ?? null,
+    acceptsMemberships: command.input.acceptsMemberships ?? false,
+    ...coursePricingInput(command.input.pricing),
+    sessions: command.input.sessions.map((session) => ({
+      startsAt: session.startAt,
+      endsAt: session.endAt
+    })),
+    programRef: command.input.programRef ?? null,
+    program: command.input.program ? {
+      identifier: command.input.program.identifier ?? null,
+      data: command.input.program.data
+    } : null
+  };
+}
+function eventPricingInput(input) {
+  switch (input.pricing.kind) {
+    case "free":
+      return {
+        requiresPayment: false,
+        priceAmount: null,
+        priceCurrency: null,
+        priceDisplay: input.priceDisplay ?? null,
+        acceptsPasses: input.acceptsPasses ?? false,
+        acceptsMemberships: input.acceptsMemberships ?? false
+      };
+    case "fixed_price":
+      return {
+        requiresPayment: input.pricing.price.amountCents > 0,
+        priceAmount: input.pricing.price.amountCents,
+        priceCurrency: input.pricing.price.currency ?? null,
+        priceDisplay: input.priceDisplay ?? null,
+        acceptsPasses: input.acceptsPasses ?? false,
+        acceptsMemberships: input.acceptsMemberships ?? false
+      };
+    case "ticket_types":
+      return {
+        requiresPayment: false,
+        priceAmount: null,
+        priceCurrency: input.pricing.currency ?? null,
+        priceDisplay: input.priceDisplay ?? null,
+        acceptsPasses: input.acceptsPasses ?? false,
+        acceptsMemberships: input.acceptsMemberships ?? false
+      };
+    case "manual_payment":
+    case "external":
+      throw new Error(`Unsupported event pricing mode reached SDK mapper: ${input.pricing.kind}`);
+    default:
+      return assertNever(input.pricing);
+  }
+}
+function coursePricingInput(pricing) {
+  switch (pricing.kind) {
+    case "free":
+      return { priceCents: null };
+    case "fixed_price":
+      return {
+        priceCents: pricing.price.amountCents,
+        ...pricing.price.currency ? { currency: pricing.price.currency } : {}
+      };
+    case "manual_payment":
+    case "external":
+      throw new Error(`Unsupported course pricing mode reached SDK mapper: ${pricing.kind}`);
+    default:
+      return assertNever(pricing);
+  }
+}
+function increment(result, counter) {
+  switch (counter) {
+    case "created":
+      result.created++;
+      return;
+    case "updated":
+      result.updated++;
+      return;
+    case "deleted":
+      result.deleted++;
+      return;
+    default:
+      assertNever(counter);
+  }
+}
+async function applyDatedOfferingCommand(client, command) {
+  switch (command.type) {
+    case "upsertVenue":
+      await client.venues.upsert(venueUpsertInput(command));
+      return;
+    case "deleteVenue":
+      await client.venues.delete(command.input.slug);
+      return;
+    case "upsertEventCategory":
+      await client.eventCategories.upsert({
+        identifier: command.input.identifier ?? refSlug(command.ref),
+        name: command.input.name,
+        description: command.input.description ?? null,
+        color: command.input.color ?? null,
+        sortOrder: command.input.sortOrder
+      });
+      return;
+    case "deleteEventCategory":
+      await client.eventCategories.delete(command.input.identifier);
+      return;
+    case "upsertEventSeries":
+      await client.events.upsert(eventSeriesUpsertInput(command));
+      return;
+    case "deleteEventSeries":
+      await client.events.delete(command.input.identifier);
+      return;
+    case "upsertCourse":
+      try {
+        await client.courses.upsert(courseUpsertInput(command));
+      } catch (error) {
+        throw new Error(courseSessionConflictMessage(error));
+      }
+      return;
+    case "deleteCourse":
+      await client.courses.delete(command.input.identifier);
+      return;
+    default:
+      assertNever(command);
+  }
+}
+function capacity(value) {
+  return typeof value === "number" ? { kind: "limited", quantity: value } : { kind: "unlimited" };
+}
+function capacityLimit(value) {
+  return !value || value.kind === "unlimited" ? null : value.quantity;
+}
+function offeringVisibility(visibility, status) {
+  if (status === "draft") return "draft";
+  if (visibility === "unlisted") return "unlisted";
+  if (visibility === "private") return "draft";
+  return "listed";
+}
+function managementVisibility(visibility) {
+  switch (visibility) {
+    case "draft":
+      return "private";
+    case "unlisted":
+      return "unlisted";
+    case "listed":
+    case "published":
+      return "public";
+    default:
+      return assertNever(visibility);
+  }
+}
+function scheduleFromOccurrence(occurrence) {
+  return {
+    recurrenceRule: null,
+    startDate: occurrence.startAt.slice(0, 10),
+    defaultStartTime: occurrence.startAt.slice(11, 19),
+    durationMinutes: Math.round((Date.parse(occurrence.endAt) - Date.parse(occurrence.startAt)) / 6e4)
+  };
+}
+function toUtcIso(date, time) {
+  const normalizedTime = time.length === 5 ? `${time}:00` : time;
+  return (/* @__PURE__ */ new Date(`${date}T${normalizedTime}Z`)).toISOString();
+}
+function isRecord11(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function unsupported(identifier, message) {
+  return err({
+    code: "unsupported_local_shape",
+    identifier,
+    message
+  });
+}
+function courseSessionConflictMessage(error) {
+  if (!(error instanceof CourseSessionConflictError)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  return error.conflicts.map((conflict) => conflict.message).join("; ") || error.message;
+}
+
 // src/cli/site-commands/entryCommands.ts
 init_src();
 
@@ -46502,6 +47412,43 @@ var asCliBlockIdentifier = (value) => value;
 var asCliFormSlug = (value) => value;
 var asCliNavigationMenuName = (value) => value;
 
+// src/cli/site-commands/commandRuntimeCompat.ts
+init_src();
+function commandReportToSyncResult(input) {
+  const result = createEmptySyncResult();
+  for (const outcome of input.report.outcomes) {
+    switch (outcome.status) {
+      case "applied":
+        input.incrementSuccess(result, outcome.subject);
+        break;
+      case "failed":
+      case "compile_failed":
+        input.recordFailure(
+          result,
+          outcome.identifier,
+          outcome.message,
+          outcome.subject
+        );
+        break;
+      case "skipped_by_stop_policy":
+        break;
+      default:
+        assertNever(outcome);
+    }
+  }
+  result.warnings.push(...input.report.warnings);
+  return result;
+}
+async function executeCompiledCliCommandPlanAsSyncResult(input) {
+  const report = await executeCompiledCliCommandPlanAsReport({
+    compiledPlan: input.compiledPlan,
+    onBeforeExecute: input.onBeforeExecute,
+    executePlan: input.executePlan,
+    executionToReport: input.executionToReport
+  });
+  return input.reportToSyncResult(report);
+}
+
 // src/cli/site-commands/entryCommands.ts
 var entrySiteCommandTypes = [
   "upsertContentEntry",
@@ -46587,20 +47534,29 @@ async function executeEntryCommandPlanAsSyncResult(input) {
       client: input.client,
       plan
     }),
-    executionToSyncResult: entryCommandExecutionToSyncResult
+    executionToReport: entryCommandExecutionToReport,
+    reportToSyncResult: entryCommandReportToSyncResult
+  });
+}
+function executeEntryCommandPlanAsReport(input) {
+  return executeCompiledCliCommandPlanAsReport({
+    compiledPlan: input.compiledPlan,
+    onBeforeExecute: input.onBeforeExecute,
+    executePlan: (plan) => executeEntryCommandPlan({
+      client: input.client,
+      plan
+    }),
+    executionToReport: entryCommandExecutionToReport
   });
 }
 function syncResultForEntryCommandCompileError(error) {
-  const result = createEmptySyncResult();
-  recordEntryFailure(
-    result,
-    error.code === "missing_local_entry" ? `${error.contentType}/${error.identifier}` : "command-validation",
-    error.message
-  );
-  return result;
+  return entryCommandReportToSyncResult(entryCommandCompileErrorToReport(error));
 }
-function entryCommandExecutionToSyncResult(input) {
-  return entryCommandReportToSyncResult(entryCommandExecutionToReport(input));
+function entryCommandCompileErrorToReport(error) {
+  return commandCompileFailureToReport({
+    identifier: error.code === "missing_local_entry" ? `${error.contentType}/${error.identifier}` : "command-validation",
+    message: error.message
+  });
 }
 function entryCommandExecutionToReport(input) {
   return commandExecutionToReport({
@@ -46814,28 +47770,22 @@ async function executeFormCommandPlan(input) {
     }
   });
 }
-async function executeFormCommandPlanAsSyncResult(input) {
-  return executeCompiledCliCommandPlanAsSyncResult({
+function executeFormCommandPlanAsReport(input) {
+  return executeCompiledCliCommandPlanAsReport({
     compiledPlan: input.compiledPlan,
     onBeforeExecute: input.onBeforeExecute,
     executePlan: (plan) => executeFormCommandPlan({
       client: input.client,
       plan
     }),
-    executionToSyncResult: formCommandExecutionToSyncResult
+    executionToReport: formCommandExecutionToReport
   });
 }
-function syncResultForFormCommandCompileError(error) {
-  const result = createEmptySyncResult();
-  recordFormFailure(
-    result,
-    error.code === "missing_local_form" ? error.slug : "command-validation",
-    error.message
-  );
-  return result;
-}
-function formCommandExecutionToSyncResult(input) {
-  return formCommandReportToSyncResult(formCommandExecutionToReport(input));
+function formCommandCompileErrorToReport(error) {
+  return commandCompileFailureToReport({
+    identifier: error.code === "missing_local_form" ? error.slug : "command-validation",
+    message: error.message
+  });
 }
 function formCommandExecutionToReport(input) {
   return commandExecutionToReport({
@@ -46959,16 +47909,18 @@ async function executeFooterCommandPlanAsSyncResult(input) {
       client: input.client,
       plan
     }),
-    executionToSyncResult: footerCommandExecutionToSyncResult
+    executionToReport: footerCommandExecutionToReport,
+    reportToSyncResult: footerCommandReportToSyncResult
   });
 }
 function syncResultForFooterCommandCompileError(error) {
-  const result = createEmptySyncResult();
-  recordFooterFailure(result, "footer", error.message);
-  return result;
+  return footerCommandReportToSyncResult(footerCommandCompileErrorToReport(error));
 }
-function footerCommandExecutionToSyncResult(input) {
-  return footerCommandReportToSyncResult(footerCommandExecutionToReport(input));
+function footerCommandCompileErrorToReport(error) {
+  return commandCompileFailureToReport({
+    identifier: "footer",
+    message: error.message
+  });
 }
 function footerCommandExecutionToReport(input) {
   return commandExecutionToReport({
@@ -47071,28 +48023,22 @@ async function executeNavigationCommandPlan(input) {
     }
   });
 }
-async function executeNavigationCommandPlanAsSyncResult(input) {
-  return executeCompiledCliCommandPlanAsSyncResult({
+function executeNavigationCommandPlanAsReport(input) {
+  return executeCompiledCliCommandPlanAsReport({
     compiledPlan: input.compiledPlan,
     onBeforeExecute: input.onBeforeExecute,
     executePlan: (plan) => executeNavigationCommandPlan({
       client: input.client,
       plan
     }),
-    executionToSyncResult: navigationCommandExecutionToSyncResult
+    executionToReport: navigationCommandExecutionToReport
   });
 }
-function syncResultForNavigationCommandCompileError(error) {
-  const result = createEmptySyncResult();
-  recordNavigationFailure(
-    result,
-    error.code === "missing_local_navigation_menu" ? error.name : "command-validation",
-    error.message
-  );
-  return result;
-}
-function navigationCommandExecutionToSyncResult(input) {
-  return navigationCommandReportToSyncResult(navigationCommandExecutionToReport(input));
+function navigationCommandCompileErrorToReport(error) {
+  return commandCompileFailureToReport({
+    identifier: error.code === "missing_local_navigation_menu" ? error.name : "command-validation",
+    message: error.message
+  });
 }
 function navigationCommandExecutionToReport(input) {
   return commandExecutionToReport({
@@ -47394,39 +48340,34 @@ async function executePageCommandPlan(input) {
     }
   });
 }
-async function executePageCommandPlanAsSyncResult(input) {
-  const result = await executeCompiledCliCommandPlanAsSyncResult({
+async function executePageCommandPlanAsReport(input) {
+  const report = await executeCompiledCliCommandPlanAsReport({
     compiledPlan: input.compiledPlan,
     onBeforeExecute: input.onBeforeExecute,
     executePlan: (plan) => executePageCommandPlan({
       client: input.client,
       plan
     }),
-    executionToSyncResult: pageCommandExecutionToSyncResult
+    executionToReport: pageCommandExecutionToReport
   });
-  result.warnings.push(...input.compiledPlan.warnings);
-  return result;
+  return pageCommandReportWithWarnings(report, [
+    ...report.warnings,
+    ...input.compiledPlan.warnings
+  ]);
 }
-function syncResultForPageCommandCompileError(error) {
-  const result = createEmptySyncResult();
+function pageCommandCompileErrorToReport(error) {
   const identifier = error.code === "command_validation_failed" ? "command-validation" : error.identifier;
-  if (error.code === "missing_local_block" || error.code === "invalid_page_block") {
-    result.blocks.failed++;
-    result.errors.push({
+  return commandCompileFailureToReport({
+    identifier,
+    message: error.message,
+    subject: error.code === "missing_local_block" || error.code === "invalid_page_block" ? {
       resource: "block",
-      identifier,
-      error: error.message
-    });
-    if (error.code === "invalid_page_block") {
-      result.warnings.push(...error.warnings);
-    }
-    return result;
-  }
-  recordPageFailure(result, identifier, error.message);
-  return result;
-}
-function pageCommandExecutionToSyncResult(input) {
-  return pageCommandReportToSyncResult(pageCommandExecutionToReport(input));
+      pageIdentifier: pageIdentifierFromPageBlockIdentifier(identifier),
+      identifier: blockIdentifierFromPageBlockIdentifier(identifier),
+      counter: "updated"
+    } : void 0,
+    warnings: error.code === "invalid_page_block" ? error.warnings : []
+  });
 }
 function pageCommandExecutionToReport(input) {
   return commandExecutionToReport({
@@ -47444,6 +48385,12 @@ function pageCommandReportToSyncResult(report) {
     recordFailure: recordPageFailure
   });
 }
+function pageCommandReportWithWarnings(report, warnings) {
+  return reportFromOutcomes({
+    outcomes: report.outcomes,
+    warnings
+  });
+}
 function pageCommandsForDiff(input) {
   if (input.pageDiff.type === "unchanged" && !input.pageDiff.statusChange) {
     return ok(emptyPageCommandCompileFragment());
@@ -47747,49 +48694,107 @@ function blockReportSubject(input) {
 function pageBlockIdentifier(pageIdentifier, blockIdentifier) {
   return `${pageIdentifier}/${blockIdentifier}`;
 }
+function pageIdentifierFromPageBlockIdentifier(identifier) {
+  return asCliPageIdentifier(identifier.split("/")[0] ?? identifier);
+}
+function blockIdentifierFromPageBlockIdentifier(identifier) {
+  return asCliBlockIdentifier(identifier.split("/")[1] ?? identifier);
+}
 
 // src/cli/site-commands/pushExecution.ts
 init_src();
-var baselineResidualOmittedCommandSurfaces = ["navigation"];
-var baselineResidualOmittedCommandSurfaceSet = new Set(
-  baselineResidualOmittedCommandSurfaces
-);
-async function executeContentPushPlan(input) {
-  const executionPlan = planContentPushExecution({
-    pushScope: input.pushScope,
-    siteId: input.siteId,
-    target: input.target,
-    diff: input.diff,
-    local: input.local,
-    blockFieldExtensions: input.blockFieldExtensions
+
+// src/cli/site-commands/commandSurfaceDispatch.ts
+init_src();
+function compileContentPushExecutionPlan(plan, input, dependencies = {}) {
+  const steps = [];
+  for (const step of plan.steps) {
+    switch (step.kind) {
+      case "residual-settings-sync":
+        steps.push(step);
+        break;
+      case "command-surface": {
+        const compiled = commandSurfaceCompileSuccess(
+          (dependencies.compileCommandSurface ?? compileCommandSurface)(step.surface, input)
+        );
+        if (!compiled.ok) return err(compiled.error);
+        steps.push({
+          ...step,
+          surface: compiled.value
+        });
+        break;
+      }
+      default:
+        assertNever(step);
+    }
+  }
+  return ok({
+    kind: "compiled-sync-steps",
+    steps
   });
-  if (!executionPlan.ok) return executionPlan.error;
-  return executePushExecutionSteps(executionPlan.value.steps, input);
 }
-function planContentPushExecution(input) {
-  const directCommand = directCommandStepForPushScope(input);
-  if (directCommand) {
-    return directCommand.ok ? ok(syncPlanWithSteps([directCommand.value])) : err(directCommand.error);
-  }
-  switch (input.pushScope) {
-    case "pages": {
-      return ok(syncPlanWithResidualOnly(input));
-    }
-    case "all":
-      return pushAllExecutionPlan(input);
+async function executeCommandSurfaceAsReport(surface, input) {
+  switch (surface.surface) {
+    case "entry":
+      return {
+        surface: "entry",
+        report: await executeEntryCommandPlanAsReport({
+          client: input.client,
+          compiledPlan: surface.compileValue,
+          onBeforeExecute: input.onEntryCommandCount
+        })
+      };
+    case "page":
+      return {
+        surface: "page",
+        report: await executePageCommandPlanAsReport({
+          client: input.client,
+          compiledPlan: surface.compileValue,
+          onBeforeExecute: input.onPageCommandCount
+        })
+      };
+    case "form":
+      return {
+        surface: "form",
+        report: await executeFormCommandPlanAsReport({
+          client: input.client,
+          compiledPlan: surface.compileValue,
+          onBeforeExecute: input.onFormCommandCount
+        })
+      };
+    case "navigation":
+      return {
+        surface: "navigation",
+        report: await executeNavigationCommandPlanAsReport({
+          client: input.client,
+          compiledPlan: surface.compileValue,
+          onBeforeExecute: input.onNavigationCommandCount
+        })
+      };
     default:
-      return ok(syncPlanWithResidualOnly(input));
+      assertNever(surface);
   }
 }
-function directCommandStepForPushScope(input) {
-  const commandSurface = directCommandSurfaceForPushScope(input);
-  if (!commandSurface) return null;
-  const compiled = commandSurfaceCompileSuccess(commandSurface);
-  return compiled.ok ? ok(commandSurfaceStep(compiled.value, "continue")) : err(compiled.error);
+function skippedRemainingCommandReports(steps) {
+  return steps.flatMap((step) => step.kind === "command-surface" ? [skippedCommandSurfaceReport(step.surface)] : []);
 }
-function directCommandSurfaceForPushScope(input) {
-  switch (input.pushScope) {
-    case "entries":
+function commandSurfaceReportToSyncResult(report) {
+  switch (report.surface) {
+    case "entry":
+      return entryCommandReportToSyncResult(report.report);
+    case "page":
+      return pageCommandReportToSyncResult(report.report);
+    case "form":
+      return formCommandReportToSyncResult(report.report);
+    case "navigation":
+      return navigationCommandReportToSyncResult(report.report);
+    default:
+      assertNever(report);
+  }
+}
+function compileCommandSurface(surface, input) {
+  switch (surface) {
+    case "entry":
       return {
         surface: "entry",
         compileResult: compileEntryPushCommands({
@@ -47800,7 +48805,19 @@ function directCommandSurfaceForPushScope(input) {
           local: input.local
         })
       };
-    case "forms":
+    case "page":
+      return {
+        surface: "page",
+        compileResult: compilePagePushCommands({
+          source: "push_pages",
+          siteId: input.siteId,
+          targetEnv: input.target,
+          diff: input.diff,
+          local: input.local,
+          blockFieldExtensions: input.blockFieldExtensions
+        })
+      };
+    case "form":
       return {
         surface: "form",
         compileResult: compileFormPushCommands({
@@ -47822,249 +48839,152 @@ function directCommandSurfaceForPushScope(input) {
           local: input.local
         })
       };
-    case "pages":
-      return pageCommandRouting(input.diff).kind === "command_backed" ? {
-        surface: "page",
-        compileResult: compilePagePushCommands({
-          source: "push_pages",
-          siteId: input.siteId,
-          targetEnv: input.target,
-          diff: input.diff,
-          local: input.local,
-          blockFieldExtensions: input.blockFieldExtensions
-        })
-      } : null;
     default:
-      return null;
-  }
-}
-function pushAllExecutionPlan(input) {
-  const pageRouting = pageCommandRouting(input.diff);
-  const successfulSurfaces = [];
-  for (const surface of commandSurfacesForPushAll({ ...input, pageRouting })) {
-    const compiled = commandSurfaceCompileSuccess(surface);
-    if (!compiled.ok) return compiled;
-    successfulSurfaces.push(compiled.value);
-  }
-  const orderedSurfaces = orderCommandSurfacesForPushAll(successfulSurfaces);
-  const beforeResidualSteps = orderedSurfaces.beforeResidualSync.map(
-    (surface) => commandSurfaceStep(surface, "stop")
-  );
-  const residualPlan = residualSettingsPlan(input, successfulSurfaces);
-  const residualStep = residualPlan ? { kind: "residual-settings-sync", residual: residualPlan, onFailure: "continue" } : null;
-  const afterResidualSteps = orderedSurfaces.afterResidualSync.map(
-    (surface) => commandSurfaceStep(surface, "continue")
-  );
-  const steps = [
-    ...beforeResidualSteps,
-    ...residualStep ? [residualStep] : [],
-    ...afterResidualSteps
-  ];
-  return ok(syncPlanWithSteps(steps));
-}
-function syncPlanWithResidualOnly(input) {
-  return syncPlanWithSteps([{
-    kind: "residual-settings-sync",
-    onFailure: "continue",
-    residual: {
-      diff: withoutCommandSurfaceDiff(input.diff, baselineResidualOmittedCommandSurfaceSet),
-      local: withoutCommandSurfaceLocal(input.local, baselineResidualOmittedCommandSurfaceSet)
-    }
-  }]);
-}
-async function executePushExecutionSteps(steps, input) {
-  const results = [];
-  for (const step of steps) {
-    switch (step.kind) {
-      case "residual-settings-sync": {
-        const result = await executeResidualSettingsSync(input, step.residual);
-        results.push(result);
-        if (step.onFailure === "stop" && result.errors.length > 0) {
-          return mergeManySyncResults(results);
-        }
-        break;
-      }
-      case "command-surface": {
-        const result = await executeCommandSurfaceAsSyncResult(step.surface, input);
-        results.push(result);
-        if (step.onFailure === "stop" && result.errors.length > 0) {
-          return mergeManySyncResults(results);
-        }
-        break;
-      }
-      default:
-        assertNever(step);
-    }
-  }
-  return mergeManySyncResults(results);
-}
-function executeResidualSettingsSync(input, residual) {
-  return executeResidualSettingsSyncPlan(
-    input.client,
-    residual.diff,
-    residual.local,
-    {
-      dryRun: false
-    },
-    input.output
-  );
-}
-function commandSurfacesForPushAll(input) {
-  const surfaces = [];
-  if (hasEntryChanges(input.diff)) {
-    surfaces.push({
-      surface: "entry",
-      compileResult: compileEntryPushCommands({
-        source: "push_entries",
-        siteId: input.siteId,
-        targetEnv: input.target,
-        diff: input.diff,
-        local: input.local
-      })
-    });
-  }
-  if (input.pageRouting.kind === "command_backed") {
-    surfaces.push({
-      surface: "page",
-      compileResult: compilePagePushCommands({
-        source: "push_pages",
-        siteId: input.siteId,
-        targetEnv: input.target,
-        diff: input.diff,
-        local: input.local,
-        blockFieldExtensions: input.blockFieldExtensions
-      })
-    });
-  }
-  if (hasFormChanges(input.diff)) {
-    surfaces.push({
-      surface: "form",
-      compileResult: compileFormPushCommands({
-        source: "push_forms",
-        siteId: input.siteId,
-        targetEnv: input.target,
-        diff: input.diff,
-        local: input.local
-      })
-    });
-  }
-  if (hasNavigationChanges(input.diff)) {
-    surfaces.push({
-      surface: "navigation",
-      compileResult: compileNavigationPushCommands({
-        source: "push_navigation",
-        siteId: input.siteId,
-        targetEnv: input.target,
-        diff: input.diff.navigation,
-        local: input.local
-      })
-    });
+      assertNever(surface);
   }
-  return surfaces;
-}
-function commandSurfacesToOmitFromResidualSync(surfaces) {
-  return [
-    ...baselineResidualOmittedCommandSurfaces,
-    ...surfaces.map((surface) => surface.surface).filter((surface) => !baselineResidualOmittedCommandSurfaceSet.has(surface))
-  ];
-}
-function residualSettingsPlan(input, commandSurfaces) {
-  const residualSurfaces = commandSurfaceSet(commandSurfacesToOmitFromResidualSync(commandSurfaces));
-  const residual = {
-    diff: withoutCommandSurfaceDiff(input.diff, residualSurfaces),
-    local: withoutCommandSurfaceLocal(input.local, residualSurfaces)
-  };
-  return hasResidualSettingsChanges(residual.diff) ? residual : null;
-}
-function commandSurfaceStep(surface, onFailure) {
-  return { kind: "command-surface", surface, onFailure };
-}
-function syncPlanWithSteps(steps) {
-  return { kind: "sync-steps", steps };
 }
 function commandSurfaceCompileSuccess(surface) {
   switch (surface.surface) {
     case "entry":
-      return surface.compileResult.ok ? ok({ surface: "entry", compileValue: surface.compileResult.value }) : err(syncResultForEntryCommandCompileError(surface.compileResult.error));
+      return surface.compileResult.ok ? ok({ surface: "entry", compileValue: surface.compileResult.value }) : err(contentPushReportWithCommandReport({
+        surface: "entry",
+        report: entryCommandCompileErrorToReport(surface.compileResult.error)
+      }));
     case "page":
-      return surface.compileResult.ok ? ok({ surface: "page", compileValue: surface.compileResult.value }) : err(syncResultForPageCommandCompileError(surface.compileResult.error));
+      return surface.compileResult.ok ? ok({ surface: "page", compileValue: surface.compileResult.value }) : err(contentPushReportWithCommandReport({
+        surface: "page",
+        report: pageCommandCompileErrorToReport(surface.compileResult.error)
+      }));
     case "form":
-      return surface.compileResult.ok ? ok({ surface: "form", compileValue: surface.compileResult.value }) : err(syncResultForFormCommandCompileError(surface.compileResult.error));
+      return surface.compileResult.ok ? ok({ surface: "form", compileValue: surface.compileResult.value }) : err(contentPushReportWithCommandReport({
+        surface: "form",
+        report: formCommandCompileErrorToReport(surface.compileResult.error)
+      }));
     case "navigation":
-      return surface.compileResult.ok ? ok({ surface: "navigation", compileValue: surface.compileResult.value }) : err(syncResultForNavigationCommandCompileError(surface.compileResult.error));
+      return surface.compileResult.ok ? ok({ surface: "navigation", compileValue: surface.compileResult.value }) : err(contentPushReportWithCommandReport({
+        surface: "navigation",
+        report: navigationCommandCompileErrorToReport(surface.compileResult.error)
+      }));
     default:
       assertNever(surface);
   }
 }
-async function executeCommandSurfaceAsSyncResult(surface, input) {
+function contentPushReportWithCommandReport(commandReport) {
+  return {
+    commandReports: [commandReport],
+    residualSyncResults: []
+  };
+}
+function skippedCommandSurfaceReport(surface) {
   switch (surface.surface) {
-    case "entry": {
-      return executeEntryCommandPlanAsSyncResult({
-        client: input.client,
-        compiledPlan: surface.compileValue,
-        onBeforeExecute: input.onEntryCommandCount
-      });
-    }
-    case "page": {
-      return executePageCommandPlanAsSyncResult({
-        client: input.client,
-        compiledPlan: surface.compileValue,
-        onBeforeExecute: input.onPageCommandCount
-      });
-    }
-    case "form": {
-      return executeFormCommandPlanAsSyncResult({
-        client: input.client,
-        compiledPlan: surface.compileValue,
-        onBeforeExecute: input.onFormCommandCount
-      });
-    }
-    case "navigation": {
-      return executeNavigationCommandPlanAsSyncResult({
-        client: input.client,
-        compiledPlan: surface.compileValue,
-        onBeforeExecute: input.onNavigationCommandCount
-      });
-    }
+    case "entry":
+      return {
+        surface: "entry",
+        report: reportFromOutcomes({
+          outcomes: skippedOutcomes(
+            surface.compileValue.reportedCommands,
+            entrySkippedIdentifier
+          )
+        })
+      };
+    case "page":
+      return {
+        surface: "page",
+        report: reportFromOutcomes({
+          outcomes: skippedOutcomes(
+            surface.compileValue.reportedCommands,
+            pageSkippedIdentifier
+          ),
+          warnings: surface.compileValue.warnings
+        })
+      };
+    case "form":
+      return {
+        surface: "form",
+        report: reportFromOutcomes({
+          outcomes: skippedOutcomes(
+            surface.compileValue.reportedCommands,
+            formSkippedIdentifier
+          )
+        })
+      };
+    case "navigation":
+      return {
+        surface: "navigation",
+        report: reportFromOutcomes({
+          outcomes: skippedOutcomes(
+            surface.compileValue.reportedCommands,
+            navigationSkippedIdentifier
+          )
+        })
+      };
     default:
       assertNever(surface);
   }
 }
-function commandSurfaceSet(surfaces) {
-  return new Set(surfaces);
+function skippedOutcomes(reportedCommands, identifierForSubject) {
+  return reportedCommands.map((reportedCommand) => ({
+    status: "skipped_by_stop_policy",
+    commandRef: reportedCommand.plannedCommand.command.ref,
+    commandType: reportedCommand.plannedCommand.command.type,
+    identifier: identifierForSubject(reportedCommand.reportSubject),
+    subject: reportedCommand.reportSubject
+  }));
 }
-function hasNavigationChanges(diff) {
-  return diff.navigation.some((item) => item.type !== "unchanged");
+function entrySkippedIdentifier(subject) {
+  return `${subject.contentType}/${subject.identifier}`;
 }
-function hasEntryChanges(diff) {
-  for (const entryDiffs of diff.entries.values()) {
-    if (entryDiffs.some((item) => item.type !== "unchanged" || Boolean(item.statusChange))) {
-      return true;
-    }
+function pageSkippedIdentifier(subject) {
+  switch (subject.resource) {
+    case "page":
+      return subject.identifier;
+    case "block":
+      return `${subject.pageIdentifier}/${subject.identifier}`;
+    default:
+      assertNever(subject);
   }
-  return false;
 }
-function hasFormChanges(diff) {
-  return diff.forms.some((item) => item.type !== "unchanged");
+function formSkippedIdentifier(subject) {
+  return subject.slug;
 }
-function hasResidualSettingsChanges(diff) {
-  return diff.summary.settings.update > 0;
+function navigationSkippedIdentifier(subject) {
+  return subject.name;
 }
-function orderCommandSurfacesForPushAll(surfaces) {
+
+// src/cli/site-commands/pushExecutionPlan.ts
+init_src();
+
+// src/cli/site-commands/residualSettingsTrimming.ts
+var baselineResidualOmittedCommandSurfaces = ["navigation"];
+var baselineResidualOmittedCommandSurfaceSet = new Set(
+  baselineResidualOmittedCommandSurfaces
+);
+function syncPlanResidual(input) {
   return {
-    beforeResidualSync: surfaces.filter((surface) => surface.surface === "entry"),
-    afterResidualSync: surfaces.filter((surface) => surface.surface !== "entry")
+    diff: withoutCommandSurfaceDiff(input.diff, input.omitSurfaces),
+    local: withoutCommandSurfaceLocal(input.local, input.omitSurfaces)
   };
 }
-function withoutNavigationDiff(diff) {
-  return {
-    ...diff,
-    navigation: [],
-    summary: {
-      ...diff.summary,
-      navigation: { create: 0, update: 0, unchanged: 0 }
-    }
-  };
+function residualSettingsPlan(input) {
+  const residualSurfaces = commandSurfaceSet(commandSurfacesToOmitFromResidualSync(input.commandSurfaces));
+  const residual = syncPlanResidual({
+    diff: input.diff,
+    local: input.local,
+    omitSurfaces: residualSurfaces
+  });
+  return hasResidualSettingsChanges(residual.diff) ? residual : null;
+}
+function commandSurfacesToOmitFromResidualSync(surfaces) {
+  return [
+    ...baselineResidualOmittedCommandSurfaces,
+    ...surfaces.filter((surface) => !baselineResidualOmittedCommandSurfaceSet.has(surface))
+  ];
+}
+function commandSurfaceSet(surfaces) {
+  return new Set(surfaces);
+}
+function hasResidualSettingsChanges(diff) {
+  return diff.summary.settings.update > 0;
 }
 function withoutCommandSurfaceDiff(diff, surfaces) {
   let next = diff;
@@ -48105,6 +49025,16 @@ function withoutFormsDiff(diff) {
     }
   };
 }
+function withoutNavigationDiff(diff) {
+  return {
+    ...diff,
+    navigation: [],
+    summary: {
+      ...diff.summary,
+      navigation: { create: 0, update: 0, unchanged: 0 }
+    }
+  };
+}
 function withoutCommandSurfaceLocal(local, surfaces) {
   return {
     ...local,
@@ -48117,58 +49047,157 @@ function withoutCommandSurfaceLocal(local, surfaces) {
 function emptyLocalEntries() {
   return /* @__PURE__ */ new Map();
 }
-function mergeManySyncResults(results) {
-  return results.reduce(
-    (merged, result) => mergeSyncResults(merged, result),
-    createEmptySyncResult()
+
+// src/cli/site-commands/pushExecutionPlan.ts
+function planContentPushExecution(input) {
+  switch (input.pushScope) {
+    case "entries":
+      return syncPlanWithSteps([commandSurfaceStep("entry", "continue")]);
+    case "forms":
+      return syncPlanWithSteps([commandSurfaceStep("form", "continue")]);
+    case "navigation":
+      return syncPlanWithSteps([commandSurfaceStep("navigation", "continue")]);
+    case "pages":
+      return pageCommandRouting(input.diff).kind === "command_backed" ? syncPlanWithSteps([commandSurfaceStep("page", "continue")]) : syncPlanWithResidualOnly(input);
+    case "all":
+      return pushAllExecutionPlan(input);
+    default:
+      assertNever(input.pushScope);
+  }
+}
+function pushAllExecutionPlan(input) {
+  const pageRouting = pageCommandRouting(input.diff);
+  const commandSurfaces = commandSurfacesForPushAll({ ...input, pageRouting });
+  const orderedSurfaces = orderCommandSurfacesForPushAll(commandSurfaces);
+  const beforeResidualSteps = orderedSurfaces.beforeResidualSync.map(
+    (surface) => commandSurfaceStep(surface, "stop")
   );
+  const residualPlan = residualSettingsPlan({
+    diff: input.diff,
+    local: input.local,
+    commandSurfaces
+  });
+  const residualStep = residualPlan ? { kind: "residual-settings-sync", residual: residualPlan, onFailure: "continue" } : null;
+  const afterResidualSteps = orderedSurfaces.afterResidualSync.map(
+    (surface) => commandSurfaceStep(surface, "continue")
+  );
+  return syncPlanWithSteps([
+    ...beforeResidualSteps,
+    ...residualStep ? [residualStep] : [],
+    ...afterResidualSteps
+  ]);
 }
-function mergeSyncResults(first, second) {
+function syncPlanWithResidualOnly(input) {
+  return syncPlanWithSteps([{
+    kind: "residual-settings-sync",
+    onFailure: "continue",
+    residual: syncPlanResidual({
+      diff: input.diff,
+      local: input.local,
+      omitSurfaces: baselineResidualOmittedCommandSurfaceSet
+    })
+  }]);
+}
+function commandSurfacesForPushAll(input) {
+  return [
+    ...hasEntryChanges(input.diff) ? ["entry"] : [],
+    ...input.pageRouting.kind === "command_backed" ? ["page"] : [],
+    ...hasFormChanges(input.diff) ? ["form"] : [],
+    ...hasNavigationChanges(input.diff) ? ["navigation"] : []
+  ];
+}
+function commandSurfaceStep(surface, onFailure) {
+  return { kind: "command-surface", surface, onFailure };
+}
+function syncPlanWithSteps(steps) {
+  return { kind: "sync-steps", steps };
+}
+function hasNavigationChanges(diff) {
+  return diff.navigation.some((item) => item.type !== "unchanged");
+}
+function hasEntryChanges(diff) {
+  for (const entryDiffs of diff.entries.values()) {
+    if (entryDiffs.some((item) => item.type !== "unchanged" || Boolean(item.statusChange))) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasFormChanges(diff) {
+  return diff.forms.some((item) => item.type !== "unchanged");
+}
+function orderCommandSurfacesForPushAll(surfaces) {
   return {
-    entries: {
-      created: first.entries.created + second.entries.created,
-      updated: first.entries.updated + second.entries.updated,
-      deleted: first.entries.deleted + second.entries.deleted,
-      failed: first.entries.failed + second.entries.failed,
-      published: first.entries.published + second.entries.published,
-      unpublished: first.entries.unpublished + second.entries.unpublished
-    },
-    pages: {
-      created: first.pages.created + second.pages.created,
-      updated: first.pages.updated + second.pages.updated,
-      failed: first.pages.failed + second.pages.failed,
-      published: first.pages.published + second.pages.published,
-      unpublished: first.pages.unpublished + second.pages.unpublished
-    },
-    blocks: {
-      created: first.blocks.created + second.blocks.created,
-      updated: first.blocks.updated + second.blocks.updated,
-      deleted: first.blocks.deleted + second.blocks.deleted,
-      failed: first.blocks.failed + second.blocks.failed
-    },
-    navigation: {
-      created: first.navigation.created + second.navigation.created,
-      updated: first.navigation.updated + second.navigation.updated,
-      failed: first.navigation.failed + second.navigation.failed
-    },
-    settings: {
-      updated: first.settings.updated + second.settings.updated,
-      failed: first.settings.failed + second.settings.failed
-    },
-    forms: {
-      created: first.forms.created + second.forms.created,
-      updated: first.forms.updated + second.forms.updated,
-      failed: first.forms.failed + second.forms.failed
-    },
-    footer: {
-      updated: first.footer.updated + second.footer.updated,
-      failed: first.footer.failed + second.footer.failed
-    },
-    errors: [...first.errors, ...second.errors],
-    warnings: [...first.warnings, ...second.warnings]
+    beforeResidualSync: surfaces.filter((surface) => surface === "entry"),
+    afterResidualSync: surfaces.filter((surface) => surface !== "entry")
   };
 }
 
+// src/cli/site-commands/pushExecution.ts
+async function executeContentPushPlan(input) {
+  const report = await executeContentPushPlanAsCommandReport(input);
+  return contentPushExecutionReportToSyncResult(report);
+}
+async function executeContentPushPlanAsCommandReport(input, dependencies = {}) {
+  const executionPlan = planContentPushExecution({
+    pushScope: input.pushScope,
+    diff: input.diff,
+    local: input.local
+  });
+  const compiled = compileContentPushExecutionPlan(executionPlan, input, dependencies);
+  if (!compiled.ok) return compiled.error;
+  return executePushExecutionSteps(compiled.value.steps, input, dependencies);
+}
+async function executePushExecutionSteps(steps, input, dependencies) {
+  const commandReports = [];
+  const residualSyncResults = [];
+  for (const [index, step] of steps.entries()) {
+    switch (step.kind) {
+      case "residual-settings-sync": {
+        const result = await executeResidualSettingsSync(input, step.residual);
+        residualSyncResults.push(result);
+        if (step.onFailure === "stop" && result.errors.length > 0) {
+          commandReports.push(...skippedRemainingCommandReports(steps.slice(index + 1)));
+          return { commandReports, residualSyncResults };
+        }
+        break;
+      }
+      case "command-surface": {
+        const report = await (dependencies.executeCommandSurfaceAsReport ?? executeCommandSurfaceAsReport)(
+          step.surface,
+          input
+        );
+        commandReports.push(report);
+        if (step.onFailure === "stop" && commandReportHasFailures(report.report)) {
+          commandReports.push(...skippedRemainingCommandReports(steps.slice(index + 1)));
+          return { commandReports, residualSyncResults };
+        }
+        break;
+      }
+      default:
+        assertNever(step);
+    }
+  }
+  return { commandReports, residualSyncResults };
+}
+function executeResidualSettingsSync(input, residual) {
+  return executeResidualSettingsSyncPlan(
+    input.client,
+    residual.diff,
+    residual.local,
+    {
+      dryRun: false
+    },
+    input.output
+  );
+}
+function contentPushExecutionReportToSyncResult(report) {
+  return mergeManySyncResults([
+    ...report.commandReports.map(commandSurfaceReportToSyncResult),
+    ...report.residualSyncResults
+  ]);
+}
+
 // src/cli/commands/push/execute/footer.ts
 function footerPushDecision(diff, dryRun) {
   if (!diff) return { kind: "unchanged" };
@@ -48440,87 +49469,67 @@ ${errors}`
     output.error(message);
   }
 }
-async function pushScopeGeneric(ctx, config2) {
-  const { output, contentDir, dryRun, force, isJsonOutput, deleteOrphaned, autoPullStale, skipMeta, humanDiff } = ctx;
-  const {
-    scopeName,
-    itemLabelSingular,
-    scopeCommand,
-    getIdentifier,
-    getDisplayLabel,
-    shouldPushItem,
-    readLocal,
-    readMeta,
-    fetchRemote,
-    getRemoteUpdatedAt,
-    orphanDeletion,
-    findRemote,
-    checkExists,
-    pushItem,
-    updateLocalMeta
-  } = config2;
+async function pushCommandBackedDatedOfferingScope(ctx, config2) {
   const noopResult = {
     status: "noop",
-    scopeCommand,
-    scopeName,
+    scopeCommand: config2.scopeCommand,
+    scopeName: config2.scopeName,
     created: 0,
     updated: 0,
     deleted: 0,
     failed: 0,
     errors: []
   };
-  const allLocalItems = await readLocal(contentDir);
-  if (allLocalItems.length === 0 && !deleteOrphaned) {
-    output.warn(`No ${scopeName} found to push`);
+  const allLocalItems = await config2.readLocal(ctx.contentDir);
+  if (allLocalItems.length === 0 && !ctx.deleteOrphaned) {
+    ctx.output.warn(`No ${config2.scopeName} found to push`);
     return noopResult;
   }
-  const localItems = shouldPushItem ? allLocalItems.filter(shouldPushItem) : allLocalItems;
+  const localItems = config2.shouldPushItem ? allLocalItems.filter(config2.shouldPushItem) : allLocalItems;
   const skippedUnchanged = allLocalItems.length - localItems.length;
-  if (localItems.length === 0 && !deleteOrphaned) {
-    output.info(`No ${scopeName} changes to push`);
+  if (localItems.length === 0 && !ctx.deleteOrphaned) {
+    ctx.output.info(`No ${config2.scopeName} changes to push`);
     return noopResult;
   }
   let remoteItems = null;
-  if (!force && localItems.length > 0) {
-    const meta = await readMeta(contentDir);
+  if (!ctx.force && localItems.length > 0) {
+    const meta = await config2.readMeta(ctx.contentDir);
     if (meta) {
-      remoteItems = await fetchRemote();
+      remoteItems = await config2.fetchRemote();
       const staleItems = [];
       for (const localItem of localItems) {
-        const identifier = getIdentifier(localItem);
-        const remoteItem = findRemote(remoteItems, identifier);
+        const identifier = config2.getIdentifier(localItem);
+        const remoteItem = config2.findRemote(remoteItems, identifier);
         const localBaseTime = meta[identifier]?.updatedAt;
-        if (remoteItem && localBaseTime) {
-          const remoteTime = getRemoteUpdatedAt(remoteItem);
-          if (new Date(remoteTime) > new Date(localBaseTime)) {
-            staleItems.push(`${scopeName}: ${identifier} (Remote updated: ${remoteTime})`);
-          }
+        if (!remoteItem || !localBaseTime) continue;
+        const remoteTime = config2.getRemoteUpdatedAt(remoteItem);
+        if (new Date(remoteTime) > new Date(localBaseTime)) {
+          staleItems.push(`${config2.scopeName}: ${identifier} (Remote updated: ${remoteTime})`);
         }
       }
       if (staleItems.length > 0) {
-        output.warn("Stale content detected! Remote has newer changes:");
-        if (!isJsonOutput) {
+        ctx.output.warn("Stale content detected! Remote has newer changes:");
+        if (!ctx.isJsonOutput) {
           for (const item of staleItems) {
-            output.warn(`  - ${item}`);
+            ctx.output.warn(`  - ${item}`);
           }
         }
-        if (dryRun) {
-          output.warn("Continuing anyway (dry-run mode \u2014 no changes will be made).");
+        if (ctx.dryRun) {
+          ctx.output.warn("Continuing anyway (dry-run mode - no changes will be made).");
         } else {
           const resolution = await resolveStaleOrAbort({
-            autoPullStale,
+            autoPullStale: ctx.autoPullStale,
             yes: false
-            // scoped pushes don't use --yes for stale; they use it for remote
           });
           if (resolution === "abort") {
-            output.warn(
+            ctx.output.warn(
               `
-Run "riverbankcms pull ${scopeCommand}" first to get latest, or use --force to overwrite.`
+Run "riverbankcms pull ${config2.scopeCommand}" first to get latest, or use --force to overwrite.`
             );
             return {
               status: "aborted",
-              scopeCommand,
-              scopeName,
+              scopeCommand: config2.scopeCommand,
+              scopeName: config2.scopeName,
               created: 0,
               updated: 0,
               deleted: 0,
@@ -48528,67 +49537,64 @@ Run "riverbankcms pull ${scopeCommand}" first to get latest, or use --force to o
               errors: []
             };
           }
-          output.info("Stale content acknowledged. Continuing push...");
+          ctx.output.info("Stale content acknowledged. Continuing push...");
         }
       }
     }
   }
-  let orphanIdentifiers = [];
-  if (deleteOrphaned && orphanDeletion && !shouldPushItem) {
-    if (!remoteItems) {
-      remoteItems = await fetchRemote();
-    }
-    const localIdentifierSet = new Set(allLocalItems.map(getIdentifier));
-    orphanIdentifiers = remoteItems.map(orphanDeletion.getRemoteIdentifier).filter((id) => !localIdentifierSet.has(id));
+  if (!remoteItems && (localItems.length > 0 || ctx.deleteOrphaned)) {
+    remoteItems = await config2.fetchRemote();
   }
-  if (dryRun) {
+  const allLocalIdentifierSet = new Set(allLocalItems.map(config2.getIdentifier));
+  const orphanIdentifiers = ctx.deleteOrphaned && !config2.shouldPushItem && remoteItems ? remoteItems.map(config2.getRemoteIdentifier).filter((identifier) => !allLocalIdentifierSet.has(identifier)) : [];
+  if (ctx.dryRun) {
     if (localItems.length > 0) {
-      output.info(`[DRY RUN] Would push ${localItems.length} ${scopeName}`);
+      ctx.output.info(`[DRY RUN] Would push ${localItems.length} ${config2.scopeName}`);
       if (skippedUnchanged > 0) {
-        output.info(`  (skipping ${skippedUnchanged} unchanged)`);
+        ctx.output.info(`  (skipping ${skippedUnchanged} unchanged)`);
       }
-      if (humanDiff && remoteItems) {
+      if (ctx.humanDiff && remoteItems) {
         for (const item of localItems) {
-          const identifier = getIdentifier(item);
-          const remoteItem = findRemote(remoteItems, identifier);
+          const identifier = config2.getIdentifier(item);
+          const remoteItem = config2.findRemote(remoteItems, identifier);
           if (!remoteItem) {
-            output.info(`  + ${identifier}: ${getDisplayLabel(item)} (new)`);
+            ctx.output.info(`  + ${identifier}: ${config2.getDisplayLabel(item)} (new)`);
+            continue;
+          }
+          const localObject = JSON.parse(JSON.stringify(item));
+          const remoteObject = JSON.parse(JSON.stringify(remoteItem));
+          delete remoteObject.createdAt;
+          delete remoteObject.updatedAt;
+          delete remoteObject.contentUpdatedAt;
+          if (equal(localObject, remoteObject)) {
+            ctx.output.info(`  = ${identifier}: ${config2.getDisplayLabel(item)} (unchanged)`);
           } else {
-            const localObj = JSON.parse(JSON.stringify(item));
-            const remoteObj = JSON.parse(JSON.stringify(remoteItem));
-            delete remoteObj.createdAt;
-            delete remoteObj.updatedAt;
-            delete remoteObj.contentUpdatedAt;
-            if (equal(localObj, remoteObj)) {
-              output.info(`  = ${identifier}: ${getDisplayLabel(item)} (unchanged)`);
-            } else {
-              output.info(`  ~ ${identifier}: ${getDisplayLabel(item)}`);
-              const changes = findChangedFieldsWithValues(localObj, remoteObj);
-              for (const fc of changes) {
-                output.info(`    ${fc.path}: ${formatValue(fc.before)} -> ${formatValue(fc.after)}`);
-              }
+            ctx.output.info(`  ~ ${identifier}: ${config2.getDisplayLabel(item)}`);
+            const changes = findChangedFieldsWithValues(localObject, remoteObject);
+            for (const change of changes) {
+              ctx.output.info(`    ${change.path}: ${formatValue(change.before)} -> ${formatValue(change.after)}`);
             }
           }
         }
       } else {
         for (const item of localItems) {
-          output.info(`  - ${getIdentifier(item)}: ${getDisplayLabel(item)}`);
+          ctx.output.info(`  - ${config2.getIdentifier(item)}: ${config2.getDisplayLabel(item)}`);
         }
       }
     }
     if (orphanIdentifiers.length > 0) {
-      output.info(`[DRY RUN] Would delete ${orphanIdentifiers.length} orphaned ${scopeName}:`);
-      for (const id of orphanIdentifiers) {
-        output.info(`  - ${id}`);
+      ctx.output.info(`[DRY RUN] Would delete ${orphanIdentifiers.length} orphaned ${config2.scopeName}:`);
+      for (const identifier of orphanIdentifiers) {
+        ctx.output.info(`  - ${identifier}`);
       }
     }
     if (localItems.length > 0 || orphanIdentifiers.length > 0) {
-      output.info("\nUse --yes (for remote) or remove --dry-run (for local) to apply changes.");
+      ctx.output.info("\nUse --yes (for remote) or remove --dry-run (for local) to apply changes.");
     }
     return {
       status: "dry-run",
-      scopeCommand,
-      scopeName,
+      scopeCommand: config2.scopeCommand,
+      scopeName: config2.scopeName,
       created: 0,
       updated: 0,
       deleted: orphanIdentifiers.length,
@@ -48596,71 +49602,110 @@ Run "riverbankcms pull ${scopeCommand}" first to get latest, or use --force to o
       errors: []
     };
   }
-  let created = 0;
-  let updated = 0;
-  let deleted = 0;
-  let failed = 0;
-  const errors = [];
+  const upserts = localItems.map((item) => ({
+    item,
+    exists: Boolean(remoteItems?.some((remote) => config2.getRemoteIdentifier(remote) === config2.getIdentifier(item)))
+  }));
   if (localItems.length > 0) {
-    output.info(`Pushing ${localItems.length} ${scopeName}...`);
-    for (const item of localItems) {
-      const identifier = getIdentifier(item);
-      try {
-        const exists = await checkExists(identifier);
-        await pushItem(item);
-        if (exists) {
-          updated++;
-        } else {
-          created++;
-        }
-      } catch (error) {
-        failed++;
-        const message = error instanceof Error ? error.message : String(error);
-        errors.push({ identifier, error: message });
-        if (!isJsonOutput) {
-          output.warn(`  Failed to push ${itemLabelSingular} ${identifier}: ${message}`);
-        }
-      }
-    }
+    ctx.output.info(`Pushing ${localItems.length} ${config2.scopeName}...`);
   }
-  if (orphanIdentifiers.length > 0 && orphanDeletion) {
+  if (orphanIdentifiers.length > 0) {
     if (orphanIdentifiers.length > 5) {
-      output.warn(`Warning: ${orphanIdentifiers.length} ${scopeName} will be deleted from CMS`);
-    }
-    output.info(`Deleting ${orphanIdentifiers.length} orphaned ${scopeName}...`);
-    for (const id of orphanIdentifiers) {
-      try {
-        await orphanDeletion.deleteItem(id);
-        deleted++;
-      } catch (error) {
-        failed++;
-        const message = error instanceof Error ? error.message : String(error);
-        errors.push({ identifier: id, error: message });
-        if (!isJsonOutput) {
-          output.warn(`  Failed to delete ${itemLabelSingular} ${id}: ${message}`);
-        }
-      }
+      ctx.output.warn(`Warning: ${orphanIdentifiers.length} ${config2.scopeName} will be deleted from CMS`);
     }
+    ctx.output.info(`Deleting ${orphanIdentifiers.length} orphaned ${config2.scopeName}...`);
   }
-  if (failed === 0) {
-    await updateLocalMeta(contentDir, { skipMeta });
-  } else {
-    if (!isJsonOutput) {
-      output.warn(
-        `Not updating local files due to ${failed} failed ${scopeName} pushes. Run "riverbankcms pull ${scopeCommand}" to resync.`
+  const result = await executePlansResiliently({
+    ctx,
+    config: config2,
+    upserts,
+    orphanIdentifiers
+  });
+  if (result.failed === 0) {
+    await config2.updateLocalMeta(ctx.contentDir, { skipMeta: ctx.skipMeta });
+  } else if (!ctx.isJsonOutput) {
+    for (const itemError of result.errors) {
+      ctx.output.warn(
+        `  Failed to push ${config2.itemLabelSingular} ${itemError.identifier}: ${itemError.error}`
       );
     }
+    ctx.output.warn(
+      `Not updating local files due to ${result.failed} failed ${config2.scopeName} pushes. Run "riverbankcms pull ${config2.scopeCommand}" to resync.`
+    );
   }
-  return {
+  return result;
+}
+async function executePlansResiliently(input) {
+  const result = {
     status: "pushed",
-    scopeCommand,
-    scopeName,
-    created,
-    updated,
-    deleted,
-    failed,
-    errors
+    scopeCommand: input.config.scopeCommand,
+    scopeName: input.config.scopeName,
+    created: 0,
+    updated: 0,
+    deleted: 0,
+    failed: 0,
+    errors: []
   };
+  for (const upsert of input.upserts) {
+    const warning = input.config.readOnlyStatusWarning?.(upsert.item);
+    if (warning) input.ctx.output.warn(warning);
+    const partialResult = await compileAndExecutePartial({
+      ...input,
+      upserts: [upsert],
+      deletes: [],
+      fallbackIdentifier: input.config.getIdentifier(upsert.item)
+    });
+    mergePushScopeResult(result, partialResult);
+  }
+  for (const identifier of input.orphanIdentifiers) {
+    const partialResult = await compileAndExecutePartial({
+      ...input,
+      upserts: [],
+      deletes: [identifier],
+      fallbackIdentifier: identifier
+    });
+    mergePushScopeResult(result, partialResult);
+  }
+  if (result.failed > 0 && result.created === 0 && result.updated === 0 && result.deleted === 0) {
+    result.status = "failed";
+  }
+  return result;
+}
+async function compileAndExecutePartial(input) {
+  const compiled = compileDatedOfferingPushCommands(input.config.buildCompileInput({
+    source: input.config.source,
+    siteId: input.ctx.siteId,
+    targetEnv: input.ctx.targetEnv,
+    upserts: input.upserts,
+    deletes: input.deletes
+  }));
+  if (!compiled.ok) {
+    const compileResult = syncResultForDatedOfferingCommandCompileError(
+      compiled.error,
+      input.config.scopeCommand,
+      input.config.scopeName
+    );
+    return {
+      ...compileResult,
+      errors: compileResult.errors.map((itemError) => ({
+        identifier: itemError.identifier === "command-validation" ? input.fallbackIdentifier : itemError.identifier,
+        error: itemError.error
+      }))
+    };
+  }
+  return executeDatedOfferingCommandPlanAsPushScopeResult({
+    client: input.ctx.client,
+    compiledPlan: compiled.value,
+    scopeCommand: input.config.scopeCommand,
+    scopeName: input.config.scopeName
+  });
+}
+function mergePushScopeResult(target, source) {
+  target.created += source.created;
+  target.updated += source.updated;
+  target.deleted += source.deleted;
+  target.failed += source.failed;
+  target.errors.push(...source.errors);
 }
 
 // src/cli/commands/push/scopes/mediaPrep.ts
@@ -48698,9 +49743,6 @@ async function syncLocalMediaForScopePush(ctx, content) {
 }
 
 // src/cli/commands/push/scopes/courses.ts
-function preserveUndefined(value) {
-  return value === void 0 ? void 0 : value;
-}
 async function pushCoursesScope(ctx, options) {
   const { client } = ctx;
   const only = options?.only;
@@ -48722,7 +49764,8 @@ async function pushCoursesScope(ctx, options) {
       errors: []
     };
   }
-  return pushScopeGeneric(ctx, {
+  return pushCommandBackedDatedOfferingScope(ctx, {
+    source: "push_courses",
     scopeName: "courses",
     itemLabelSingular: "course",
     scopeCommand: "courses",
@@ -48740,63 +49783,19 @@ async function pushCoursesScope(ctx, options) {
     },
     getRemoteUpdatedAt: (course) => course.updatedAt,
     findRemote: (courses2, identifier) => courses2.find((course) => course.identifier === identifier),
-    checkExists: async (identifier) => {
-      const existing = await client.courses.get(identifier);
-      return existing !== null;
-    },
-    pushItem: async (course) => {
-      if (course.identifier !== course.slug) {
-        throw new Error(
-          `Course identifier "${course.identifier}" must match slug "${course.slug}".`
-        );
-      }
-      const program2 = course.program === void 0 ? void 0 : course.program === null ? null : {
-        identifier: preserveUndefined(course.program.identifier) ?? null,
-        data: course.program.data
-      };
-      try {
-        const status = preserveUndefined(
-          course.status === "completed" ? void 0 : course.status
-        );
-        if (course.status === "completed") {
-          ctx.output.warn(
-            `Course ${course.identifier}: status "completed" is read-only; omitting status on push.`
-          );
-        }
-        await client.courses.upsert({
-          identifier: course.identifier,
-          title: course.title,
-          slug: course.slug,
-          status,
-          visibility: preserveUndefined(course.visibility),
-          venueRef: preserveUndefined(course.venueRef),
-          categoryRef: preserveUndefined(course.categoryRef),
-          formRef: preserveUndefined(course.formRef),
-          capacity: preserveUndefined(course.capacity),
-          enrollmentCapacity: preserveUndefined(course.enrollmentCapacity),
-          acceptsMemberships: preserveUndefined(course.acceptsMemberships),
-          priceCents: preserveUndefined(course.priceCents),
-          currency: preserveUndefined(course.currency),
-          sessions: course.sessions,
-          programRef: preserveUndefined(course.programRef),
-          program: program2
-        });
-      } catch (error) {
-        if (error instanceof CourseSessionConflictError) {
-          const detail = error.conflicts.map((conflict) => conflict.message).join("; ");
-          throw new Error(detail || error.message);
-        }
-        throw error;
-      }
-    },
-    orphanDeletion: {
-      getRemoteIdentifier: (course) => course.identifier,
-      deleteItem: (identifier) => client.courses.delete(identifier)
-    },
+    getRemoteIdentifier: (course) => course.identifier,
     updateLocalMeta: async (dir, opts) => {
       const pulledCourses = await client.pull.courses();
       await writeCourses(dir, pulledCourses, opts);
-    }
+    },
+    readOnlyStatusWarning: (course) => course.status === "completed" ? `Course ${course.identifier}: status "completed" is read-only; omitting status on push.` : null,
+    buildCompileInput: ({ source, siteId, targetEnv, upserts, deletes }) => ({
+      source,
+      siteId,
+      targetEnv,
+      courses: { items: upserts },
+      delete: { courses: deletes }
+    })
   });
 }
 
@@ -48804,7 +49803,8 @@ async function pushCoursesScope(ctx, options) {
 async function pushEventCategoriesScope(ctx, options) {
   const { client } = ctx;
   const only = options?.only;
-  return pushScopeGeneric(ctx, {
+  return pushCommandBackedDatedOfferingScope(ctx, {
+    source: "push_event_categories",
     scopeName: "event categories",
     itemLabelSingular: "event category",
     scopeCommand: "event-categories",
@@ -48822,34 +49822,22 @@ async function pushEventCategoriesScope(ctx, options) {
     },
     getRemoteUpdatedAt: (category) => category.updatedAt,
     findRemote: (categories, identifier) => categories.find((c) => c.identifier === identifier),
-    checkExists: async (identifier) => {
-      const existing = await client.eventCategories.get(identifier);
-      return existing !== null;
-    },
-    pushItem: async (category) => {
-      await client.eventCategories.upsert({
-        identifier: category.identifier,
-        name: category.name,
-        description: category.description,
-        color: category.color,
-        sortOrder: category.sortOrder
-      });
-    },
-    orphanDeletion: {
-      getRemoteIdentifier: (category) => category.identifier,
-      deleteItem: (identifier) => client.eventCategories.delete(identifier)
-    },
+    getRemoteIdentifier: (category) => category.identifier,
     updateLocalMeta: async (dir, opts) => {
       const pulledCategories = await client.pull.eventCategories();
       await writeEventCategories(dir, pulledCategories, opts);
-    }
+    },
+    buildCompileInput: ({ source, siteId, targetEnv, upserts, deletes }) => ({
+      source,
+      siteId,
+      targetEnv,
+      eventCategories: { items: upserts },
+      delete: { eventCategories: deletes }
+    })
   });
 }
 
 // src/cli/commands/push/scopes/events.ts
-function preserveUndefined2(value) {
-  return value === void 0 ? void 0 : value;
-}
 async function pushEventsScope(ctx, options) {
   const { client } = ctx;
   const only = options?.only;
@@ -48871,7 +49859,8 @@ async function pushEventsScope(ctx, options) {
       errors: []
     };
   }
-  return pushScopeGeneric(ctx, {
+  return pushCommandBackedDatedOfferingScope(ctx, {
+    source: "push_events",
     scopeName: "events",
     itemLabelSingular: "event",
     scopeCommand: "events",
@@ -48895,61 +49884,19 @@ async function pushEventsScope(ctx, options) {
       return event.updatedAt;
     },
     findRemote: (events2, identifier) => events2.find((e) => e.identifier === identifier),
-    checkExists: async (identifier) => {
-      const existing = await client.events.get(identifier);
-      return existing !== null;
-    },
-    pushItem: async (event) => {
-      if (event.identifier !== event.slug) {
-        throw new Error(
-          `Event identifier "${event.identifier}" must match slug "${event.slug}".`
-        );
-      }
-      const schedule = {
-        recurrenceRule: event.schedule?.recurrenceRule ?? null,
-        startDate: event.schedule?.startDate ?? null,
-        defaultStartTime: event.schedule?.defaultStartTime ?? "09:00:00",
-        durationMinutes: event.schedule?.durationMinutes ?? 60
-      };
-      const content = event.content ? {
-        summary: event.content.summary ?? void 0,
-        body: event.content.body ?? void 0,
-        image: event.content.image ?? void 0
-      } : void 0;
-      const status = preserveUndefined2(
-        event.status === "completed" ? void 0 : event.status
-      );
-      if (event.status === "completed") {
-        ctx.output.warn(
-          `Event ${event.identifier}: status "completed" is read-only; omitting status on push.`
-        );
-      }
-      await client.events.upsert({
-        identifier: event.identifier,
-        title: event.title,
-        slug: event.slug,
-        status,
-        visibility: preserveUndefined2(event.visibility),
-        schedule,
-        capacity: preserveUndefined2(event.capacity),
-        pricing: event.pricing,
-        venueRef: preserveUndefined2(event.venueRef),
-        categoryRef: preserveUndefined2(event.categoryRef),
-        content,
-        formRef: preserveUndefined2(event.formRef),
-        settings: event.settings,
-        presentation: event.presentation,
-        tags: event.tags
-      });
-    },
-    orphanDeletion: {
-      getRemoteIdentifier: (event) => event.identifier,
-      deleteItem: (identifier) => client.events.delete(identifier)
-    },
+    getRemoteIdentifier: (event) => event.identifier,
     updateLocalMeta: async (dir, opts) => {
       const pulledEvents = await client.pull.events();
       await writeEvents(dir, pulledEvents, opts);
-    }
+    },
+    readOnlyStatusWarning: (event) => event.status === "completed" ? `Event ${event.identifier}: status "completed" is read-only; omitting status on push.` : null,
+    buildCompileInput: ({ source, siteId, targetEnv, upserts, deletes }) => ({
+      source,
+      siteId,
+      targetEnv,
+      events: { items: upserts },
+      delete: { events: deletes }
+    })
   });
 }
 
@@ -48957,7 +49904,8 @@ async function pushEventsScope(ctx, options) {
 async function pushVenuesScope(ctx, options) {
   const { client } = ctx;
   const only = options?.only;
-  return pushScopeGeneric(ctx, {
+  return pushCommandBackedDatedOfferingScope(ctx, {
+    source: "push_venues",
     scopeName: "venues",
     itemLabelSingular: "venue",
     scopeCommand: "venues",
@@ -48975,42 +49923,18 @@ async function pushVenuesScope(ctx, options) {
     },
     getRemoteUpdatedAt: (venue) => venue.updatedAt,
     findRemote: (venues, slug) => venues.find((v) => v.slug === slug),
-    checkExists: async (slug) => {
-      const existing = await client.venues.get(slug);
-      return existing !== null;
-    },
-    pushItem: async (venue) => {
-      const convertedAddress = venue.address ? {
-        line1: venue.address.line1 ?? void 0,
-        line2: venue.address.line2 ?? void 0,
-        city: venue.address.city ?? void 0,
-        region: venue.address.region ?? void 0,
-        postcode: venue.address.postcode ?? void 0,
-        country: venue.address.country ?? void 0
-      } : void 0;
-      const convertedLocation = venue.location ? {
-        lat: venue.location.lat,
-        lng: venue.location.lng
-      } : void 0;
-      await client.venues.upsert({
-        slug: venue.slug,
-        title: venue.title,
-        description: venue.description ?? void 0,
-        timezone: venue.timezone ?? void 0,
-        capacity: venue.capacity ?? void 0,
-        address: convertedAddress,
-        location: convertedLocation,
-        mapEmbed: venue.mapEmbed ?? void 0
-      });
-    },
-    orphanDeletion: {
-      getRemoteIdentifier: (venue) => venue.slug,
-      deleteItem: (slug) => client.venues.delete(slug)
-    },
+    getRemoteIdentifier: (venue) => venue.slug,
     updateLocalMeta: async (dir, opts) => {
       const pulledVenues = await client.pull.venues();
       await writeVenues(dir, pulledVenues, opts);
-    }
+    },
+    buildCompileInput: ({ source, siteId, targetEnv, upserts, deletes }) => ({
+      source,
+      siteId,
+      targetEnv,
+      venues: { items: upserts },
+      delete: { venues: deletes }
+    })
   });
 }
 
@@ -49019,37 +49943,6 @@ init_src();
 
 // src/cli/merge-remote/entryMerge.ts
 init_src();
-
-// src/cli/merge-remote/stableJson.ts
-init_src();
-function stableStringify(value) {
-  const sorted = sortValue(value);
-  switch (typeof sorted) {
-    case "bigint":
-    case "function":
-    case "symbol":
-    case "undefined":
-      return String(sorted);
-    case "boolean":
-    case "number":
-    case "object":
-    case "string":
-      return JSON.stringify(sorted);
-  }
-  return assertNever(sorted);
-}
-function sortValue(value) {
-  if (Array.isArray(value)) return value.map(sortValue);
-  if (value && typeof value === "object") return sortRecord(value);
-  return value;
-}
-function sortRecord(record) {
-  return Object.fromEntries(
-    Object.entries(record).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, sortValue(value)])
-  );
-}
-
-// src/cli/merge-remote/entryMerge.ts
 function planEntryMerge(input) {
   const { subject, base, local, remote } = input;
   if (!base) {
@@ -49843,6 +50736,8 @@ async function executeScopedPush(output, isRemote, options, globalOpts, scopeLab
   const result = await pushFn({
     output,
     contentDir,
+    siteId: env.siteId,
+    targetEnv: isRemote ? "remote" : "local",
     client,
     dryRun: options.dryRun,
     force: options.force ?? false,
@@ -49853,7 +50748,7 @@ async function executeScopedPush(output, isRemote, options, globalOpts, scopeLab
     skipMeta: !(options.meta ?? true),
     humanDiff: options.diff ?? false
   });
-  if (result.status === "pushed" && result.failed > 0) {
+  if (result.status === "pushed" && result.failed > 0 || result.status === "failed") {
     process.exitCode = 1;
     output.result(false, `${scopeLabel} push had failures`, result);
     return { success: false };
@@ -50547,6 +51442,8 @@ ${errors}`
       const pushAllCtx = {
         output,
         contentDir,
+        siteId: env.siteId,
+        targetEnv: target,
         client,
         dryRun: false,
         force: options.force ?? false,
@@ -50579,10 +51476,30 @@ Pushing ${label.toLowerCase()}...`);
       if (hasOrphans) {
         let deleteFailed = 0;
         const deleteScopes = [
-          { name: "events", items: pushAllExtraChanges.events.toDelete ?? /* @__PURE__ */ new Set(), deleteFn: (id) => client.events.delete(id) },
-          { name: "courses", items: pushAllExtraChanges.courses.toDelete ?? /* @__PURE__ */ new Set(), deleteFn: (id) => client.courses.delete(id) },
-          { name: "venues", items: pushAllExtraChanges.venues.toDelete ?? /* @__PURE__ */ new Set(), deleteFn: (slug) => client.venues.delete(slug) },
-          { name: "event categories", items: pushAllExtraChanges.eventCategories.toDelete ?? /* @__PURE__ */ new Set(), deleteFn: (id) => client.eventCategories.delete(id) }
+          {
+            name: "events",
+            scopeCommand: "events",
+            items: pushAllExtraChanges.events.toDelete ?? /* @__PURE__ */ new Set(),
+            buildDelete: (events) => ({ events })
+          },
+          {
+            name: "courses",
+            scopeCommand: "courses",
+            items: pushAllExtraChanges.courses.toDelete ?? /* @__PURE__ */ new Set(),
+            buildDelete: (courses) => ({ courses })
+          },
+          {
+            name: "venues",
+            scopeCommand: "venues",
+            items: pushAllExtraChanges.venues.toDelete ?? /* @__PURE__ */ new Set(),
+            buildDelete: (venues) => ({ venues })
+          },
+          {
+            name: "event categories",
+            scopeCommand: "event-categories",
+            items: pushAllExtraChanges.eventCategories.toDelete ?? /* @__PURE__ */ new Set(),
+            buildDelete: (eventCategories) => ({ eventCategories })
+          }
         ];
         for (const scope2 of deleteScopes) {
           if (scope2.items.size === 0) continue;
@@ -50590,14 +51507,30 @@ Pushing ${label.toLowerCase()}...`);
             output.warn(`Warning: ${scope2.items.size} ${scope2.name} will be deleted from CMS`);
           }
           output.info(`Deleting ${scope2.items.size} orphaned ${scope2.name}...`);
-          for (const id of scope2.items) {
-            try {
-              await scope2.deleteFn(id);
-            } catch (error) {
-              deleteFailed++;
-              const message = error instanceof Error ? error.message : String(error);
-              if (!isJsonOutput) {
-                output.warn(`  Failed to delete ${scope2.name} ${id}: ${message}`);
+          const compiledDeletes = compileDatedOfferingPushCommands({
+            source: "push_all_dated_offerings",
+            siteId: env.siteId,
+            targetEnv: target,
+            delete: scope2.buildDelete([...scope2.items])
+          });
+          if (!compiledDeletes.ok) {
+            deleteFailed++;
+            if (!isJsonOutput) {
+              output.warn(`  Failed to plan ${scope2.name} deletes: ${compiledDeletes.error.message}`);
+            }
+            continue;
+          }
+          const deleteResult = await executeDatedOfferingCommandPlanAsPushScopeResult({
+            client,
+            compiledPlan: compiledDeletes.value,
+            scopeCommand: scope2.scopeCommand,
+            scopeName: scope2.name
+          });
+          if (deleteResult.failed > 0) {
+            deleteFailed += deleteResult.failed;
+            if (!isJsonOutput) {
+              for (const itemError of deleteResult.errors) {
+                output.warn(`  Failed to delete ${scope2.name} ${itemError.identifier}: ${itemError.error}`);
               }
             }
           }
@@ -51677,7 +52610,7 @@ var THEME_FIELD_CATEGORY_MAP = {
 };
 
 // src/cli/init-docs/zod-to-markdown.ts
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isZodTypeAny(value) {
@@ -51803,7 +52736,7 @@ function extractLiteralValue(schema) {
   const typeName = getTypeName(schema);
   if (typeName !== ZodTypeName.ZodLiteral) return void 0;
   const def = schema._def;
-  if (!isRecord11(def)) return void 0;
+  if (!isRecord12(def)) return void 0;
   return String(def.value);
 }
 function extractSchemaInfo(schema, skipFields = []) {
@@ -51873,7 +52806,7 @@ function extractFieldInfo(name, schema) {
   }
   if (typeName === ZodTypeName.ZodRecord) {
     const def = inner._def;
-    const valueSchema = isRecord11(def) ? def.valueType : void 0;
+    const valueSchema = isRecord12(def) ? def.valueType : void 0;
     if (!isZodTypeAny(valueSchema)) {
       info.recordValueType = "unknown";
       return info;
@@ -51888,7 +52821,7 @@ function extractFieldInfo(name, schema) {
       }
     } else if (getTypeName(valueInner) === ZodTypeName.ZodRecord) {
       const nestedDef = valueInner._def;
-      const nestedValueSchema = isRecord11(nestedDef) ? nestedDef.valueType : void 0;
+      const nestedValueSchema = isRecord12(nestedDef) ? nestedDef.valueType : void 0;
       if (!isZodTypeAny(nestedValueSchema)) {
         info.recordValueType = "record<string, unknown>";
         return info;
@@ -51899,7 +52832,7 @@ function extractFieldInfo(name, schema) {
   }
   if (typeName === ZodTypeName.ZodUnion || typeName === ZodTypeName.ZodDiscriminatedUnion) {
     const def = inner._def;
-    const optionsValue = isRecord11(def) ? def.options : void 0;
+    const optionsValue = isRecord12(def) ? def.options : void 0;
     const options = Array.isArray(optionsValue) ? optionsValue.filter(isZodTypeAny) : [];
     const optionTypes = options.map((opt) => {
       const { inner: optInner } = unwrapSchema(opt);
@@ -53059,7 +53992,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.67.0";
+var SDK_VERSION = "0.68.0";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -59461,7 +60394,7 @@ var cancelCommand2 = new Command("cancel").description("Cancel a course run").ar
     }
   })
 );
-var courseCommand = new Command("course").description("Manage courses").addHelpText(
+var courseCommand2 = new Command("course").description("Manage courses").addHelpText(
   "after",
   `
 Examples:
@@ -59742,7 +60675,7 @@ program.addCommand(publishAllCommand);
 program.addCommand(auditCommand);
 program.addCommand(compareCommand);
 program.addCommand(eventCommand);
-program.addCommand(courseCommand);
+program.addCommand(courseCommand2);
 program.addCommand(manifestCommand);
 program.addCommand(envCommand);
 program.addCommand(migrateCommand);