@mevdragon/vidfarm-devcli 0.5.3 → 0.6.0

package/dist/src/ready-post-schedule-component.js

@@ -0,0 +1,1540 @@
+import { escapeJsonForHtml } from "./page-shell.js";
+export function renderReadyPostScheduleStyles() {
+    return `.ready-post-schedule-modal {
+  width: min(880px, calc(100vw - 28px));
+  padding: 0;
+  border: 1px solid rgba(191, 164, 109, 0.36);
+  border-radius: var(--radius-md);
+  background: var(--paper-strong);
+  color: var(--ink);
+  box-shadow: 0 28px 72px rgba(15, 23, 42, 0.18);
+}
+
+.ready-post-schedule-modal::backdrop {
+  background: rgba(36, 48, 65, 0.26);
+  backdrop-filter: blur(8px);
+}
+
+.ready-post-schedule-head {
+  display: grid;
+  gap: 8px;
+  padding: 22px 22px 18px;
+  border-bottom: 1px solid var(--line);
+  background: rgba(222, 192, 129, 0.1);
+}
+
+.ready-post-schedule-head h2 {
+  font-size: clamp(1.8rem, 4vw, 2.5rem);
+}
+
+.ready-post-schedule-body {
+  display: grid;
+  gap: 14px;
+  padding: 20px 22px 22px;
+}
+
+.ready-post-schedule-grid {
+  display: grid;
+  grid-template-columns: minmax(320px, 1fr) minmax(280px, 0.74fr);
+  gap: 16px;
+  align-items: start;
+}
+
+.ready-post-calendar {
+  display: grid;
+  gap: 12px;
+  padding: 14px;
+  border: 1px solid rgba(209, 219, 233, 0.96);
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.62);
+}
+
+.ready-post-calendar-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.ready-post-calendar-title {
+  color: #2f3748;
+  font-weight: 800;
+  letter-spacing: -0.02em;
+}
+
+.ready-post-calendar-nav {
+  display: flex;
+  gap: 6px;
+}
+
+.ready-post-calendar-nav button {
+  width: 38px;
+  min-width: 38px;
+  min-height: 38px;
+  padding: 0;
+}
+
+.ready-post-calendar-weekdays,
+.ready-post-calendar-days {
+  display: grid;
+  grid-template-columns: repeat(7, minmax(0, 1fr));
+  gap: 6px;
+}
+
+.ready-post-calendar-weekdays span {
+  color: var(--muted);
+  font-size: 0.72rem;
+  font-weight: 800;
+  text-align: center;
+  text-transform: uppercase;
+}
+
+.ready-post-calendar-day {
+  position: relative;
+  display: grid;
+  place-items: center;
+  min-width: 0;
+  min-height: 52px;
+  padding: 0;
+  border-color: rgba(209, 219, 233, 0.78);
+  background: rgba(255, 255, 255, 0.76);
+  border-radius: 14px;
+  color: #2f3748;
+  font-size: 0.9rem;
+  font-weight: 700;
+}
+
+.ready-post-calendar-day-number {
+  line-height: 1;
+}
+
+.ready-post-calendar-day-preview {
+  position: absolute;
+  right: 7px;
+  bottom: 6px;
+  min-width: 18px;
+  padding: 2px 5px;
+  border-radius: 999px;
+  background: rgba(255, 252, 247, 0.92);
+  color: #536176;
+  font-size: 0.58rem;
+  font-weight: 900;
+  line-height: 1.1;
+}
+
+.ready-post-calendar-day.has-posts {
+  border-color: rgba(83, 114, 89, 0.34);
+  background: rgba(83, 114, 89, 0.11);
+}
+
+.ready-post-calendar-day.has-posts::after {
+  content: "";
+  position: absolute;
+  left: 50%;
+  bottom: 8px;
+  width: 18px;
+  height: 3px;
+  border-radius: 999px;
+  background: rgba(83, 114, 89, 0.58);
+  transform: translateX(-50%);
+}
+
+.ready-post-calendar-day.has-many-posts::after {
+  display: none;
+}
+
+.ready-post-calendar-day.has-many-posts {
+  background: rgba(191, 164, 109, 0.2);
+  border-color: rgba(191, 164, 109, 0.44);
+}
+
+.ready-post-calendar-day.is-muted {
+  opacity: 0.42;
+}
+
+.ready-post-calendar-day.is-today {
+  border-color: rgba(191, 164, 109, 0.85);
+}
+
+.ready-post-calendar-day.is-selected {
+  background: #243041;
+  color: #fffaf2;
+  border-color: #243041;
+}
+
+.ready-post-calendar-day.is-selected::after {
+  background: rgba(255, 250, 242, 0.78);
+}
+
+.ready-post-calendar-day.is-selected .ready-post-calendar-day-preview {
+  background: rgba(255, 250, 242, 0.18);
+  color: rgba(255, 250, 242, 0.9);
+}
+
+.ready-post-calendar-popover {
+  position: fixed;
+  z-index: 999;
+  display: grid;
+  width: min(390px, calc(100vw - 32px));
+  gap: 12px;
+  padding: 14px;
+  border: 1px solid rgba(191, 164, 109, 0.28);
+  border-radius: 18px;
+  background: rgba(255, 252, 247, 0.98);
+  box-shadow: 0 18px 44px rgba(37, 45, 61, 0.18);
+}
+
+.ready-post-calendar-popover[hidden] {
+  display: none;
+}
+
+.ready-post-calendar-popover-title {
+  padding-right: 30px;
+  color: #2f3748;
+  font-size: 0.95rem;
+  font-weight: 800;
+}
+
+.ready-post-calendar-popover-close {
+  position: absolute;
+  top: 10px;
+  right: 10px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  min-width: 26px;
+  height: 26px;
+  min-height: 26px;
+  padding: 0;
+  border: 1px solid rgba(209, 219, 233, 0.8);
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.72);
+  color: var(--muted);
+  box-shadow: none;
+  font-size: 0.95rem;
+  line-height: 1;
+}
+
+.ready-post-calendar-popover-close:hover {
+  background: rgba(255, 255, 255, 0.95);
+  color: #2f3748;
+  transform: none;
+  box-shadow: none;
+}
+
+.ready-post-calendar-popover-list {
+  display: grid;
+  gap: 10px;
+  max-height: min(360px, calc(100vh - 180px));
+  overflow: auto;
+  padding-right: 2px;
+}
+
+.ready-post-calendar-popover-item {
+  display: grid;
+  gap: 6px;
+  padding: 10px 11px;
+  border: 1px solid rgba(209, 219, 233, 0.72);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.72);
+}
+
+.ready-post-calendar-popover-time {
+  color: var(--muted);
+  font-size: 0.72rem;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.ready-post-calendar-popover-item a {
+  color: #2f3748;
+  font-size: 0.95rem;
+  font-weight: 700;
+  line-height: 1.18;
+  text-decoration: none;
+}
+
+.ready-post-calendar-popover-item a:hover {
+  text-decoration: underline;
+}
+
+.ready-post-calendar-popover-linkless {
+  color: #2f3748;
+  font-size: 0.95rem;
+  font-weight: 700;
+  line-height: 1.18;
+}
+
+.ready-post-calendar-popover-summary,
+.ready-post-calendar-popover-channel {
+  color: var(--muted);
+  font-size: 0.78rem;
+  line-height: 1.35;
+}
+
+.ready-post-calendar-popover-channel {
+  font-weight: 800;
+}
+
+.ready-post-schedule-side {
+  display: grid;
+  gap: 14px;
+}
+
+.ready-post-datetime-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(118px, 0.46fr);
+  gap: 10px;
+  align-items: end;
+}
+
+.ready-post-datetime-row .label-group {
+  min-width: 0;
+}
+
+.ready-post-datetime-shell {
+  position: relative;
+  min-width: 0;
+  cursor: pointer;
+}
+
+.ready-post-datetime-shell input {
+  min-width: 0;
+  padding-right: 44px;
+  cursor: pointer;
+}
+
+.ready-post-datetime-icon {
+  pointer-events: none;
+  position: absolute;
+  right: 16px;
+  top: 50%;
+  width: 18px;
+  height: 18px;
+  transform: translateY(-50%);
+  color: #243041;
+}
+
+.ready-post-timezone-select {
+  min-width: 0;
+  padding-inline: 14px;
+  text-overflow: ellipsis;
+}
+
+.ready-post-channel-picker {
+  position: relative;
+  display: grid;
+  gap: 8px;
+}
+
+.ready-post-channel-trigger {
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+  width: 100%;
+  min-height: 54px;
+  gap: 10px;
+  padding: 8px 14px;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.92);
+  color: var(--ink);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.8);
+}
+
+.ready-post-channel-trigger.is-placeholder {
+  color: var(--muted);
+}
+
+.ready-post-channel-trigger:hover {
+  transform: none;
+}
+
+.ready-post-channel-avatar {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 34px;
+  height: 34px;
+  flex: 0 0 34px;
+  overflow: hidden;
+  border: 1px solid rgba(209, 219, 233, 0.96);
+  border-radius: 999px;
+  background: #f3efe5;
+  color: #243041;
+  font-size: 0.72rem;
+  font-weight: 800;
+}
+
+.ready-post-channel-avatar img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+
+.ready-post-channel-copy {
+  display: grid;
+  min-width: 0;
+  text-align: left;
+  line-height: 1.2;
+}
+
+.ready-post-channel-title {
+  overflow: hidden;
+  color: #2f3748;
+  font-weight: 800;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.ready-post-channel-meta {
+  overflow: hidden;
+  color: var(--muted);
+  font-size: 0.82rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.ready-post-channel-menu {
+  position: absolute;
+  top: calc(100% + 8px);
+  right: 0;
+  left: 0;
+  z-index: 80;
+  display: grid;
+  gap: 8px;
+  max-height: 330px;
+  padding: 10px;
+  border: 1px solid rgba(191, 164, 109, 0.28);
+  border-radius: 18px;
+  background: rgba(255, 252, 247, 0.98);
+  box-shadow: 0 18px 44px rgba(37, 45, 61, 0.18);
+}
+
+.ready-post-email-instructions {
+  display: grid;
+  gap: 8px;
+}
+
+.ready-post-email-instructions[hidden] {
+  display: none;
+}
+
+.ready-post-email-instructions textarea {
+  min-height: 118px;
+  resize: vertical;
+  border-radius: 16px;
+  padding: 12px 14px;
+  font-size: 1rem;
+  font-weight: 400;
+  line-height: 1.45;
+  background: rgba(255, 255, 255, 0.88);
+}
+
+.ready-post-channel-menu[hidden] {
+  display: none;
+}
+
+.ready-post-channel-search {
+  min-height: 42px;
+  padding: 10px 13px;
+  border-radius: 14px;
+}
+
+.ready-post-channel-list {
+  display: grid;
+  gap: 6px;
+  overflow: auto;
+  max-height: 244px;
+}
+
+.ready-post-channel-option {
+  display: flex;
+  justify-content: flex-start;
+  width: 100%;
+  min-height: 48px;
+  gap: 10px;
+  padding: 7px 9px;
+  border: 0;
+  border-radius: 12px;
+  background: transparent;
+  box-shadow: none;
+}
+
+.ready-post-channel-option:hover,
+.ready-post-channel-option.is-selected {
+  background: rgba(222, 192, 129, 0.18);
+  transform: none;
+  box-shadow: none;
+}
+
+.ready-post-channel-empty {
+  padding: 12px;
+  color: var(--muted);
+  font-size: 0.9rem;
+}
+
+.ready-post-schedule-note {
+  display: none;
+  padding: 12px 14px;
+  border: 1px solid rgba(120, 138, 166, 0.24);
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.72);
+  color: #5b6d8f;
+  font-size: 0.92rem;
+  line-height: 1.5;
+}
+
+.ready-post-schedule-note[data-visible="true"] {
+  display: block;
+}
+
+.ready-post-schedule-note[data-tone="info"] {
+  border-color: rgba(84, 120, 184, 0.28);
+  background: rgba(238, 245, 255, 0.82);
+  color: #4d6591;
+}
+
+.ready-post-schedule-note[data-tone="success"] {
+  border-color: rgba(64, 139, 92, 0.28);
+  background: rgba(237, 248, 240, 0.82);
+  color: #326744;
+}
+
+.ready-post-schedule-note[data-tone="error"] {
+  border-color: rgba(190, 83, 73, 0.32);
+  background: rgba(255, 241, 239, 0.88);
+  color: #a34239;
+}
+
+.ready-post-schedule-toast {
+  position: absolute;
+  right: 28px;
+  bottom: 86px;
+  z-index: 4;
+  max-width: min(420px, calc(100% - 56px));
+  padding: 10px 13px;
+  border: 1px solid rgba(191, 164, 109, 0.38);
+  border-radius: 14px;
+  background: rgba(35, 43, 58, 0.94);
+  color: #fff;
+  font-size: 0.9rem;
+  line-height: 1.35;
+  box-shadow: 0 18px 42px rgba(20, 24, 34, 0.22);
+  opacity: 0;
+  pointer-events: none;
+  transform: translateY(8px);
+  transition: opacity 160ms ease, transform 160ms ease;
+}
+
+.ready-post-schedule-toast[data-visible="true"] {
+  opacity: 1;
+  transform: translateY(0);
+}
+
+.ready-post-schedule-actions {
+  justify-content: flex-end;
+}
+
+@media (max-width: 920px) {
+  .ready-post-actions {
+    justify-content: flex-start;
+  }
+
+  .ready-post-grid {
+    grid-template-columns: 1fr;
+    height: auto;
+    overflow: visible;
+  }
+
+  .ready-post-carousel,
+  .ready-post-slide {
+    min-height: 0;
+  }
+
+  .ready-post-phone-stage {
+    height: auto;
+    min-height: 560px;
+  }
+
+  .ready-post-schedule-toast {
+    right: 18px;
+    bottom: 74px;
+    max-width: calc(100% - 36px);
+  }
+
+  .ready-post-phone {
+    width: min(340px, 100%);
+    height: auto;
+  }
+
+  .ready-post-detail-column {
+    overflow: visible;
+    padding-right: 0;
+  }
+
+  .ready-post-asset {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .ready-post-asset-actions,
+  .ready-post-asset-actions .button {
+    width: 100%;
+  }
+
+  .ready-post-title-row,
+  .ready-post-schedule-grid {
+    grid-template-columns: 1fr;
+    display: grid;
+  }
+
+  .ready-post-actions {
+    max-width: 100%;
+    min-width: 0;
+    flex-wrap: wrap;
+    white-space: normal;
+    padding-bottom: 2px;
+  }
+
+  .ready-post-calendar-day {
+    min-height: 44px;
+  }
+
+  .ready-post-calendar-nav button {
+    width: 44px;
+    min-width: 44px;
+    min-height: 44px;
+  }
+
+  .ready-post-calendar-popover-close {
+    width: 40px;
+    min-width: 40px;
+    height: 40px;
+    min-height: 40px;
+  }
+
+  .ready-post-calendar-popover-title {
+    padding-right: 46px;
+  }
+}
+
+@media (max-width: 560px) {
+  .ready-post-datetime-row {
+    grid-template-columns: 1fr;
+  }
+}
+`;
+}
+export function renderReadyPostScheduleModal() {
+    return `<dialog class="ready-post-schedule-modal" data-schedule-modal>
+      <div class="ready-post-schedule-head">
+        <div class="label">Schedule post</div>
+        <h2>Choose a slot</h2>
+        <p>This is a UI preview only. It does not create a scheduled post yet.</p>
+      </div>
+      <form method="dialog" class="ready-post-schedule-body">
+        <div class="ready-post-schedule-grid">
+          <section class="ready-post-calendar" aria-label="Schedule calendar">
+            <div class="ready-post-calendar-head">
+              <div class="ready-post-calendar-title" data-schedule-calendar-title></div>
+              <div class="ready-post-calendar-nav">
+                <button type="button" class="secondary" data-schedule-prev-month aria-label="Previous month">‹</button>
+                <button type="button" class="secondary" data-schedule-next-month aria-label="Next month">›</button>
+              </div>
+            </div>
+            <div class="ready-post-calendar-weekdays" aria-hidden="true">
+              <span>Sun</span><span>Mon</span><span>Tue</span><span>Wed</span><span>Thu</span><span>Fri</span><span>Sat</span>
+            </div>
+            <div class="ready-post-calendar-days" data-schedule-calendar-days></div>
+            <input type="hidden" name="schedule_date" data-schedule-date>
+          </section>
+          <div class="ready-post-schedule-side">
+            <div class="ready-post-datetime-row">
+              <label class="label-group">
+                <span class="label">Date & time</span>
+                <span class="ready-post-datetime-shell" data-schedule-datetime-shell>
+                  <input type="datetime-local" name="schedule_datetime" data-schedule-datetime>
+                  <svg class="ready-post-datetime-icon" viewBox="0 0 20 20" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="10" cy="10" r="7.2"></circle><path d="M10 6.4v4l2.7 1.6"></path></svg>
+                </span>
+              </label>
+              <label class="label-group">
+                <span class="label">Timezone</span>
+                <select class="ready-post-timezone-select" name="schedule_timezone" data-schedule-timezone></select>
+              </label>
+            </div>
+            <label class="label-group">
+              <span class="label">Channel</span>
+              <span class="ready-post-channel-picker" data-schedule-channel-picker>
+                <button type="button" class="ready-post-channel-trigger" data-schedule-channel-trigger aria-haspopup="listbox" aria-expanded="false"></button>
+                <span class="ready-post-channel-menu" data-schedule-channel-menu hidden>
+                  <input class="ready-post-channel-search" type="search" data-schedule-channel-search placeholder="Search channels" autocomplete="off">
+                  <span class="ready-post-channel-list" data-schedule-channel-list role="listbox"></span>
+                </span>
+                <input type="hidden" name="schedule_channel" data-schedule-channel-value>
+              </span>
+            </label>
+            <label class="label-group ready-post-email-instructions" data-schedule-email-instructions hidden>
+              <span class="label">Additional instructions</span>
+              <textarea name="additional_notes" data-schedule-additional-notes maxlength="4000" placeholder="Example: publish this to LinkedIn after approval, adapt the caption for Reddit, or send to the Douyin team for localization."></textarea>
+            </label>
+          </div>
+        </div>
+        <div class="ready-post-schedule-note" data-schedule-note role="status" aria-live="polite"></div>
+        <div class="toolbar ready-post-schedule-actions">
+          <button type="button" class="secondary" data-schedule-close>Close</button>
+          <button type="button" data-schedule-submit disabled>Schedule</button>
+        </div>
+      </form>
+      <div class="ready-post-schedule-toast" data-schedule-toast role="status" aria-live="polite"></div>
+      <div class="ready-post-calendar-popover" data-schedule-post-popover hidden></div>
+    </dialog>`;
+}
+export function renderReadyPostScheduleData(boot) {
+    return `<script id="ready-post-schedule-data" type="application/json">${escapeJsonForHtml(boot)}</script>`;
+}
+export function renderReadyPostScheduleScript() {
+    return `<script>
+  (() => {
+const scheduleBoot = (() => {
+  try {
+    return JSON.parse(document.getElementById("ready-post-schedule-data")?.textContent || "{}");
+  } catch {
+    return {};
+  }
+})();
+document.addEventListener("click", (event) => {
+  const scheduleTrigger = event.target.closest("[data-schedule]");
+  if (scheduleTrigger) {
+    scheduleBoot.scheduleEndpoint = scheduleTrigger.dataset.scheduleEndpoint || scheduleBoot.scheduleEndpoint || null;
+    const modal = document.querySelector("[data-schedule-modal]");
+    if (modal?.showModal) {
+      modal.showModal();
+    } else if (modal) {
+      modal.setAttribute("open", "");
+    }
+    void refreshScheduleCalendar();
+  }
+  if (event.target.closest("[data-schedule-close]")) {
+    const modal = document.querySelector("[data-schedule-modal]");
+    if (modal?.close) {
+      modal.close();
+    } else if (modal) {
+      modal.removeAttribute("open");
+    }
+  }
+  if (event.target.closest("[data-schedule-post-popover-close]")) {
+    closePostPopover();
+  }
+});
+document.querySelector("[data-schedule-modal]")?.addEventListener("click", (event) => {
+  if (event.target === event.currentTarget) {
+    event.currentTarget.close?.();
+  }
+});
+const channelPicker = document.querySelector("[data-schedule-channel-picker]");
+const channelTrigger = document.querySelector("[data-schedule-channel-trigger]");
+const channelMenu = document.querySelector("[data-schedule-channel-menu]");
+const channelSearch = document.querySelector("[data-schedule-channel-search]");
+const channelList = document.querySelector("[data-schedule-channel-list]");
+const channelValueInput = document.querySelector("[data-schedule-channel-value]");
+const emailInstructions = document.querySelector("[data-schedule-email-instructions]");
+const additionalNotesInput = document.querySelector("[data-schedule-additional-notes]");
+const scheduleDateInput = document.querySelector("[data-schedule-date]");
+const scheduleDateTimeInput = document.querySelector("[data-schedule-datetime]");
+const scheduleDateTimeShell = document.querySelector("[data-schedule-datetime-shell]");
+const timezoneSelect = document.querySelector("[data-schedule-timezone]");
+const calendarTitle = document.querySelector("[data-schedule-calendar-title]");
+const calendarDays = document.querySelector("[data-schedule-calendar-days]");
+const postPopover = document.querySelector("[data-schedule-post-popover]");
+const scheduleNote = document.querySelector("[data-schedule-note]");
+const scheduleSubmit = document.querySelector("[data-schedule-submit]");
+const scheduleToast = document.querySelector("[data-schedule-toast]");
+const monthFormatter = new Intl.DateTimeFormat(undefined, { month: "long", year: "numeric" });
+const popoverDateFormatter = new Intl.DateTimeFormat(undefined, { month: "short", day: "numeric" });
+const popoverTimeFormatter = new Intl.DateTimeFormat(undefined, { hour: "numeric", minute: "2-digit" });
+const toastDateFormatter = new Intl.DateTimeFormat(undefined, { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
+const minScheduleLeadMs = 10 * 60 * 1000;
+const cacheKey = "vidfarm:flockposter-cache:v1_" + (scheduleBoot.userId || "public");
+const isoDate = (date) => {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return year + "-" + month + "-" + day;
+};
+const pad2 = (value) => String(value).padStart(2, "0");
+const isoDateTimeLocal = (date, time) => isoDate(date) + "T" + time;
+const startOfDay = (date) => new Date(date.getFullYear(), date.getMonth(), date.getDate());
+const today = startOfDay(new Date());
+let selectedDate = today;
+let calendarCursor = new Date(today.getFullYear(), today.getMonth(), 1);
+let selectedTime = (() => {
+  const next = new Date();
+  next.setMinutes(next.getMinutes() >= 30 ? 0 : 30, 0, 0);
+  if (next.getTime() < Date.now() + minScheduleLeadMs) next.setHours(next.getHours() + 1);
+  return pad2(next.getHours()) + ":" + pad2(next.getMinutes());
+})();
+let scheduleChannels = Array.isArray(scheduleBoot.channels) ? scheduleBoot.channels : [];
+let selectedChannelId = "";
+let channelSearchQuery = "";
+let isScheduleSubmitting = false;
+let scheduleSubmitMode = "schedule";
+let hasInteractedWithScheduleDateTime = false;
+let scheduledPosts = [];
+let loadedRangeStart = null;
+let loadedRangeEnd = null;
+let scheduleFetchPromise = null;
+let hasLoadedScheduleCalendar = false;
+let activePostPopoverDateKey = "";
+
+const createOption = (label, value) => {
+  const option = document.createElement("option");
+  option.textContent = label;
+  option.value = value || label;
+  return option;
+};
+
+const describeChannel = (channel) => {
+  const name = channel?.name || channel?.title || channel?.id || "Untitled channel";
+  const handle = channel?.handle ? " @" + channel.handle : "";
+  const platform = channel?.platform ? " · " + String(channel.platform).toUpperCase() : "";
+  return name + handle + platform;
+};
+
+const normalizeChannelsForSchedule = (entries) => (Array.isArray(entries) ? entries : []).map((channel) => ({
+  id: String(channel.id || ""),
+  name: String(channel.name || channel.title || channel.id || "Channel"),
+  title: String(channel.title || channel.name || channel.id || "Channel"),
+  handle: channel.handle ? String(channel.handle) : null,
+  platform: channel.platform ? String(channel.platform) : null,
+  avatarUrl: channel.avatarUrl ? String(channel.avatarUrl) : null,
+  platformIconUrl: channel.platformIconUrl ? String(channel.platformIconUrl) : null
+})).filter((channel) => channel.id);
+
+const dedupeById = (entries) => [...new Map(entries.map((entry) => [entry.id, entry])).values()];
+
+const dedupeSchedulePosts = (entries) => {
+  const byId = dedupeById(entries);
+  const managedSlots = new Set(byId
+    .filter((post) => post.managedBy === "vidfarm")
+    .map((post) => post.channelId + "|" + post.scheduledAt));
+  return byId.filter((post) => post.managedBy !== "external" || !managedSlots.has(post.channelId + "|" + post.scheduledAt));
+};
+
+const normalizePostsForSchedule = (entries) => dedupeSchedulePosts((Array.isArray(entries) ? entries : []).map((post) => {
+  const scheduledAt = typeof post?.scheduledAt === "string" ? post.scheduledAt : "";
+  return {
+    id: String(post?.id || ""),
+    scheduleId: String(post?.scheduleId || post?.schedule_id || post?.id || ""),
+    postId: String(post?.postId || post?.post_id || ""),
+    managedBy: String(post?.managedBy || post?.managed_by || ""),
+    channelId: String(post?.channelId || ""),
+    scheduledAt,
+    status: String(post?.status || "Scheduled"),
+    title: String(post?.title || "Scheduled post"),
+    summary: String(post?.summary || ""),
+    url: typeof post?.url === "string" && post.url ? post.url : null
+  };
+}).filter((post) => post.id && post.channelId && !Number.isNaN(Date.parse(post.scheduledAt))));
+
+const readScheduleCache = () => {
+  try {
+    const runtime = window.__vidfarmFlockPosterCache;
+    if (runtime && typeof runtime.readSnapshot === "function") {
+      return runtime.readSnapshot();
+    }
+    const raw = window.localStorage.getItem(cacheKey);
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+};
+
+const applyScheduleCache = () => {
+  const snapshot = readScheduleCache();
+  if (Array.isArray(snapshot.channels) && snapshot.channels.length) {
+    scheduleChannels = normalizeChannelsForSchedule(dedupeById([...scheduleChannels, ...snapshot.channels]));
+  }
+  if (Array.isArray(snapshot.posts) && snapshot.posts.length) {
+    scheduledPosts = normalizePostsForSchedule([...scheduledPosts, ...snapshot.posts]);
+  }
+  loadedRangeStart = typeof snapshot.calendarRangeStart === "string" ? snapshot.calendarRangeStart : loadedRangeStart;
+  loadedRangeEnd = typeof snapshot.calendarRangeEnd === "string" ? snapshot.calendarRangeEnd : loadedRangeEnd;
+};
+
+const writeScheduleCache = (channels, posts, rangeStart, rangeEnd) => {
+  const runtime = window.__vidfarmFlockPosterCache;
+  if (runtime && typeof runtime.setCalendarData === "function") {
+    runtime.setCalendarData({ channels, posts, rangeStart, rangeEnd, replaceRange: true });
+    return;
+  }
+  try {
+    const current = readScheduleCache();
+    window.localStorage.setItem(cacheKey, JSON.stringify({
+      channels: dedupeById([...(Array.isArray(current.channels) ? current.channels : []), ...channels]),
+      posts: normalizePostsForSchedule([...(Array.isArray(current.posts) ? current.posts : []), ...posts]),
+      channelsUpdatedAt: new Date().toISOString(),
+      calendarUpdatedAt: new Date().toISOString(),
+      calendarRangeStart: rangeStart,
+      calendarRangeEnd: rangeEnd
+    }));
+  } catch {
+    // Ignore storage failures.
+  }
+};
+
+const clearScheduleNote = () => {
+  if (!scheduleNote) return;
+  scheduleNote.textContent = "";
+  scheduleNote.dataset.visible = "false";
+  delete scheduleNote.dataset.tone;
+};
+
+const setScheduleNote = (message, options = {}) => {
+  if (!scheduleNote) return;
+  if (!message) {
+    clearScheduleNote();
+    return;
+  }
+  scheduleNote.textContent = message;
+  scheduleNote.dataset.visible = "true";
+  scheduleNote.dataset.tone = options.tone || "info";
+  if (options.link) {
+    scheduleNote.append(" ");
+    const anchor = document.createElement("a");
+    anchor.href = options.link.href;
+    anchor.textContent = options.link.label;
+    scheduleNote.append(anchor);
+  }
+};
+
+let scheduleToastTimer = 0;
+const showScheduleToast = (message) => {
+  if (!scheduleToast) return;
+  window.clearTimeout(scheduleToastTimer);
+  scheduleToast.textContent = message;
+  scheduleToast.dataset.visible = "true";
+  scheduleToastTimer = window.setTimeout(() => {
+    scheduleToast.dataset.visible = "false";
+  }, 3600);
+};
+
+const syncDateTimeInput = () => {
+  if (!scheduleDateInput || !scheduleDateTimeInput) return;
+  scheduleDateInput.value = isoDate(selectedDate);
+  scheduleDateTimeInput.value = isoDateTimeLocal(selectedDate, selectedTime);
+  updateScheduleSubmitState();
+};
+
+const syncDateFromDateTimeInput = () => {
+  hasInteractedWithScheduleDateTime = true;
+  if (!scheduleDateTimeInput?.value) {
+    updateScheduleSubmitState();
+    return;
+  }
+  const [datePart, timePart] = scheduleDateTimeInput.value.split("T");
+  if (datePart) {
+    const parsed = new Date(datePart + "T00:00:00");
+    if (!Number.isNaN(parsed.getTime())) {
+      selectedDate = startOfDay(parsed);
+      calendarCursor = new Date(parsed.getFullYear(), parsed.getMonth(), 1);
+    }
+  }
+  if (/^\\d{2}:\\d{2}/.test(timePart || "")) {
+    selectedTime = timePart.slice(0, 5);
+  }
+  renderCalendar();
+  updateScheduleSubmitState();
+};
+
+const showDateTimePicker = () => {
+  if (!scheduleDateTimeInput) return;
+  scheduleDateTimeInput.focus();
+  if (typeof scheduleDateTimeInput.showPicker === "function") {
+    try { scheduleDateTimeInput.showPicker(); } catch {}
+  }
+};
+
+const rangeContainsDate = (rangeStart, rangeEnd, date) => {
+  if (!rangeStart || !rangeEnd) return false;
+  const time = startOfDay(date).getTime();
+  return time >= startOfDay(new Date(rangeStart)).getTime() && time <= startOfDay(new Date(rangeEnd)).getTime();
+};
+
+const calendarFetchWindow = () => {
+  const first = new Date(calendarCursor.getFullYear(), calendarCursor.getMonth(), 1);
+  const gridStart = new Date(first);
+  gridStart.setDate(first.getDate() - first.getDay());
+  const gridEnd = new Date(gridStart);
+  gridEnd.setDate(gridStart.getDate() + 41);
+  gridEnd.setHours(23, 59, 59, 999);
+  return { startDate: gridStart.toISOString(), endDate: gridEnd.toISOString() };
+};
+
+const postsForDate = (date) => {
+  const dateKey = isoDate(date);
+  const channelId = selectedChannelId;
+  return scheduledPosts
+    .filter((post) => isoDate(new Date(post.scheduledAt)) === dateKey)
+    .filter((post) => !channelId || post.channelId === channelId)
+    .sort((a, b) => Date.parse(a.scheduledAt) - Date.parse(b.scheduledAt));
+};
+
+const closePostPopover = () => {
+  activePostPopoverDateKey = "";
+  if (postPopover) postPopover.hidden = true;
+};
+
+const hidePostPopover = () => {
+  if (postPopover) postPopover.hidden = true;
+};
+
+const openPostPopover = (button, date, posts, options = {}) => {
+  if (!postPopover || !posts.length) {
+    closePostPopover();
+    return;
+  }
+  if (options.persist) {
+    activePostPopoverDateKey = isoDate(date);
+  }
+  const title = popoverDateFormatter.format(date);
+  postPopover.innerHTML = "";
+  const closeButton = document.createElement("button");
+  closeButton.type = "button";
+  closeButton.className = "ready-post-calendar-popover-close";
+  closeButton.setAttribute("aria-label", "Close post preview");
+  closeButton.dataset.schedulePostPopoverClose = "true";
+  closeButton.textContent = "×";
+  const heading = document.createElement("div");
+  heading.className = "ready-post-calendar-popover-title";
+  heading.textContent = title + " · " + posts.length + " post" + (posts.length === 1 ? "" : "s");
+  const list = document.createElement("div");
+  list.className = "ready-post-calendar-popover-list";
+  posts.slice(0, 8).forEach((post) => {
+    const channel = scheduleChannels.find((entry) => entry.id === post.channelId) || null;
+    const item = document.createElement("div");
+    item.className = "ready-post-calendar-popover-item";
+    const time = document.createElement("div");
+    time.className = "ready-post-calendar-popover-time";
+    time.textContent = popoverTimeFormatter.format(new Date(post.scheduledAt));
+    const channelNode = document.createElement("div");
+    channelNode.className = "ready-post-calendar-popover-channel";
+    channelNode.textContent = channel ? describeChannel(channel) : post.channelId;
+    const titleNode = post.url ? document.createElement("a") : document.createElement("span");
+    if (post.url) {
+      titleNode.href = post.url;
+      titleNode.target = "_blank";
+      titleNode.rel = "noreferrer";
+    } else {
+      titleNode.className = "ready-post-calendar-popover-linkless";
+    }
+    titleNode.textContent = post.title || "Scheduled post";
+    item.append(time, titleNode, channelNode);
+    if (post.summary && post.summary !== post.title) {
+      const summary = document.createElement("div");
+      summary.className = "ready-post-calendar-popover-summary";
+      summary.textContent = post.summary;
+      item.append(summary);
+    }
+    list.append(item);
+  });
+  postPopover.append(closeButton, heading, list);
+  const rect = button.getBoundingClientRect();
+  postPopover.hidden = false;
+  const width = postPopover.offsetWidth || 390;
+  const height = postPopover.offsetHeight || 260;
+  const preferRight = rect.right + width + 12 <= window.innerWidth - 16;
+  const left = preferRight
+    ? rect.right + 12
+    : Math.max(16, Math.min(window.innerWidth - width - 16, rect.left));
+  const top = Math.max(16, Math.min(window.innerHeight - height - 16, rect.top));
+  postPopover.style.left = left + "px";
+  postPopover.style.top = top + "px";
+};
+
+const channelInitials = (channel) => String(channel?.name || channel?.title || channel?.id || "CH")
+  .split(/\s+/)
+  .filter(Boolean)
+  .slice(0, 2)
+  .map((part) => part[0]?.toUpperCase() || "")
+  .join("") || "CH";
+
+const channelMeta = (channel) => {
+  const handle = channel?.handle ? (String(channel.platform || "").toLowerCase() === "email" ? channel.handle : "@" + channel.handle) : channel?.id || "";
+  const platform = channel?.platform ? String(channel.platform).toUpperCase() : "CHANNEL";
+  return [handle, platform].filter(Boolean).join(" · ");
+};
+
+const isEmailScheduleChannel = (channel) => String(channel?.platform || "").toLowerCase() === "email" || String(channel?.id || "").startsWith("email:");
+
+const updateEmailInstructionsVisibility = () => {
+  if (!emailInstructions) return;
+  const visible = isEmailScheduleChannel(selectedChannel());
+  emailInstructions.hidden = !visible;
+  if (!visible && additionalNotesInput) {
+    additionalNotesInput.value = "";
+  }
+};
+
+const renderChannelAvatar = (channel) => {
+  const avatar = document.createElement("span");
+  avatar.className = "ready-post-channel-avatar";
+  if (channel?.avatarUrl) {
+    const image = document.createElement("img");
+    image.src = channel.avatarUrl;
+    image.alt = "";
+    avatar.append(image);
+  } else {
+    avatar.textContent = channelInitials(channel);
+  }
+  return avatar;
+};
+
+const selectedChannel = () => scheduleChannels.find((channel) => channel.id === selectedChannelId) || null;
+
+const setSelectedChannel = (channelId) => {
+  if (!channelId || !scheduleChannels.some((channel) => channel.id === channelId)) {
+    selectedChannelId = "";
+  } else {
+    selectedChannelId = channelId;
+  }
+  if (channelValueInput) channelValueInput.value = selectedChannelId;
+  updateScheduleSubmitState();
+};
+
+const renderChannelTrigger = () => {
+  if (!channelTrigger) return;
+  channelTrigger.innerHTML = "";
+  channelTrigger.classList.remove("is-placeholder");
+  const channel = selectedChannel();
+  if (!channel) {
+    updateEmailInstructionsVisibility();
+    channelTrigger.classList.add("is-placeholder");
+    channelTrigger.textContent = scheduleChannels.length ? "Select a channel" : (scheduleBoot.error || "No channels connected");
+    if (scheduleChannels.length) {
+      setScheduleNote("Choose a channel to schedule this post.", { tone: "info" });
+    } else {
+      setScheduleNote("Add an email channel or connect FlockPoster to load channels.", {
+        tone: "info",
+        link: {
+          href: scheduleBoot.connectHref || "/settings?tab=channels",
+          label: "Open Settings"
+        }
+      });
+    }
+    return;
+  }
+  channelTrigger.append(renderChannelAvatar(channel));
+  const copy = document.createElement("span");
+  copy.className = "ready-post-channel-copy";
+  const title = document.createElement("span");
+  title.className = "ready-post-channel-title";
+  title.textContent = channel.name || channel.title || channel.id;
+  const meta = document.createElement("span");
+  meta.className = "ready-post-channel-meta";
+  meta.textContent = channelMeta(channel);
+  copy.append(title, meta);
+  channelTrigger.append(copy);
+  updateEmailInstructionsVisibility();
+  clearScheduleNote();
+  updateScheduleSubmitState();
+};
+
+const renderChannelList = () => {
+  if (!channelList) return;
+  channelList.innerHTML = "";
+  const query = channelSearchQuery.trim().toLowerCase();
+  const visible = scheduleChannels.filter((channel) => {
+    const haystack = [channel.name, channel.title, channel.handle, channel.platform, channel.id].filter(Boolean).join(" ").toLowerCase();
+    return !query || haystack.includes(query);
+  });
+  if (!visible.length) {
+    const empty = document.createElement("span");
+    empty.className = "ready-post-channel-empty";
+    empty.textContent = scheduleChannels.length ? "No channels match that search." : "No channels connected yet.";
+    channelList.append(empty);
+    return;
+  }
+  visible.forEach((channel) => {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "ready-post-channel-option" + (channel.id === selectedChannelId ? " is-selected" : "");
+    button.setAttribute("role", "option");
+    button.setAttribute("aria-selected", channel.id === selectedChannelId ? "true" : "false");
+    button.append(renderChannelAvatar(channel));
+    const copy = document.createElement("span");
+    copy.className = "ready-post-channel-copy";
+    const title = document.createElement("span");
+    title.className = "ready-post-channel-title";
+    title.textContent = channel.name || channel.title || channel.id;
+    const meta = document.createElement("span");
+    meta.className = "ready-post-channel-meta";
+    meta.textContent = channelMeta(channel);
+    copy.append(title, meta);
+    button.append(copy);
+    button.addEventListener("click", () => {
+      setSelectedChannel(channel.id);
+      closeChannelMenu();
+      renderChannelPicker();
+      closePostPopover();
+      renderCalendar();
+    });
+    channelList.append(button);
+  });
+};
+
+const renderChannelPicker = () => {
+  const previous = selectedChannelId;
+  setSelectedChannel(previous);
+  renderChannelTrigger();
+  renderChannelList();
+};
+
+const openChannelMenu = () => {
+  if (!channelMenu || !channelTrigger) return;
+  channelMenu.hidden = false;
+  channelTrigger.setAttribute("aria-expanded", "true");
+  renderChannelList();
+  setTimeout(() => channelSearch?.focus(), 0);
+};
+
+const closeChannelMenu = () => {
+  if (!channelMenu || !channelTrigger) return;
+  channelMenu.hidden = true;
+  channelTrigger.setAttribute("aria-expanded", "false");
+};
+
+const refreshScheduleCalendar = async (options = {}) => {
+  applyScheduleCache();
+  if (!scheduleBoot.feedEndpoint || !scheduleBoot.hasFlockPosterKey) {
+    renderChannelPicker();
+    renderCalendar();
+    return;
+  }
+  const range = calendarFetchWindow();
+  if (!options.force && hasLoadedScheduleCalendar && rangeContainsDate(loadedRangeStart, loadedRangeEnd, calendarCursor)) {
+    renderChannelPicker();
+    renderCalendar();
+    return;
+  }
+  if (scheduleFetchPromise) {
+    await scheduleFetchPromise;
+    return;
+  }
+  hasLoadedScheduleCalendar = true;
+  scheduleFetchPromise = (async () => {
+  try {
+    const url = new URL(scheduleBoot.feedEndpoint, window.location.origin);
+    url.searchParams.set("start_date", range.startDate);
+    url.searchParams.set("end_date", range.endDate);
+    const response = await fetch(url.pathname + url.search, { credentials: "same-origin", headers: { accept: "application/json" } });
+    const payload = await response.json();
+    if (!response.ok) {
+      throw new Error(typeof payload?.error === "string" ? payload.error : "Unable to load FlockPoster calendar.");
+    }
+    const nextChannels = normalizeChannelsForSchedule(payload.channels);
+    const nextPosts = normalizePostsForSchedule(payload.posts);
+    scheduleChannels = normalizeChannelsForSchedule(dedupeById([...scheduleChannels, ...nextChannels]));
+    scheduledPosts = normalizePostsForSchedule(dedupeById([...scheduledPosts, ...nextPosts]));
+    loadedRangeStart = typeof payload.startDate === "string" ? payload.startDate : range.startDate;
+    loadedRangeEnd = typeof payload.endDate === "string" ? payload.endDate : range.endDate;
+    scheduleBoot.error = typeof payload.error === "string" ? payload.error : "";
+    writeScheduleCache(nextChannels, nextPosts, loadedRangeStart, loadedRangeEnd);
+  } catch (error) {
+    scheduleBoot.error = error instanceof Error ? error.message : "Unable to load FlockPoster calendar.";
+  } finally {
+    scheduleFetchPromise = null;
+  }
+  })();
+  await scheduleFetchPromise;
+  renderChannelPicker();
+  renderCalendar();
+};
+
+const hydrateScheduleChannelsOnPageLoad = async () => {
+  const runtime = window.__vidfarmFlockPosterCache;
+  if (runtime && typeof runtime.ensureHydrated === "function") {
+    await runtime.ensureHydrated({ force: true });
+  }
+  await refreshScheduleCalendar({ force: true });
+};
+
+const renderCalendar = () => {
+  if (!calendarTitle || !calendarDays || !scheduleDateInput) return;
+  calendarTitle.textContent = monthFormatter.format(calendarCursor);
+  syncDateTimeInput();
+  calendarDays.innerHTML = "";
+  const first = new Date(calendarCursor.getFullYear(), calendarCursor.getMonth(), 1);
+  const gridStart = new Date(first);
+  gridStart.setDate(first.getDate() - first.getDay());
+  for (let index = 0; index < 42; index += 1) {
+    const date = new Date(gridStart);
+    date.setDate(gridStart.getDate() + index);
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "ready-post-calendar-day";
+    const number = document.createElement("span");
+    number.className = "ready-post-calendar-day-number";
+    number.textContent = String(date.getDate());
+    button.append(number);
+    button.dataset.scheduleDate = isoDate(date);
+    if (date.getMonth() !== calendarCursor.getMonth()) button.classList.add("is-muted");
+    if (isoDate(date) === isoDate(today)) button.classList.add("is-today");
+    if (isoDate(date) === isoDate(selectedDate)) button.classList.add("is-selected");
+    const dayPosts = postsForDate(date);
+    if (dayPosts.length) {
+      button.classList.add("has-posts");
+      if (dayPosts.length > 2) button.classList.add("has-many-posts");
+      button.setAttribute("aria-label", number.textContent + ", " + dayPosts.length + " scheduled post" + (dayPosts.length === 1 ? "" : "s"));
+      const preview = document.createElement("span");
+      preview.className = "ready-post-calendar-day-preview";
+      preview.textContent = String(dayPosts.length);
+      button.append(preview);
+      button.addEventListener("mouseenter", () => openPostPopover(button, date, dayPosts));
+      button.addEventListener("focus", () => openPostPopover(button, date, dayPosts));
+      if (activePostPopoverDateKey === isoDate(date)) {
+        setTimeout(() => {
+          openPostPopover(button, date, dayPosts, { persist: true });
+        }, 0);
+      }
+    }
+    button.addEventListener("click", () => {
+      selectedDate = startOfDay(date);
+      calendarCursor = new Date(date.getFullYear(), date.getMonth(), 1);
+      activePostPopoverDateKey = dayPosts.length ? isoDate(date) : "";
+      hidePostPopover();
+      renderCalendar();
+      void refreshScheduleCalendar();
+    });
+    calendarDays.append(button);
+  }
+};
+
+const selectedScheduleIso = () => {
+  if (!scheduleDateTimeInput?.value) return "";
+  const timezone = timezoneSelect?.value || "";
+  const offset = /^GMT([+-]\\d{2}:\\d{2})$/.exec(timezone)?.[1];
+  const raw = scheduleDateTimeInput.value.length === 16
+    ? scheduleDateTimeInput.value + ":00"
+    : scheduleDateTimeInput.value;
+  const parsed = new Date(offset ? raw + offset : raw);
+  return Number.isNaN(parsed.getTime()) ? "" : parsed.toISOString();
+};
+
+const canSubmitSchedule = () => {
+  const scheduledAt = selectedScheduleIso();
+  return Boolean(
+    scheduleBoot.scheduleEndpoint
+    && selectedChannel()
+    && scheduledAt
+    && Date.parse(scheduledAt) >= Date.now() + minScheduleLeadMs
+  );
+};
+
+const validateScheduleDateTime = () => {
+  if (!hasInteractedWithScheduleDateTime) return;
+  const scheduledAt = selectedScheduleIso();
+  if (!scheduledAt) {
+    setScheduleNote("Choose a valid date and time.", { tone: "error" });
+    return;
+  }
+  if (Date.parse(scheduledAt) < Date.now() + minScheduleLeadMs) {
+    setScheduleNote("Choose a time at least 10 minutes from now.", { tone: "error" });
+    return;
+  }
+  if (selectedChannel()) {
+    clearScheduleNote();
+  }
+};
+
+const setScheduleSubmitMode = (mode) => {
+  scheduleSubmitMode = mode;
+  if (!scheduleSubmit) return;
+  scheduleSubmit.textContent = mode === "another" ? "Schedule Another?" : "Schedule";
+  scheduleSubmit.classList.toggle("secondary", mode === "another");
+};
+
+const updateScheduleSubmitState = () => {
+  if (!scheduleSubmit) return;
+  if (scheduleSubmitMode === "another") {
+    scheduleSubmit.disabled = false;
+    return;
+  }
+  scheduleSubmit.disabled = isScheduleSubmitting || !canSubmitSchedule();
+  validateScheduleDateTime();
+};
+
+const submitSchedule = async () => {
+  if (!scheduleSubmit) return;
+  if (scheduleSubmitMode === "another") {
+    setScheduleSubmitMode("schedule");
+    updateScheduleSubmitState();
+    return;
+  }
+  if (!canSubmitSchedule()) {
+    updateScheduleSubmitState();
+    return;
+  }
+  if (!scheduleBoot.scheduleEndpoint) {
+    setScheduleNote("Sign in as the post owner before scheduling.", { tone: "error" });
+    return;
+  }
+  const channel = selectedChannel();
+  if (!channel) {
+    setScheduleNote("Choose a channel before scheduling.", { tone: "error" });
+    return;
+  }
+  const scheduledAt = selectedScheduleIso();
+  if (!scheduledAt) {
+    setScheduleNote("Choose a valid date and time.", { tone: "error" });
+    return;
+  }
+  if (Date.parse(scheduledAt) < Date.now() + minScheduleLeadMs) {
+    setScheduleNote("Choose a time at least 10 minutes from now.", { tone: "error" });
+    return;
+  }
+  const destinationType = isEmailScheduleChannel(channel) ? "email" : "flockposter";
+  const additionalNotes = destinationType === "email" ? String(additionalNotesInput?.value || "").trim() : "";
+  isScheduleSubmitting = true;
+  updateScheduleSubmitState();
+  scheduleSubmit.textContent = "Scheduling...";
+  try {
+    const response = await fetch(scheduleBoot.scheduleEndpoint, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      },
+      body: JSON.stringify({
+        destination_type: destinationType,
+        destination_id: channel.id,
+        scheduled_at: scheduledAt,
+        timezone: timezoneSelect?.value || null,
+        additional_notes: additionalNotes || undefined
+      })
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new Error(typeof payload?.error === "string" ? payload.error : "Unable to schedule post.");
+    }
+    const channelName = channel.name || channel.title || channel.id || "channel";
+    showScheduleToast("Scheduled to " + channelName + " · " + toastDateFormatter.format(new Date(scheduledAt)));
+    clearScheduleNote();
+    setScheduleSubmitMode("another");
+    await refreshScheduleCalendar({ force: true });
+  } catch (error) {
+    setScheduleNote(error instanceof Error ? error.message : "Unable to schedule post.", { tone: "error" });
+  } finally {
+    isScheduleSubmitting = false;
+    updateScheduleSubmitState();
+    if (scheduleSubmitMode !== "another") {
+      setScheduleSubmitMode("schedule");
+    }
+  }
+};
+
+channelTrigger?.addEventListener("click", (event) => {
+  event.preventDefault();
+  closePostPopover();
+  if (channelMenu?.hidden === false) {
+    closeChannelMenu();
+  } else {
+    openChannelMenu();
+  }
+});
+channelSearch?.addEventListener("input", () => {
+  channelSearchQuery = String(channelSearch.value || "");
+  renderChannelList();
+});
+scheduleDateTimeShell?.addEventListener("click", showDateTimePicker);
+scheduleDateTimeInput?.addEventListener("focus", showDateTimePicker);
+scheduleDateTimeInput?.addEventListener("input", () => {
+  hasInteractedWithScheduleDateTime = true;
+  updateScheduleSubmitState();
+});
+scheduleDateTimeInput?.addEventListener("change", syncDateFromDateTimeInput);
+scheduleSubmit?.addEventListener("click", () => {
+  void submitSchedule();
+});
+if (timezoneSelect) {
+  const timezoneCities = {
+    "-12": "Baker Island",
+    "-11": "Pago Pago",
+    "-10": "Honolulu",
+    "-9": "Anchorage",
+    "-8": "Los Angeles",
+    "-7": "Denver",
+    "-6": "Chicago",
+    "-5": "New York",
+    "-4": "Toronto",
+    "-3": "Sao Paulo",
+    "-2": "South Georgia",
+    "-1": "Azores",
+    "0": "London",
+    "1": "Paris",
+    "2": "Cairo",
+    "3": "Istanbul",
+    "4": "Dubai",
+    "5": "Karachi",
+    "6": "Dhaka",
+    "7": "Bangkok",
+    "8": "Singapore",
+    "9": "Tokyo",
+    "10": "Sydney",
+    "11": "Noumea",
+    "12": "Auckland",
+    "13": "Apia",
+    "14": "Kiritimati"
+  };
+  timezoneSelect.innerHTML = "";
+  for (let offset = -12; offset <= 14; offset += 1) {
+    const sign = offset >= 0 ? "+" : "-";
+    const value = "GMT" + sign + String(Math.abs(offset)).padStart(2, "0") + ":00";
+    timezoneSelect.append(createOption(value + " · " + timezoneCities[String(offset)], value));
+  }
+  const localOffset = -new Date().getTimezoneOffset() / 60;
+  const roundedOffset = Math.max(-12, Math.min(14, Math.round(localOffset)));
+  const localSign = roundedOffset >= 0 ? "+" : "-";
+  timezoneSelect.value = "GMT" + localSign + String(Math.abs(roundedOffset)).padStart(2, "0") + ":00";
+  timezoneSelect.addEventListener("change", () => {
+    hasInteractedWithScheduleDateTime = true;
+    updateScheduleSubmitState();
+  });
+}
+document.querySelector("[data-schedule-prev-month]")?.addEventListener("click", () => {
+  calendarCursor = new Date(calendarCursor.getFullYear(), calendarCursor.getMonth() - 1, 1);
+  closePostPopover();
+  renderCalendar();
+  void refreshScheduleCalendar();
+});
+document.querySelector("[data-schedule-next-month]")?.addEventListener("click", () => {
+  calendarCursor = new Date(calendarCursor.getFullYear(), calendarCursor.getMonth() + 1, 1);
+  closePostPopover();
+  renderCalendar();
+  void refreshScheduleCalendar();
+});
+document.addEventListener("pointerdown", (event) => {
+  if (channelPicker && !channelPicker.contains(event.target)) {
+    closeChannelMenu();
+  }
+  if (!event.target.closest("[data-schedule-post-popover]") && !event.target.closest(".ready-post-calendar-day")) {
+    closePostPopover();
+  }
+});
+window.addEventListener("resize", closePostPopover);
+window.addEventListener("vidfarm:flockposter-cache-updated", () => {
+  applyScheduleCache();
+  renderChannelPicker();
+  renderCalendar();
+});
+applyScheduleCache();
+renderChannelPicker();
+renderCalendar();
+void hydrateScheduleChannelsOnPageLoad();
+  })();
+  </script>`;
+}
+//# sourceMappingURL=ready-post-schedule-component.js.map