@jant/core 0.6.6 → 0.6.8

package/src/services/site-admin.ts

@@ -72,6 +72,11 @@ export interface ManageManagedSiteDomainInput {
   makePrimary?: boolean;
 }
 
+export interface RenameManagedSiteInput {
+  key: string;
+  primaryHost: string;
+}
+
 export interface ExportManagedSiteDeps {
   env: Bindings;
   storage?: StorageDriver | null;
@@ -130,6 +135,20 @@ export interface SiteAdminService {
   ): Promise<ManagedSitePostCountResult[]>;
   suspendManagedSite(siteId: string): Promise<Site>;
   resumeManagedSite(siteId: string): Promise<Site>;
+  /**
+   * Atomically rename a managed site: change `sites.key` and rewrite the
+   * existing primary domain's host. The primary domain row keeps its id, so
+   * downstream projections that key off the domain id (e.g. the control
+   * plane's `cloud_site_domain` projection) stay stable across the rename.
+   *
+   * Throws ConflictError if the new key or primary host collide with another
+   * site (or with a non-primary domain on the same site). No-ops when the new
+   * key and host both match the current values.
+   */
+  renameManagedSite(
+    siteId: string,
+    input: RenameManagedSiteInput,
+  ): Promise<ManagedSiteResult>;
   deleteManagedSite(
     siteId: string,
     deps?: DeleteManagedSiteDeps,
@@ -1024,5 +1043,107 @@ export function createSiteAdminService(
           .where(eq(siteDomains.id, normalizedDomainId));
       });
     },
+    async renameManagedSite(siteId, input) {
+      assertManagedSiteOperationsEnabled();
+      const normalizedSiteId = siteId.trim();
+      if (!normalizedSiteId) {
+        throw new NotFoundError("Site");
+      }
+
+      const newKey = input.key.trim();
+      const newPrimaryHost = input.primaryHost.trim().toLowerCase();
+      if (!newKey) {
+        throw new ConflictError("Site key is required.");
+      }
+      if (!newPrimaryHost) {
+        throw new ConflictError("Primary host is required.");
+      }
+
+      async function performRename(
+        targetDb: Database,
+      ): Promise<ManagedSiteResult> {
+        const siteRow = await requireSiteRow(targetDb, normalizedSiteId);
+
+        const primaryRows = await targetDb
+          .select()
+          .from(siteDomains)
+          .where(
+            and(
+              eq(siteDomains.siteId, normalizedSiteId),
+              eq(siteDomains.kind, "primary"),
+            ),
+          )
+          .limit(1);
+        const primaryRow = primaryRows[0];
+        if (!primaryRow) {
+          throw new NotFoundError("Site primary domain");
+        }
+
+        if (siteRow.key === newKey && primaryRow.host === newPrimaryHost) {
+          return {
+            domain: toSiteDomain(primaryRow),
+            site: toSite(siteRow),
+          };
+        }
+
+        if (siteRow.key !== newKey) {
+          const conflictingSite = await targetDb
+            .select({ id: sites.id })
+            .from(sites)
+            .where(eq(sites.key, newKey))
+            .limit(1);
+          if (conflictingSite[0]) {
+            throw new ConflictError("Site key is already in use.");
+          }
+        }
+
+        if (primaryRow.host !== newPrimaryHost) {
+          const conflictingDomain = await targetDb
+            .select({ id: siteDomains.id, siteId: siteDomains.siteId })
+            .from(siteDomains)
+            .where(eq(siteDomains.host, newPrimaryHost))
+            .limit(1);
+          if (conflictingDomain[0]) {
+            throw new ConflictError("Primary host is already in use.");
+          }
+        }
+
+        const timestamp = now();
+        const updatedSiteRow = (
+          await targetDb
+            .update(sites)
+            .set({ key: newKey, updatedAt: timestamp })
+            .where(eq(sites.id, normalizedSiteId))
+            .returning()
+        )[0];
+        if (!updatedSiteRow) {
+          throw new NotFoundError("Site");
+        }
+
+        const updatedDomainRow = (
+          await targetDb
+            .update(siteDomains)
+            .set({ host: newPrimaryHost, updatedAt: timestamp })
+            .where(eq(siteDomains.id, primaryRow.id))
+            .returning()
+        )[0];
+        if (!updatedDomainRow) {
+          throw new NotFoundError("Site primary domain");
+        }
+
+        return {
+          domain: toSiteDomain(updatedDomainRow),
+          site: toSite(updatedSiteRow),
+        };
+      }
+
+      if (supportsDrizzleTransaction(db, databaseDialect)) {
+        return db.transaction(async (tx) =>
+          performRename(tx as unknown as Database),
+        );
+      }
+
+      return performRename(db);
+    },
   };
 }

package/src/services/upload-session.ts

@@ -52,6 +52,10 @@ const RELAY_MULTIPART_THRESHOLD = 95 * 1024 * 1024;
 const RELAY_MULTIPART_PART_SIZE = 50 * 1024 * 1024;
 const IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable";
 const DEFAULT_EXPIRED_UPLOAD_CLEANUP_LIMIT = 20;
+// Grace window before a finalized-but-unattached media row (uploaded during
+// compose, `postId IS NULL`) is reaped. Generous enough that an in-progress
+// compose/edit is never affected; based on `createdAt`, no heartbeat needed.
+const ORPHAN_MEDIA_GRACE_SECONDS = 7 * 24 * 60 * 60;
 type CleanupableUploadSessionState = "pending" | "uploaded" | "failed";
 const CLEANUPABLE_UPLOAD_SESSION_STATES = [
   "pending",
@@ -143,6 +147,7 @@ export interface UploadSessionService {
   }): Promise<{
     abortedMultipartUploads: number;
     deletedSessions: number;
+    deletedOrphanMedia: number;
   }>;
   abort(id: string, deps: { storage: StorageDriver }): Promise<void>;
 }
@@ -760,9 +765,22 @@ export function createUploadSessionService(
         deletedSessions += 1;
       }
 
+      // Reap finalized media that was uploaded during compose but never
+      // attached to a post (`postId IS NULL`) past the grace window. Deletes
+      // the S3/R2 objects and DB rows (best-effort storage delete). Bounded by
+      // the same per-run `limit`; any backlog drains over subsequent runs.
+      const orphanIds = await media.listOrphanedMediaIds({
+        before: now() - ORPHAN_MEDIA_GRACE_SECONDS,
+        limit,
+      });
+      if (orphanIds.length > 0) {
+        await media.deleteByIds(orphanIds, deps.storage);
+      }
+
       return {
         abortedMultipartUploads,
         deletedSessions,
+        deletedOrphanMedia: orphanIds.length,
       };
     },
   };

package/src/styles/tokens.css

@@ -84,7 +84,7 @@
      mobile overrides below cap sizes for small screens.
      --type-content-scale uniformly scales all content sizes
      without affecting UI controls. */
-  --type-content-scale: 0.81;
+  --type-content-scale: 0.78;
   --type-content-display: calc(var(--type-display) * var(--type-content-scale));
   --type-content-title: calc(var(--type-title) * var(--type-content-scale));
   --type-content-subtitle: calc(

package/src/styles/ui.css

@@ -2205,8 +2205,16 @@
   }
 
   .feed-continue-link {
-    display: inline-block;
-    margin-top: 0.5rem;
+    /* Block so the whole content-width row is the tap target, not just the few
+       characters of "Read more". On mobile the trailing link on the last
+       summary line sits just above this control, so taps aimed here used to
+       land on that link. The larger `margin-top` is a dead (non-clickable)
+       buffer that separates the prose's trailing link from the control, and
+       `padding-bottom` grows the tap area downward, away from the footer
+       links below. Appearance is unchanged — only the hit area and spacing. */
+    display: block;
+    margin-top: 1rem;
+    padding-bottom: 0.6rem;
     font-size: var(--type-ui-meta);
     color: var(--site-text-secondary);
   }
@@ -2215,6 +2223,19 @@
     text-decoration: underline;
   }
 
+  /* Untitled note expand-in-place. The full body is rendered with a zero-width
+     `data-note-break` marker at the summary boundary; clamping hides only the
+     marker's following siblings, leaving the visible summary untouched so the
+     note grows in place without the page jumping. note-expand.ts toggles
+     `data-note-clamp` to reveal/hide the tail. */
+  [data-note-break] {
+    display: none;
+  }
+
+  [data-note-clamp] [data-note-break] ~ * {
+    display: none;
+  }
+
   .post-header-block {
     margin-bottom: 1rem;
   }
@@ -2331,16 +2352,39 @@
 
   .sidenote,
   .marginnote {
+    /* Layout: float into the right margin. A floated note anchors to its containing
+       block's right *content* edge, so if a theme gives that block inline-end padding
+       (e.g. a padded blockquote card) the anchor is inset and the note drifts left.
+       Themes expose that inset via --sidenote-anchor-inset (default 0) — best derived
+       from the same token that sets the padding — so the note still reaches the gutter
+       no matter how the container is indented. Core's own blocks add no inset. */
     float: right;
     clear: right;
-    margin-right: var(--layout-sidenote-margin);
+    margin-right: calc(
+      var(--layout-sidenote-margin) - var(--sidenote-anchor-inset, 0px)
+    );
     width: var(--layout-sidenote-width);
     margin-top: 0.3rem;
-    margin-bottom: 0;
-    font-size: var(--type-secondary);
-    line-height: 1.3;
+    /* Breathing room so multiple notes from one paragraph don't touch when they stack. */
+    margin-bottom: 1.4rem;
     vertical-align: baseline;
     position: relative;
+
+    /* Typographic isolation. A footnote is an annotation, not part of the text it
+       hangs off of, so it must render identically no matter what its reference sits
+       inside. The body span is emitted at the reference position (see tiptap-render
+       renderSidenoteReference), so when the [^n] is inside a blockquote / bold run /
+       heading the span inherits that context. Pin every inheritable type property to
+       the canonical note look to cut every such leak — not just the blockquote
+       serif+italic case. */
+    font-family: var(--font-body);
+    font-size: var(--type-sm);
+    font-style: normal;
+    font-weight: 400;
+    font-variant: normal;
+    line-height: 1.3;
+    letter-spacing: var(--type-body-tracking, normal);
+    text-align: left;
     color: var(--site-reading-meta);
   }
 
@@ -2358,12 +2402,16 @@
     content: counter(sidenote-counter);
     font-size: var(--type-code);
     top: -0.5rem;
-    left: 0.1rem;
+    /* Real margins (not `left`, which reserves no space) so the superscript
+       number keeps a gap from the words on both sides — matters for CJK, which
+       has no inter-word spacing. */
+    margin-left: 0.1rem;
+    margin-right: 0.25rem;
   }
 
   .sidenote::before {
     content: counter(sidenote-counter) " ";
-    font-size: var(--type-code);
+    font-size: var(--type-xs);
     top: -0.5rem;
   }
 
@@ -2372,13 +2420,6 @@
     font-size: var(--type-code);
   }
 
-  blockquote .sidenote,
-  blockquote .marginnote {
-    margin-right: -82%;
-    min-width: 59%;
-    text-align: left;
-  }
-
   input.margin-toggle {
     display: none;
   }
@@ -2637,13 +2678,28 @@
      secondary to the focused post but not so much that text becomes gray
      and hard to read. Combined with the mask-image bottom fade this gives
      a "context drifts into the background" effect without dimming the
-     whole shell to the point of illegibility. */
-  .thread-context-shell {
+     whole shell to the point of illegibility.
+
+     Fade per item, not the whole shell: a blanket `opacity` on the shell
+     makes it a stacking context that *caps* descendant opacity, so the gap
+     marker ("N more posts") could never read brighter than the faded
+     context around it. Fading each item individually leaves the gap — a
+     real route into the rest of the thread, not background context — at
+     full strength. The items cover everything inside the shell (feed:
+     context + gap; detail page: ancestor detail items), so nothing slips
+     through undimmed. */
+  .thread-context-shell .thread-item {
     opacity: 0.6;
     transition: opacity 0.22s ease;
   }
 
-  .thread-context-shell:not([data-collapsed]) {
+  .thread-context-shell:not([data-collapsed]) .thread-item {
+    opacity: 1;
+  }
+
+  /* The gap is a structural "thread continues here" marker — never faded,
+     collapsed or expanded. */
+  .thread-context-shell .thread-item.thread-item-gap {
     opacity: 1;
   }
 
@@ -2708,33 +2764,78 @@
     padding-bottom: 0.35rem;
   }
 
+  /* Gap marker on the rail: swap the single post dot for a short column of
+     small beads (a vertical "⋮") so the thread line visibly "skips" a run
+     of posts — the familiar threaded-conversation cue for collapsed
+     content. Smaller and quieter than the real post dots, sitting on the
+     same rail x-position. The continuous rail line still shows through
+     behind the beads, so thread continuity reads intact. */
+  .thread-group-preview .thread-item-gap::before,
+  .thread-group-detail .thread-item-gap::before {
+    top: 50%;
+    transform: translateY(-50%);
+    left: calc(
+      var(--site-thread-rail-line-left) + var(--site-thread-rail-line-width) /
+        2 - 2px - var(--site-thread-rail-indent)
+    );
+    width: 4px;
+    height: 24px;
+    border: 0;
+    border-radius: 0;
+    background: radial-gradient(
+      circle,
+      var(--site-threadline) 1.75px,
+      transparent 2px
+    );
+    background-size: 4px 8px;
+    background-repeat: repeat-y;
+    background-position: center top;
+    box-shadow: none;
+  }
+
+  /* "N more posts" — a calm route into the rest of the thread, styled as a
+     sibling of `.thread-context-toggle` (same muted colour + size) rather
+     than a pill or an underlined link. A small chevron does the "this is
+     tappable / leads somewhere" work an underline does poorly on a short
+     standalone label; it points right because the link navigates into the
+     thread rather than expanding in place. Full opacity keeps it from
+     fading into the context above. */
   .thread-gap-link {
     display: inline-flex;
     align-items: center;
-    gap: 0.35rem;
-    padding: 0.38rem 0.78rem;
-    border: 1px dashed var(--site-thread-context-border);
-    border-radius: 999px;
-    background: var(--site-thread-gap-bg);
+    gap: 0.4rem;
+    padding: 0.25rem 0;
     color: var(--site-text-secondary);
     font-size: var(--type-thread-context-meta);
-    line-height: 1.3;
+    font-weight: 500;
+    line-height: 1.2;
     text-decoration: none;
+    transition: color 0.18s ease;
+  }
+
+  .thread-gap-link::after {
+    content: "";
+    width: 0.36em;
+    height: 0.36em;
+    border: 1.5px solid currentColor;
+    border-left: 0;
+    border-bottom: 0;
+    opacity: 0.65;
+    transform: rotate(45deg);
     transition:
-      border-color 0.18s ease,
-      color 0.18s ease,
-      background-color 0.18s ease;
+      transform 0.18s ease,
+      opacity 0.18s ease;
   }
 
   .thread-gap-link:hover {
-    border-color: color-mix(
-      in srgb,
-      var(--site-accent) 22%,
-      var(--site-divider)
-    );
     color: var(--site-text-primary);
   }
 
+  .thread-gap-link:hover::after {
+    opacity: 1;
+    transform: translateX(2px) rotate(45deg);
+  }
+
   .thread-item-hero {
     padding-top: 0.95rem;
   }
@@ -7739,9 +7840,12 @@
     min-height: 72px;
   }
 
-  /* Focused thread post gets a subtle left accent */
+  /* Focused thread post gets a subtle left accent. Use an inset box-shadow, not
+     a border: a border adds 2px of layout width only while focused, so switching
+     focus between thread posts shifted each one sideways ("jitter"). box-shadow
+     paints in the same spot without affecting layout. */
   .compose-thread-post:focus-within > jant-compose-editor {
-    border-left: 2px solid transparent;
+    box-shadow: inset 2px 0 0 transparent;
   }
 
   /* "Add to thread" row inside thread compose layout */
@@ -7852,6 +7956,22 @@
     padding: 6px 0 4px;
   }
 
+  /* Reply / edit-reply compose (a .compose-editor-row directly under
+     .compose-thread-layout — not the multi-post thread variant) needs clear
+     separation from the parent post shown above it. A thread post is meant to
+     sit tight on the rail, so this is scoped away from thread compose. Uses a
+     static :not() rather than :has() on purpose: a :has() here re-evaluates on
+     focus changes inside the row and caused a one-frame horizontal reflow
+     ("jitter") when clicking into the editor. */
+  .compose-thread-layout:not(.compose-thread-compose-layout)
+    .compose-editor-row {
+    padding-top: 14px;
+  }
+
+  .compose-thread-post-header + .compose-body {
+    padding-top: 8px;
+  }
+
   /* Thread format selector: pill-tag style (lighter than the main segmented) */
   .compose-thread-segmented {
     background: transparent;
@@ -8630,6 +8750,15 @@
     margin-bottom: 1.4rem;
   }
 
+  /* In inline-format compose (reply / edit-reply / thread — the editors wrapped
+     in .compose-editor-row), the format header sits right above the body, so the
+     first block's 1.4rem top margin reads as a gap between the format pills and
+     the input. Drop it there so the text hugs the header. Standalone new/edit
+     editors keep their natural lead-in. */
+  .compose-editor-row .compose-tiptap-body .tiptap > :first-child {
+    margin-top: 0;
+  }
+
   .compose-tiptap-body .tiptap ul {
     list-style-type: disc;
     padding-left: 1.5em;

package/src/types/config.ts

@@ -163,7 +163,7 @@ export const CONFIG_FIELDS = {
     envKeys: ["ASSET_BASE_URL"],
   },
   UPLOAD_MAX_FILE_SIZE_MB: {
-    defaultValue: "500",
+    defaultValue: "1024",
     envOnly: true,
     envKeys: ["UPLOAD_MAX_FILE_SIZE_MB"],
   },

package/src/types/props.ts

@@ -59,6 +59,8 @@ export interface ArchiveFilters {
   mediaKinds?: MediaKind[];
   hasMedia?: boolean;
   hasTitle?: boolean;
+  /** true = threads (roots with replies), false = single posts (no replies) */
+  hasReplies?: boolean;
   visibility?: ArchiveVisibility;
   view?: ArchiveView;
 }
@@ -122,6 +124,7 @@ export interface CollectionsPageProps {
   items: CollectionDirectoryItem[];
   isAuthenticated: boolean;
   sitePathPrefix?: string;
+  siteOrigin?: string;
 }
 
 // =============================================================================

package/src/ui/compose/ComposeDialog.tsx

@@ -743,6 +743,19 @@ export const ComposeForm: FC<ComposeFormProps> = ({
           "@context: Compose dialog header title when composing a thread",
       }),
     ),
+    replyTitle: i18n._(
+      msg({
+        message: "Reply",
+        comment:
+          "@context: Compose dialog header title when replying to a post",
+      }),
+    ),
+    editTitle: i18n._(
+      msg({
+        message: "Edit",
+        comment: "@context: Compose dialog header title when editing a post",
+      }),
+    ),
     slashHint: i18n._(
       msg({
         message: "Type / for commands",

package/src/ui/dash/settings/AccountMenuContent.tsx

@@ -31,13 +31,11 @@ export function AccountMenuContent({
   demoMode = false,
   hostedControlPlaneAccountUrl,
   hostedControlPlaneProviderLabel,
-  hostedControlPlaneSiteDeleteUrl,
 }: {
   sitePathPrefix?: string;
   demoMode?: boolean;
   hostedControlPlaneAccountUrl?: string | null;
   hostedControlPlaneProviderLabel?: string | null;
-  hostedControlPlaneSiteDeleteUrl?: string | null;
 }) {
   const { i18n } = useLingui();
   const isHosted = Boolean(hostedControlPlaneAccountUrl);
@@ -266,43 +264,6 @@ export function AccountMenuContent({
         />
       </SettingsDirectorySection>
 
-      {!demoMode && isHosted && hostedControlPlaneSiteDeleteUrl ? (
-        <SettingsDirectorySection
-          title={i18n._(
-            msg({
-              message: "Danger Zone",
-              comment:
-                "@context: Settings group label for destructive account actions",
-            }),
-          )}
-          tone="danger"
-        >
-          <SettingsDirectoryLink
-            href={hostedControlPlaneSiteDeleteUrl}
-            icon={ICONS.trash}
-            tone="danger"
-            name={i18n._(
-              msg({
-                message: "Delete Hosted Site",
-                comment:
-                  "@context: Settings item — open the hosted site danger zone in the control plane",
-              }),
-            )}
-            description={i18n._(
-              msg({
-                message:
-                  "Open the hosted site controls in {providerLabel} to cancel billing or permanently delete this site.",
-                comment:
-                  "@context: Settings item description for the hosted delete-site entry in the account menu",
-              }),
-              {
-                providerLabel,
-              },
-            )}
-          />
-        </SettingsDirectorySection>
-      ) : null}
-
       {!demoMode && !isHosted && (
         <SettingsDirectorySection
           title={i18n._(

package/src/ui/dash/settings/SettingsDirectory.tsx

@@ -22,6 +22,28 @@ function ChevronRight() {
   );
 }
 
+function ExternalLinkIndicator() {
+  return (
+    <svg
+      class="settings-directory-item-chevron"
+      xmlns="http://www.w3.org/2000/svg"
+      width="16"
+      height="16"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="2"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+      aria-hidden="true"
+    >
+      <path d="M15 3h6v6" />
+      <path d="M10 14 21 3" />
+      <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" />
+    </svg>
+  );
+}
+
 export function SettingsDirectorySection({
   title,
   tone = "default",
@@ -45,10 +67,12 @@ export function SettingsDirectoryItemContent({
   icon,
   name,
   description,
+  external = false,
 }: {
   icon: string;
   name: string;
   description: string;
+  external?: boolean;
 }) {
   return (
     <>
@@ -59,7 +83,7 @@ export function SettingsDirectoryItemContent({
         <span class="settings-directory-item-name">{name}</span>
         <span class="settings-directory-item-desc">{description}</span>
       </span>
-      <ChevronRight />
+      {external ? <ExternalLinkIndicator /> : <ChevronRight />}
     </>
   );
 }
@@ -93,6 +117,7 @@ export function SettingsDirectoryLink({
         icon={icon}
         name={name}
         description={description}
+        external={target === "_blank"}
       />
     </a>
   );