@nearform/fling 0.6.0 → 0.7.0

package/dist/cli.js

@@ -1,26 +1,108 @@
 #!/usr/bin/env node
 
+// ../../packages/shared/src/access.ts
+import { z } from "zod";
+var ACCESS_LEVELS = ["only_me", "members", "groups", "people", "public"];
+var AccessLevelSchema = z.enum(ACCESS_LEVELS);
+var DEFAULT_ACCESS_LEVELS = ["only_me", "members"];
+var DefaultAccessLevelSchema = z.enum(DEFAULT_ACCESS_LEVELS);
+var LEGACY_DEFAULT_ACCESS = "members";
+var needsAudience = (level) => level === "groups" || level === "people";
+var ACCESS_LABELS = {
+  only_me: "Only you",
+  members: "Everyone signed in",
+  groups: "Teams",
+  people: "Specific people",
+  public: "Public"
+};
+function accessDescription(level, members2) {
+  switch (level) {
+    case "only_me":
+      return "Only you can open it.";
+    case "members":
+      return `${capitalise(members2)} can open it.`;
+    case "groups":
+      return "Only you and the members of the groups you name can open it.";
+    case "people":
+      return "Only you and the people you name can open it.";
+    case "public":
+      return "Anyone with the address can open it, without signing in; its review page and comments still need sign-in.";
+  }
+}
+var capitalise = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function accessLevelOf(site) {
+  if (site.visibility === "public") return "public";
+  if (!site.restricted) return "members";
+  if (site.emails > 0) return "people";
+  return site.groups > 0 ? "groups" : "only_me";
+}
+var siteAccessLevel = (site) => site.access ?? accessLevelOf({
+  visibility: site.visibility,
+  restricted: site.restricted ?? false,
+  emails: (site.audienceSize ?? 0) - (site.audienceGroups ?? 0),
+  groups: site.audienceGroups ?? 0
+});
+function parseAccessLevel(value) {
+  const v = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  const aliases = {
+    me: "only_me",
+    only_you: "only_me",
+    owner: "only_me",
+    private: "members",
+    member: "members",
+    everyone: "members",
+    group: "groups",
+    teams: "groups",
+    team: "groups",
+    person: "people",
+    emails: "people"
+  };
+  return ACCESS_LEVELS.includes(v) ? v : aliases[v] ?? null;
+}
+function accessChangeHint(client, name, opts = {}) {
+  const bin = opts.bin ?? "fling";
+  const how = client === "cli" ? `Change who can open it with \`${bin} access ${name} --only-me | --members | --add <email> | --group <slug> | --public\`.` : `To change who can open it, call fling_set_access (only_me, members, groups, people or public).`;
+  return opts.invites ? `${how} An address from outside is invited as a reviewer, who sees only what is shared with them.` : how;
+}
+var count = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+function describeSiteAccess(site, members2) {
+  const level = siteAccessLevel(site);
+  const share2 = site.shareUrl && level !== "public" && level !== "members" ? " A share link is active: anyone with it can still open the site." : "";
+  if (!needsAudience(level)) return `${accessDescription(level, members2)}${share2}`;
+  const groups2 = site.audienceGroups ?? 0;
+  const people2 = (site.audienceSize ?? 0) - groups2;
+  const who = [
+    people2 ? count(people2, "person", "people") : "",
+    groups2 ? count(groups2, "group", "groups") : ""
+  ].filter(Boolean);
+  return `Only you and ${who.join(" and ")} can open it.${share2}`;
+}
+
 // ../../packages/shared/src/api.ts
-import { z as z3 } from "zod";
+import { z as z7 } from "zod";
 
 // ../../packages/shared/src/audience.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var AUDIENCE_EMAILS_MAX = 100;
 var AUDIENCE_GROUPS_MAX = 10;
-var AudienceEmailSchema = z.object({ email: z.string(), known: z.boolean() });
-var AudienceGroupSchema = z.object({
-  slug: z.string(),
-  name: z.string(),
-  size: z.number(),
-  deleted: z.boolean().optional()
+var AudienceEmailSchema = z2.object({
+  email: z2.string(),
+  known: z2.boolean(),
+  guest: z2.boolean().optional()
+});
+var AudienceGroupSchema = z2.object({
+  slug: z2.string(),
+  name: z2.string(),
+  size: z2.number(),
+  deleted: z2.boolean().optional()
 });
-var AudienceSchema = z.object({
-  emails: z.array(AudienceEmailSchema),
-  groups: z.array(AudienceGroupSchema).default([])
+var AudienceSchema = z2.object({
+  emails: z2.array(AudienceEmailSchema),
+  groups: z2.array(AudienceGroupSchema).default([])
 });
-var AudienceInputSchema = z.object({
-  emails: z.array(z.string().trim().toLowerCase().min(3).max(254)).max(AUDIENCE_EMAILS_MAX, `An audience holds at most ${AUDIENCE_EMAILS_MAX} addresses`),
-  groups: z.array(z.string().trim().toLowerCase().min(1).max(100)).max(AUDIENCE_GROUPS_MAX, `An audience names at most ${AUDIENCE_GROUPS_MAX} groups`).default([])
+var AudienceInputSchema = z2.object({
+  emails: z2.array(z2.string().trim().toLowerCase().min(3).max(254)).max(AUDIENCE_EMAILS_MAX, `An audience holds at most ${AUDIENCE_EMAILS_MAX} addresses`),
+  groups: z2.array(z2.string().trim().toLowerCase().min(1).max(100)).max(AUDIENCE_GROUPS_MAX, `An audience names at most ${AUDIENCE_GROUPS_MAX} groups`).default([])
 });
 var normaliseEmail = (email) => email.trim().toLowerCase();
 function splitEmails(values) {
@@ -66,17 +148,23 @@ function whoIn(emails2, groups2) {
   ].filter(Boolean);
 }
 var and = (parts) => parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}` : parts[0] ?? "";
-var audienceList = (emails2) => emails2.map((e) => e.known ? e.email : `${e.email} (hasn't signed in yet)`).join(", ");
+var audienceList = (emails2) => emails2.map((e) => {
+  const notes = [e.guest ? "guest" : "", e.known ? "" : "hasn't signed in yet"].filter(Boolean);
+  return notes.length ? `${e.email} (${notes.join(", ")})` : e.email;
+}).join(", ");
 function describeAudience(site, privateAudience2) {
   const emails2 = site.audience?.emails ?? [];
   const groups2 = site.audience?.groups ?? [];
   const empty = emails2.length + groups2.length === 0;
   const list = emails2.length ? `: ${audienceList(emails2)}` : "";
   if (site.visibility === "public") {
-    return empty ? "Public: anyone can open the site; reviewing it still needs sign-in." : `Public: anyone can open the site; reviewing it still needs sign-in. Its audience (${and(whoIn(emails2, groups2))}${list}) applies when it is private again.`;
+    const kept = empty ? "" : ` Its audience (${and(whoIn(emails2, groups2))}${list}) applies when it is private again.`;
+    return `Public: anyone can open the site; reviewing it still needs sign-in.${kept}`;
   }
-  if (empty) return `Private: ${privateAudience2} can open it.`;
   const share2 = site.shareUrl ? ` A share link is active: anyone with it can still open the site (${site.shareUrl}).` : "";
+  if (empty) {
+    return site.restricted ? `Only you: nobody else can open it.${share2}` : `Private: ${privateAudience2} can open it.`;
+  }
   if (emails2.length === 0 && groups2.every((g) => g.deleted)) {
     const refs = groups2.map((g) => g.slug).join(", ");
     return `Restricted: only you can open it. Its audience names only ${groups2.length === 1 ? "a deleted group" : "deleted groups"} (${refs}), which let nobody in: add people or groups, or clear it.${share2}`;
@@ -92,15 +180,15 @@ function sharedVia(site) {
 }
 var describeSharedSite = (site) => `- ${site.name}: ${site.url} (shared by ${site.owner}, through ${sharedVia(site)}${site.reviewUrl ? `; review: ${site.reviewUrl}` : ""})`;
 
-// ../../packages/shared/src/manifest.ts
-import { z as z2 } from "zod";
-
 // ../../packages/shared/src/limits.ts
 var MAX_DEPLOY_BYTES = 100 * 1024 * 1024;
 var MAX_FILE_BYTES = 25 * 1024 * 1024;
 var MAX_FILES = 5e3;
 var MAX_PATH_LENGTH = 1024;
 
+// ../../packages/shared/src/manifest.ts
+import { z as z3 } from "zod";
+
 // ../../packages/shared/src/secrets.ts
 var SECRET_SCAN_MAX_FILE_BYTES = MAX_FILE_BYTES;
 var BINARY_SNIFF_BYTES = 8192;
@@ -291,246 +379,464 @@ function isValidSitePath(path3) {
   if (path3.startsWith("/") || path3.includes("\\") || path3.includes("\0")) return false;
   return path3.split("/").every((seg) => seg !== "" && !seg.startsWith("."));
 }
-var ManifestFileSchema = z2.object({
-  path: z2.string().refine(isValidSitePath, "invalid path (dotfiles are never published)").refine((p) => !isSecretPath(p), "secret file (keys, certificates, credentials) never published"),
-  sha256: z2.string().regex(/^[a-f0-9]{64}$/),
-  size: z2.number().int().min(0).max(MAX_FILE_BYTES),
-  contentType: z2.string().min(1).max(255)
+var ManifestFileSchema = z3.object({
+  path: z3.string().refine(isValidSitePath, "invalid path (dotfiles are never published)").refine((p) => !isSecretPath(p), "secret file (keys, certificates, credentials) never published"),
+  sha256: z3.string().regex(/^[a-f0-9]{64}$/),
+  size: z3.number().int().min(0).max(MAX_FILE_BYTES),
+  contentType: z3.string().min(1).max(255)
+});
+var manifestOf = (files) => z3.object({ files }).refine((m) => new Set(m.files.map((f) => f.path)).size === m.files.length, "duplicate paths").refine((m) => m.files.reduce((n, f) => n + f.size, 0) <= MAX_DEPLOY_BYTES, "deploy too large");
+var ManifestSchema = manifestOf(z3.array(ManifestFileSchema).min(1).max(MAX_FILES));
+var DeployManifestSchema = manifestOf(z3.array(ManifestFileSchema).max(MAX_FILES));
+
+// ../../packages/shared/src/publish-path.ts
+import { z as z4 } from "zod";
+function normalizePublishPath(raw) {
+  const path3 = raw.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  return isValidSitePath(path3) ? path3 : null;
+}
+var PublishPathSchema = z4.string().transform((raw, ctx) => {
+  const path3 = normalizePublishPath(raw);
+  if (path3 === null) {
+    ctx.addIssue({
+      code: "custom",
+      message: "path must be a folder of the site, like 30-10-26 or reports/2026 (no dotfiles)"
+    });
+    return z4.NEVER;
+  }
+  return path3;
+});
+
+// ../../packages/shared/src/site-roles.ts
+import { z as z5 } from "zod";
+var OWNER_EMAILS_MAX = 20;
+var OWNER_GROUPS_MAX = 5;
+var PUBLISHER_EMAILS_MAX = 50;
+var PUBLISHER_GROUPS_MAX = 10;
+var SiteRoleSchema = z5.enum(["owner", "publisher", "admin"]);
+var SiteRoleMembersSchema = z5.object({
+  emails: z5.array(AudienceEmailSchema),
+  groups: z5.array(AudienceGroupSchema).default([])
+});
+var roleInput = (what, emailsMax, groupsMax) => z5.object({
+  emails: z5.array(z5.string().trim().toLowerCase().min(3).max(254)).max(emailsMax, `A site has at most ${emailsMax} ${what} addresses`),
+  groups: z5.array(z5.string().trim().toLowerCase().min(1).max(100)).max(groupsMax, `A site names at most ${groupsMax} ${what} groups`).default([])
 });
-var ManifestSchema = z2.object({ files: z2.array(ManifestFileSchema).min(1).max(MAX_FILES) }).refine((m) => new Set(m.files.map((f) => f.path)).size === m.files.length, "duplicate paths").refine((m) => m.files.reduce((n, f) => n + f.size, 0) <= MAX_DEPLOY_BYTES, "deploy too large");
+var OwnersInputSchema = roleInput("owner", OWNER_EMAILS_MAX, OWNER_GROUPS_MAX);
+var PublishersInputSchema = roleInput(
+  "publisher",
+  PUBLISHER_EMAILS_MAX,
+  PUBLISHER_GROUPS_MAX
+);
+var editRoleInput = (current, change) => editAudienceInput(current, change);
+function whoHolds(members2) {
+  const parts = [
+    ...(members2?.emails ?? []).map((e) => e.guest ? `${e.email} (guest)` : e.email),
+    ...(members2?.groups ?? []).map((g) => `the group ${groupLabel(g)}`)
+  ];
+  return parts.length ? parts.join(", ") : "nobody";
+}
+var roleLabel = (role) => role === "publisher" ? "a publisher" : `an ${role}`;
+function describeRoles(site) {
+  if (!site.owners) return "";
+  const you = site.role ? ` You are ${roleLabel(site.role)}.` : "";
+  return `Owners: ${whoHolds(site.owners)}. Publishers: ${whoHolds(site.publishers)}.${you}`;
+}
+
+// ../../packages/shared/src/thumbnails.ts
+import { z as z6 } from "zod";
+var THUMBNAIL_MAX_BYTES = 200 * 1024;
+var ThumbnailSchema = z6.object({ versionId: z6.string(), updatedAt: z6.string() });
+var ThumbnailStampSchema = z6.object({ updatedAt: z6.string() });
 
 // ../../packages/shared/src/api.ts
-var VisibilitySchema = z3.enum(["private", "public"]);
-var MeSchema = z3.object({
-  email: z3.string(),
-  name: z3.string(),
-  picture: z3.string().nullable(),
-  userSlug: z3.string(),
+var VisibilitySchema = z7.enum(["private", "public"]);
+var MeSchema = z7.object({
+  email: z7.string(),
+  name: z7.string(),
+  picture: z7.string().nullable(),
+  userSlug: z7.string(),
   /** one of the instance's admins (servers from before admins don't say: false) */
-  admin: z3.boolean().default(false),
+  admin: z7.boolean().default(false),
+  /** a guest: someone invited from outside who reviews what is shared with them, nothing else */
+  guest: z7.boolean().default(false),
   /** while an admin impersonates this user: the admin (browser sessions only) */
-  impersonator: z3.string().optional(),
+  impersonator: z7.string().optional(),
   /** …and when the impersonation lapses */
-  impersonationEndsAt: z3.string().optional()
+  impersonationEndsAt: z7.string().optional()
 });
-var SiteSchema = z3.object({
-  name: z3.string(),
-  url: z3.string(),
+var SiteSchema = z7.object({
+  name: z7.string(),
+  url: z7.string(),
   visibility: VisibilitySchema,
-  spa: z3.boolean(),
-  archived: z3.boolean(),
-  currentVersionId: z3.string().nullable(),
-  shareUrl: z3.string().nullable(),
-  /** private with an audience: only the owner and the people in it can open it */
-  restricted: z3.boolean().default(false),
+  spa: z7.boolean(),
+  archived: z7.boolean(),
+  currentVersionId: z7.string().nullable(),
+  shareUrl: z7.string().nullable(),
+  /** who can open it (access.ts); servers before access levels omit it (`siteAccessLevel`) */
+  access: AccessLevelSchema.optional(),
+  /** private and limited to the owner and the audience (an empty one: the owner alone) */
+  restricted: z7.boolean().default(false),
   /** how many addresses and groups the audience names (kept, and ignored, while public) */
-  audienceSize: z3.number().default(0),
+  audienceSize: z7.number().default(0),
   /** how many of those are groups */
-  audienceGroups: z3.number().default(0),
-  createdAt: z3.string(),
-  updatedAt: z3.string()
+  audienceGroups: z7.number().default(0),
+  /** the caller's role on it (site-roles.ts); servers before site roles omit it */
+  role: SiteRoleSchema.optional(),
+  /** the caller may pull its current version (`pull` capability; servers without it omit it) */
+  canPull: z7.boolean().optional(),
+  /** its home page's thumbnail, when it has one (`thumbnails` capability; thumbnails.ts) */
+  thumbnail: ThumbnailSchema.optional(),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
+var SiteWithAudienceSchema = SiteSchema.extend({
+  audience: AudienceSchema.optional(),
+  owners: SiteRoleMembersSchema.optional(),
+  publishers: SiteRoleMembersSchema.optional()
+});
+var VersionSchema = z7.object({
+  id: z7.string(),
+  fileCount: z7.number(),
+  totalBytes: z7.number(),
+  /** who published it (email); absent on versions published before it was recorded */
+  publishedBy: z7.string().optional(),
+  /**
+   * A path publish (`pathPublish` capability): the folder it replaced (`30-10-26`, shown as
+   * `/30-10-26/`), and the version it carried the rest of the site forward from (absent when the
+   * site had none)
+   */
+  path: z7.string().optional(),
+  base: z7.string().optional(),
+  createdAt: z7.string()
 });
-var SiteWithAudienceSchema = SiteSchema.extend({ audience: AudienceSchema.optional() });
-var VersionSchema = z3.object({
-  id: z3.string(),
-  fileCount: z3.number(),
-  totalBytes: z3.number(),
-  createdAt: z3.string()
+var SiteDetailSchema = SiteWithAudienceSchema.extend({
+  owner: z7.string().optional(),
+  versions: z7.array(VersionSchema)
 });
-var SiteDetailSchema = SiteWithAudienceSchema.extend({ versions: z3.array(VersionSchema) });
-var SiteListSchema = z3.object({ sites: z3.array(SiteSchema) });
-var SharedSiteSchema = z3.object({
-  name: z3.string(),
-  url: z3.string(),
+var SiteListSchema = z7.object({ sites: z7.array(SiteSchema) });
+var SharedSiteSchema = z7.object({
+  name: z7.string(),
+  url: z7.string(),
   /** the site's review page (`comments` capability) */
-  reviewUrl: z3.string().optional(),
-  owner: z3.string(),
+  reviewUrl: z7.string().optional(),
+  owner: z7.string(),
   /** how the caller is in the audience: by address, and through which of their groups (slugs) */
-  via: z3.object({ direct: z3.boolean(), groups: z3.array(z3.string()) }),
-  createdAt: z3.string(),
-  updatedAt: z3.string()
+  via: z7.object({ direct: z7.boolean(), groups: z7.array(z7.string()) }),
+  /** when its thumbnail was taken, when it has one (`thumbnails` capability) */
+  thumbnail: ThumbnailStampSchema.optional(),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
 });
-var SharedSiteListSchema = z3.object({ sites: z3.array(SharedSiteSchema) });
-var SiteFileSchema = z3.object({
-  path: z3.string(),
-  size: z3.number(),
-  contentType: z3.string()
+var SharedSiteListSchema = z7.object({ sites: z7.array(SharedSiteSchema) });
+var SiteFileSchema = z7.object({
+  path: z7.string(),
+  size: z7.number(),
+  contentType: z7.string()
 });
-var VersionFilesSchema = z3.object({
-  versionId: z3.string(),
-  files: z3.array(SiteFileSchema),
-  totalBytes: z3.number(),
-  generatedIndex: z3.boolean()
+var VersionFilesSchema = z7.object({
+  versionId: z7.string(),
+  files: z7.array(SiteFileSchema),
+  totalBytes: z7.number(),
+  generatedIndex: z7.boolean()
 });
-var NameCheckSchema = z3.object({
-  name: z3.string(),
-  status: z3.enum(["available", "yours", "taken", "invalid"]),
-  suggestions: z3.array(z3.string())
+var PULL_URL_TTL_SECONDS = 15 * 60;
+var PullFileSchema = SiteFileSchema.extend({
+  /** hex SHA-256 of the bytes */
+  sha256: z7.string(),
+  /** a signed GET for the bytes, good for PULL_URL_TTL_SECONDS */
+  url: z7.string()
 });
-var DeployRequestSchema = z3.object({
-  manifest: ManifestSchema,
-  spa: z3.boolean().optional(),
-  visibility: VisibilitySchema.optional()
+var PullResponseSchema = z7.object({
+  versionId: z7.string(),
+  path: z7.string().optional(),
+  files: z7.array(PullFileSchema),
+  /** when the URLs stop working */
+  expiresAt: z7.string()
 });
-var UploadSchema = z3.object({
-  path: z3.string(),
-  url: z3.string(),
+var NameCheckSchema = z7.object({
+  name: z7.string(),
+  status: z7.enum(["available", "yours", "taken", "invalid"]),
+  suggestions: z7.array(z7.string())
+});
+var WhySiteSchema = z7.object({ url: z7.string().nullable() });
+var DeployRequestSchema = z7.object({
+  manifest: DeployManifestSchema,
+  path: PublishPathSchema.optional(),
+  base: z7.string().min(1).max(100).optional(),
+  partial: z7.boolean().optional(),
+  remove: z7.array(z7.string().min(1).max(MAX_PATH_LENGTH)).max(MAX_FILES).optional(),
+  spa: z7.boolean().optional(),
+  visibility: VisibilitySchema.optional(),
+  access: AccessLevelSchema.optional(),
+  audience: AudienceInputSchema.optional()
+}).superRefine((req, ctx) => {
+  const issue = (message) => ctx.addIssue({ code: "custom", message });
+  if (req.manifest.files.length === 0 && !(req.partial && req.remove?.length)) {
+    issue("manifest.files: at least one file");
+  }
+  if (req.partial && req.base === void 0) issue("`partial` needs `base`");
+  if (req.remove !== void 0 && !req.partial) issue("`remove` needs `partial: true`");
+  if (req.base !== void 0 && req.path !== void 0) issue("Pass `base` or `path`, not both");
+});
+var UploadSchema = z7.object({
+  path: z7.string(),
+  url: z7.string(),
   /** headers the client must send with the PUT (they are part of the signature) */
-  headers: z3.record(z3.string(), z3.string())
+  headers: z7.record(z7.string(), z7.string())
 });
-var DeployResponseSchema = z3.discriminatedUnion("status", [
+var DeployResponseSchema = z7.discriminatedUnion("status", [
   /** content identical to the current version — nothing happened */
-  z3.object({ status: z3.literal("unchanged"), versionId: z3.string(), site: SiteSchema }),
+  z7.object({ status: z7.literal("unchanged"), versionId: z7.string(), site: SiteSchema }),
   /** this content was deployed before — site now points at that version again */
-  z3.object({ status: z3.literal("repointed"), versionId: z3.string(), site: SiteSchema }),
+  z7.object({ status: z7.literal("repointed"), versionId: z7.string(), site: SiteSchema }),
   /** new content — PUT every upload, then POST /api/sites/:name/deploys/:versionId/finalize */
-  z3.object({
-    status: z3.literal("upload"),
-    versionId: z3.string(),
-    uploads: z3.array(UploadSchema)
+  z7.object({
+    status: z7.literal("upload"),
+    versionId: z7.string(),
+    uploads: z7.array(UploadSchema)
   })
 ]);
-var FinalizeResponseSchema = z3.object({
-  status: z3.literal("live"),
-  versionId: z3.string(),
-  site: SiteSchema
+var FinalizeResponseSchema = z7.object({
+  status: z7.literal("live"),
+  versionId: z7.string(),
+  site: SiteSchema,
+  /** this deploy made the site live for the first time (a new site, its access just set) */
+  first: z7.boolean().optional()
 });
-var RollbackRequestSchema = z3.object({ versionId: z3.string() });
-var UpdateSiteRequestSchema = z3.object({
+var RollbackRequestSchema = z7.object({ versionId: z7.string() });
+var UpdateSiteRequestSchema = z7.object({
+  access: AccessLevelSchema.optional(),
   visibility: VisibilitySchema.optional(),
-  spa: z3.boolean().optional(),
-  audience: AudienceInputSchema.optional()
+  spa: z7.boolean().optional(),
+  audience: AudienceInputSchema.optional(),
+  /** the whole new list of owners (site-roles.ts): owners only */
+  owners: OwnersInputSchema.optional(),
+  /** the whole new list of publishers (site-roles.ts): owners only */
+  publishers: PublishersInputSchema.optional()
 });
-var ApiKeySchema = z3.object({
-  id: z3.string(),
-  name: z3.string(),
-  createdAt: z3.string(),
-  lastUsedAt: z3.string().nullable()
+var ApiKeySchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  createdAt: z7.string(),
+  lastUsedAt: z7.string().nullable()
 });
-var ApiKeyListSchema = z3.object({ keys: z3.array(ApiKeySchema) });
-var ErrorEnvelopeSchema = z3.object({
-  error: z3.object({ code: z3.string(), message: z3.string() })
+var ApiKeyListSchema = z7.object({ keys: z7.array(ApiKeySchema) });
+var ErrorEnvelopeSchema = z7.object({
+  error: z7.object({ code: z7.string(), message: z7.string() })
 });
-var ShareResponseSchema = z3.object({ shareUrl: z3.string() });
-var ConnectionSchema = z3.object({
-  id: z3.string(),
-  clientName: z3.string(),
+var ShareResponseSchema = z7.object({ shareUrl: z7.string() });
+var ConnectionSchema = z7.object({
+  id: z7.string(),
+  clientName: z7.string(),
   /** host the client identifies as (CIMD client_id host or redirect URI host) */
-  clientHost: z3.string().nullable(),
-  createdAt: z3.string(),
-  lastUsedAt: z3.string().nullable()
+  clientHost: z7.string().nullable(),
+  createdAt: z7.string(),
+  lastUsedAt: z7.string().nullable()
 });
-var ConnectionListSchema = z3.object({ connections: z3.array(ConnectionSchema) });
-var OAuthRequestInfoSchema = z3.object({
-  clientName: z3.string(),
-  clientUri: z3.string().nullable(),
+var ConnectionListSchema = z7.object({ connections: z7.array(ConnectionSchema) });
+var OAuthRequestInfoSchema = z7.object({
+  clientName: z7.string(),
+  clientUri: z7.string().nullable(),
   /** host of the CIMD client_id URL, when the client identified itself that way */
-  clientIdHost: z3.string().nullable(),
-  redirectHost: z3.string(),
+  clientIdHost: z7.string().nullable(),
+  redirectHost: z7.string(),
   /** true when the code goes to a loopback address (any local program could be asking) */
-  loopback: z3.boolean(),
-  scopes: z3.array(z3.string()),
-  email: z3.string()
+  loopback: z7.boolean(),
+  scopes: z7.array(z7.string()),
+  email: z7.string()
 });
-var OAuthDecisionSchema = z3.object({ redirectUrl: z3.string() });
-var AdminUserSchema = z3.object({
-  email: z3.string(),
-  name: z3.string(),
-  picture: z3.string().nullable(),
-  userSlug: z3.string(),
-  createdAt: z3.string().nullable(),
-  lastSignInAt: z3.string().nullable(),
+var OAuthDecisionSchema = z7.object({ redirectUrl: z7.string() });
+var AdminUserSchema = z7.object({
+  email: z7.string(),
+  name: z7.string(),
+  picture: z7.string().nullable(),
+  userSlug: z7.string(),
+  createdAt: z7.string().nullable(),
+  lastSignInAt: z7.string().nullable(),
   /** sites the user holds, archived ones included */
-  siteCount: z3.number(),
-  admin: z3.boolean()
+  siteCount: z7.number(),
+  admin: z7.boolean(),
+  /** outside the email policy, on a live guest invitation (see GET /api/admin/invitations) */
+  guest: z7.boolean()
 });
-var AdminUserListSchema = z3.object({
-  users: z3.array(AdminUserSchema),
+var AdminUserListSchema = z7.object({
+  users: z7.array(AdminUserSchema),
   /** pass back as `cursor` for the next page; null: no more */
-  cursor: z3.string().nullable()
+  cursor: z7.string().nullable()
 });
-var AuditEntrySchema = z3.object({
-  id: z3.string(),
-  at: z3.string(),
-  action: z3.enum(["impersonation.start", "impersonation.stop"]),
-  actor: z3.string(),
-  target: z3.string(),
-  until: z3.string().optional(),
-  lapsed: z3.boolean().optional()
+var AdminSiteSchema = z7.object({
+  name: z7.string(),
+  url: z7.string(),
+  owner: z7.string(),
+  access: AccessLevelSchema,
+  archived: z7.boolean(),
+  /** it has a current version */
+  live: z7.boolean(),
+  /** when its thumbnail was taken, when it has one (`thumbnails` capability) */
+  thumbnail: ThumbnailStampSchema.optional(),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
+var AdminSiteListSchema = z7.object({
+  sites: z7.array(AdminSiteSchema),
+  /** the list stops at the server's ceiling: there are more sites than it holds */
+  truncated: z7.boolean()
+});
+var SETTING_GROUPS = [
+  "sign_in",
+  "sites",
+  "branding",
+  "features",
+  "mail",
+  "platform"
+];
+var SettingValueSchema = z7.union([z7.string(), z7.number(), z7.boolean(), z7.array(z7.string())]).nullable();
+var AdminSettingsSchema = z7.object({
+  settings: z7.array(
+    z7.object({
+      key: z7.string(),
+      group: z7.enum(SETTING_GROUPS),
+      value: SettingValueSchema,
+      set: z7.boolean()
+    })
+  ),
+  secrets: z7.array(
+    z7.object({ name: z7.string(), group: z7.enum(SETTING_GROUPS), set: z7.boolean() }).strict()
+  )
+});
+var InvitationRoleSchema = z7.enum(["member", "guest"]);
+var InvitationViaSchema = z7.enum(["admin", "share", "group"]);
+var AdminInvitationSchema = z7.object({
+  email: z7.string(),
+  role: InvitationRoleSchema,
+  /** who invited them: the admin, or whoever shared */
+  invitedBy: z7.string(),
+  via: InvitationViaSchema,
+  createdAt: z7.string(),
+  /** set once revoked; the invitation is kept as the record */
+  revokedAt: z7.string().nullable(),
+  /** their first sign-in has happened */
+  signedIn: z7.boolean(),
+  lastSignInAt: z7.string().nullable()
+});
+var AdminInvitationListSchema = z7.object({
+  invitations: z7.array(AdminInvitationSchema),
+  /** pass back as `cursor` for the next page; null: no more */
+  cursor: z7.string().nullable()
+});
+var InviteRequestSchema = z7.object({
+  email: z7.string().trim().toLowerCase().min(3).max(254)
+});
+var AdminInviteResultSchema = z7.object({
+  invitation: AdminInvitationSchema,
+  /** the provider took the email */
+  sent: z7.boolean(),
+  /** why it didn't, in words (`rejected: sender not verified`) */
+  error: z7.string().nullable()
+});
+var AuditEntrySchema = z7.object({
+  id: z7.string(),
+  at: z7.string(),
+  action: z7.enum([
+    "impersonation.start",
+    "impersonation.stop",
+    "invitation.create",
+    "invitation.revoke",
+    "site.change",
+    "site.open"
+  ]),
+  actor: z7.string(),
+  /** the person, or for site.change and site.open the site's name */
+  target: z7.string(),
+  /** site.change, site.open: the site's owner */
+  owner: z7.string().optional(),
+  /** site.change: what the admin did (a policy action, e.g. `site.archive`) */
+  change: z7.string().optional(),
+  /** invitation.create: how it came about (an admin's invite, a share, a group) */
+  via: InvitationViaSchema.optional(),
+  /** invitation.create: what it lets them be */
+  role: InvitationRoleSchema.optional(),
+  until: z7.string().optional(),
+  lapsed: z7.boolean().optional()
+});
+var AuditListSchema = z7.object({ entries: z7.array(AuditEntrySchema) });
+var ImpersonateRequestSchema = z7.object({ email: z7.string().trim().toLowerCase().min(3) });
+var SignInLinkRequestSchema = z7.object({
+  email: z7.string().trim().toLowerCase().min(3).max(254),
+  return: z7.string().max(2048).optional()
 });
-var AuditListSchema = z3.object({ entries: z3.array(AuditEntrySchema) });
-var ImpersonateRequestSchema = z3.object({ email: z3.string().trim().toLowerCase().min(3) });
 
 // ../../packages/shared/src/comments.ts
-import { z as z4 } from "zod";
+import { z as z8 } from "zod";
 var COMMENT_MAX_CHARS = 4e3;
 var COMMENT_PATH_MAX = 1024;
-var CommentAuthorSchema = z4.discriminatedUnion("kind", [
-  z4.object({ kind: z4.literal("user"), email: z4.string() }),
-  z4.object({ kind: z4.literal("guest"), name: z4.string() })
+var CommentAuthorSchema = z8.discriminatedUnion("kind", [
+  z8.object({ kind: z8.literal("user"), email: z8.string() }),
+  z8.object({ kind: z8.literal("guest"), name: z8.string() })
 ]);
 var ANCHOR_SELECTOR_MAX = 512;
 var ANCHOR_QUOTE_MAX = 500;
-var px = z4.number().finite().min(-1e7).max(1e7);
-var percent = z4.number().min(0).max(100);
-var CommentAnchorSchema = z4.object({
+var px = z8.number().finite().min(-1e7).max(1e7);
+var percent = z8.number().min(0).max(100);
+var CommentAnchorSchema = z8.object({
   x: percent,
   y: percent,
-  selector: z4.string().min(1).max(ANCHOR_SELECTOR_MAX).optional(),
+  selector: z8.string().min(1).max(ANCHOR_SELECTOR_MAX).optional(),
   ex: percent.optional(),
   ey: percent.optional(),
   docX: px.optional(),
   docY: px.optional(),
   scrollX: px.optional(),
   scrollY: px.optional(),
-  vw: z4.number().finite().min(0).max(1e5).optional(),
-  vh: z4.number().finite().min(0).max(1e5).optional(),
-  hash: z4.string().max(COMMENT_PATH_MAX).optional(),
+  vw: z8.number().finite().min(0).max(1e5).optional(),
+  vh: z8.number().finite().min(0).max(1e5).optional(),
+  hash: z8.string().max(COMMENT_PATH_MAX).optional(),
   ew: percent.optional(),
   eh: percent.optional(),
-  docW: z4.number().finite().min(0).max(1e7).optional(),
-  docH: z4.number().finite().min(0).max(1e7).optional(),
-  quote: z4.string().min(1).max(ANCHOR_QUOTE_MAX).optional()
+  docW: z8.number().finite().min(0).max(1e7).optional(),
+  docH: z8.number().finite().min(0).max(1e7).optional(),
+  quote: z8.string().min(1).max(ANCHOR_QUOTE_MAX).optional()
 });
-var CommentSchema = z4.object({
-  id: z4.string(),
+var CommentSchema = z8.object({
+  id: z8.string(),
   /** the thread this replies to; null for the comment that starts a thread */
-  parentId: z4.string().nullable(),
+  parentId: z8.string().nullable(),
   /** the page, as normalizeCommentPath() writes it ('/', '/docs/', '/about.html') */
-  path: z4.string(),
+  path: z8.string(),
   /** the version the site was serving when the comment was made (null: none was) */
-  versionId: z4.string().nullable(),
+  versionId: z8.string().nullable(),
   anchor: CommentAnchorSchema.nullable(),
-  body: z4.string(),
+  body: z8.string(),
   author: CommentAuthorSchema,
-  createdAt: z4.string(),
+  createdAt: z8.string(),
   /** threads only: when and by whom it was resolved (null: open) */
-  resolvedAt: z4.string().nullable(),
+  resolvedAt: z8.string().nullable(),
   resolvedBy: CommentAuthorSchema.nullable(),
   /** whether the caller may delete it (policy's answer, so clients don't guess) */
-  canDelete: z4.boolean()
+  canDelete: z8.boolean()
 });
-var CommentListSchema = z4.object({
-  site: z4.object({
-    name: z4.string(),
-    url: z4.string(),
-    currentVersionId: z4.string().nullable()
+var CommentListSchema = z8.object({
+  site: z8.object({
+    name: z8.string(),
+    url: z8.string(),
+    currentVersionId: z8.string().nullable()
   }),
-  comments: z4.array(CommentSchema),
-  can: z4.object({
-    create: z4.boolean(),
-    resolve: z4.boolean(),
+  comments: z8.array(CommentSchema),
+  can: z8.object({
+    create: z8.boolean(),
+    resolve: z8.boolean(),
     /** delete anyone's comment (everyone may delete their own) */
-    deleteAny: z4.boolean()
+    deleteAny: z8.boolean()
   })
 });
-var CreateCommentRequestSchema = z4.object({
-  body: z4.string().trim().min(1).max(COMMENT_MAX_CHARS),
-  path: z4.string().max(COMMENT_PATH_MAX).optional(),
-  parentId: z4.string().min(1).max(100).optional(),
+var CreateCommentRequestSchema = z8.object({
+  body: z8.string().trim().min(1).max(COMMENT_MAX_CHARS),
+  path: z8.string().max(COMMENT_PATH_MAX).optional(),
+  parentId: z8.string().min(1).max(100).optional(),
   anchor: CommentAnchorSchema.optional()
 });
-var UpdateCommentRequestSchema = z4.object({ resolved: z4.boolean() });
+var UpdateCommentRequestSchema = z8.object({ resolved: z8.boolean() });
 function commentThreads(comments) {
   const threads = /* @__PURE__ */ new Map();
   for (const c of comments) {
@@ -545,17 +851,18 @@ function authorLabel(author) {
   return author.kind === "user" ? author.email : `${author.name} (guest)`;
 }
 function reviewUrl(appOrigin, name, path3) {
-  const base = `${appOrigin.replace(/\/+$/, "")}/review/${name === "<name>" ? name : encodeURIComponent(name)}`;
-  return path3 && path3 !== "/" ? `${base}?path=${encodeURIComponent(path3)}` : base;
+  const base2 = `${appOrigin.replace(/\/+$/, "")}/review/${name === "<name>" ? name : encodeURIComponent(name)}`;
+  return path3 && path3 !== "/" ? `${base2}?path=${encodeURIComponent(path3)}` : base2;
 }
 
 // ../../packages/shared/src/distribution.ts
 var CLI_PACKAGE = "@nearform/fling";
 var REPO_SLUG = "nearform/fling";
 var DEFAULT_INSTALL_COMMAND = `npm install -g ${CLI_PACKAGE}`;
+var REPO_URL = `https://github.com/${REPO_SLUG}`;
 
 // ../../packages/shared/src/groups.ts
-import { z as z5 } from "zod";
+import { z as z9 } from "zod";
 var GROUP_MEMBERS_MAX = 500;
 var GROUP_SLUG_MAX = 50;
 var GROUP_NAME_MAX = 100;
@@ -564,30 +871,30 @@ function isValidGroupSlug(slug) {
   return slug.length <= GROUP_SLUG_MAX && GROUP_SLUG_RE.test(slug) && !slug.includes("--");
 }
 var GROUP_SLUG_RULES = `1-${GROUP_SLUG_MAX} lowercase letters, digits and single hyphens`;
-var GroupSlugSchema = z5.string().trim().toLowerCase().refine(isValidGroupSlug, `A group's slug is ${GROUP_SLUG_RULES}`);
-var GroupNameSchema = z5.string().trim().min(1).max(GROUP_NAME_MAX);
-var memberEmails = z5.array(z5.string().trim().toLowerCase().min(3).max(254)).max(GROUP_MEMBERS_MAX, `A group holds at most ${GROUP_MEMBERS_MAX} people`);
-var GroupSummarySchema = z5.object({
-  slug: z5.string(),
-  name: z5.string(),
+var GroupSlugSchema = z9.string().trim().toLowerCase().refine(isValidGroupSlug, `A group's slug is ${GROUP_SLUG_RULES}`);
+var GroupNameSchema = z9.string().trim().min(1).max(GROUP_NAME_MAX);
+var memberEmails = z9.array(z9.string().trim().toLowerCase().min(3).max(254)).max(GROUP_MEMBERS_MAX, `A group holds at most ${GROUP_MEMBERS_MAX} people`);
+var GroupSummarySchema = z9.object({
+  slug: z9.string(),
+  name: z9.string(),
   /** the email of the user who made it, the only one who may change it */
-  owner: z5.string(),
-  size: z5.number(),
-  createdAt: z5.string(),
-  updatedAt: z5.string()
+  owner: z9.string(),
+  size: z9.number(),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
 });
-var GroupListSchema = z5.object({ groups: z5.array(GroupSummarySchema) });
+var GroupListSchema = z9.object({ groups: z9.array(GroupSummarySchema) });
 var GroupDetailSchema = GroupSummarySchema.extend({
-  members: z5.array(AudienceEmailSchema),
-  canManage: z5.boolean()
+  members: z9.array(AudienceEmailSchema),
+  canManage: z9.boolean()
 });
-var CreateGroupRequestSchema = z5.object({
+var CreateGroupRequestSchema = z9.object({
   slug: GroupSlugSchema,
   name: GroupNameSchema,
   members: memberEmails.optional()
 });
-var UpdateGroupRequestSchema = z5.object({ name: GroupNameSchema });
-var GroupMembersRequestSchema = z5.object({
+var UpdateGroupRequestSchema = z9.object({ name: GroupNameSchema });
+var GroupMembersRequestSchema = z9.object({
   add: memberEmails.optional(),
   remove: memberEmails.optional()
 });
@@ -642,48 +949,67 @@ function siteUrl(label, sitesDomain, protocol = "https:") {
 }
 
 // ../../packages/shared/src/instance.ts
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 var INSTANCE_METADATA_PATH = "/.well-known/fling";
 var HEX_COLOR_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
-var color = z6.string().regex(HEX_COLOR_RE);
-var InstanceAuthSchema = z6.looseObject({
-  kind: z6.string().min(1),
-  displayName: z6.string().min(1),
-  issuer: z6.string().optional(),
-  emailDomains: z6.array(z6.string()).default([]),
-  invitedEmails: z6.boolean().optional()
+var color = z10.string().regex(HEX_COLOR_RE);
+var SignInProviderSchema = z10.looseObject({
+  /** `google` or `oidc` today; clients pass it back as is. */
+  id: z10.string().min(1),
+  /** "Sign in with <displayName>". */
+  displayName: z10.string().min(1),
+  issuer: z10.string().optional()
+});
+var InstanceAuthSchema = z10.looseObject({
+  kind: z10.string().min(1),
+  displayName: z10.string().min(1),
+  issuer: z10.string().optional(),
+  providers: z10.array(SignInProviderSchema).optional(),
+  emailDomains: z10.array(z10.string()).default([]),
+  invitedEmails: z10.boolean().optional()
 });
-var BrandColorsSchema = z6.looseObject({
+var BrandColorsSchema = z10.looseObject({
   primary: color.optional(),
   primaryContent: color.optional(),
   accent: color.optional(),
   ink: color.optional(),
   highlight: color.optional()
 });
-var InstanceBrandSchema = z6.looseObject({
+var InstanceBrandSchema = z10.looseObject({
   /** https: or data: URL of the logo mark shown before the name (light theme). */
-  logoUrl: z6.string().optional(),
+  logoUrl: z10.string().optional(),
   /** The same for the dark theme; defaults to `logoUrl`. */
-  logoDarkUrl: z6.string().optional(),
-  faviconUrl: z6.string().optional(),
+  logoDarkUrl: z10.string().optional(),
+  faviconUrl: z10.string().optional(),
   colors: BrandColorsSchema.default({})
 });
-var InstanceMetadataSchema = z6.looseObject({
-  version: z6.number().int().min(1),
+var InstanceMetadataSchema = z10.looseObject({
+  version: z10.number().int().min(1),
   /** Display name, e.g. "Fling". */
-  name: z6.string().min(1),
+  name: z10.string().min(1),
   /** e.g. `https://fling.example.test` (no trailing slash) */
-  appOrigin: z6.string().url(),
+  appOrigin: z10.string().url(),
   /** host[:port] sites hang off: a site is `<name>.<sitesDomain>` */
-  sitesDomain: z6.string().min(1),
-  siteScheme: z6.enum(["http", "https"]),
+  sitesDomain: z10.string().min(1),
+  siteScheme: z10.enum(["http", "https"]),
   auth: InstanceAuthSchema,
   brand: InstanceBrandSchema.default({ colors: {} }),
   /** Feature flags: a client hides what is missing or false. */
-  capabilities: z6.record(z6.string(), z6.boolean()).default({}),
+  capabilities: z10.record(z10.string(), z10.boolean()).default({}),
   /** How to install the CLI, e.g. `npm install -g <package>`. */
-  installCommand: z6.string().min(1)
+  installCommand: z10.string().min(1),
+  /**
+   * The access level a new site gets when its first deploy names none (`SITE_DEFAULT_ACCESS`).
+   * Missing (older servers) or unknown: `members` (`defaultAccessOf`).
+   */
+  defaultAccess: DefaultAccessLevelSchema.optional().catch(void 0),
+  /**
+   * The Fling release the server runs, e.g. `0.7.0` (the root package.json's version, built in).
+   * Missing on servers built before releases were stamped.
+   */
+  release: z10.string().min(1).optional().catch(void 0)
 });
+var defaultAccessOf = (instance) => instance?.defaultAccess ?? LEGACY_DEFAULT_ACCESS;
 function instanceSitesPattern(instance) {
   return `${instance.siteScheme}://<name>.${instance.sitesDomain}`;
 }
@@ -706,22 +1032,22 @@ function instanceMetadataUrl(serverUrl) {
 }
 
 // ../../packages/shared/src/kvs.ts
-import { z as z7 } from "zod";
+import { z as z11 } from "zod";
 
 // ../../packages/shared/src/route-keys.ts
 var SITE_PASS_TTL_SECONDS = 5 * 60;
 
 // ../../packages/shared/src/kvs.ts
-var KvsSiteValueSchema = z7.object({
+var KvsSiteValueSchema = z11.object({
   /** siteId — S3 prefix is `sites/<id>/<v>/` */
-  id: z7.string(),
+  id: z11.string(),
   /** current versionId */
-  v: z7.string(),
-  vis: z7.enum(["private", "public"]),
+  v: z11.string(),
+  vis: z11.enum(["private", "public"]),
   /** serve /index.html for unknown extensionless paths */
-  spa: z7.boolean(),
+  spa: z11.boolean(),
   /** present when the site is restricted (private with an audience): the edge wants a site pass */
-  r: z7.literal(1).optional()
+  r: z11.literal(1).optional()
 });
 
 // ../../packages/shared/src/listing.ts
@@ -760,7 +1086,7 @@ ${rows}
 </ul>`;
   }).join("\n");
   const body = pages.length ? sections : '<p class="empty">No HTML pages in this fling.</p>';
-  const count = `${pages.length} page${pages.length === 1 ? "" : "s"}`;
+  const count2 = `${pages.length} page${pages.length === 1 ? "" : "s"}`;
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -795,7 +1121,7 @@ ${rows}
 </head>
 <body>
 <main>
-<header><h1>${escapeHtml(siteName2)}</h1><p>${count}</p></header>
+<header><h1>${escapeHtml(siteName2)}</h1><p>${count2}</p></header>
 ${body}
 <footer>Flung with Fling</footer>
 </main>
@@ -805,7 +1131,265 @@ ${body}
 }
 
 // ../../packages/shared/src/mcp-tools.ts
-import { z as z8 } from "zod";
+import { z as z13 } from "zod";
+
+// ../../packages/shared/src/notifications.ts
+import { z as z12 } from "zod";
+var CHANNEL_IDS = ["email"];
+var ChannelIdSchema = z12.enum(CHANNEL_IDS);
+var DeliverySchema = z12.enum(["on", "off"]);
+var EVENT_KEYS = [
+  "site.shared",
+  "site.shared_via_group",
+  "site.owner_added",
+  "site.publisher_added",
+  "group.member_added",
+  "comment.created",
+  "comment.reply"
+];
+var EventKeySchema = z12.enum(EVENT_KEYS);
+var EVENT_CATALOGUE = [
+  {
+    key: "site.shared",
+    title: "Someone shares a site with you",
+    description: "A site owner adds you to who may see their site.",
+    section: "sharing",
+    defaults: { email: "on" },
+    coolDown: false
+  },
+  {
+    key: "site.shared_via_group",
+    title: "Someone shares a site with a group you are in",
+    description: "A site owner adds one of your groups to who may see their site.",
+    section: "sharing",
+    defaults: { email: "on" },
+    coolDown: false
+  },
+  {
+    key: "site.owner_added",
+    title: "Someone makes you an owner of a site",
+    description: "A site's owner adds you, or a group you are in, to its owners.",
+    section: "sharing",
+    defaults: { email: "on" },
+    coolDown: false,
+    capability: "siteRoles"
+  },
+  {
+    key: "site.publisher_added",
+    title: "Someone makes you a publisher of a site",
+    description: "A site's owner adds you, or a group you are in, to who may publish it.",
+    section: "sharing",
+    defaults: { email: "on" },
+    coolDown: false,
+    capability: "siteRoles"
+  },
+  {
+    key: "group.member_added",
+    title: "Someone adds you to a group",
+    description: "A group's owner adds you to it, opening the sites shared with it to you.",
+    section: "groups",
+    defaults: { email: "on" },
+    coolDown: false
+  },
+  {
+    key: "comment.created",
+    title: "Someone comments on your site",
+    description: "A new thread is started on a site you own.",
+    section: "comments",
+    defaults: { email: "on" },
+    coolDown: true,
+    capability: "comments"
+  },
+  {
+    key: "comment.reply",
+    title: "Someone replies in your thread",
+    description: "A reply is added to a thread you started or replied in.",
+    section: "comments",
+    defaults: { email: "on" },
+    coolDown: true,
+    capability: "comments"
+  }
+];
+var BY_KEY = new Map(EVENT_CATALOGUE.map((e) => [e.key, e]));
+var NotificationPreferencesUpdateSchema = z12.object({
+  muted: z12.boolean().optional(),
+  cells: z12.partialRecord(EventKeySchema, z12.partialRecord(ChannelIdSchema, DeliverySchema.nullable())).optional()
+});
+var EventDefinitionSchema = z12.looseObject({
+  key: z12.string(),
+  title: z12.string(),
+  description: z12.string(),
+  section: z12.string(),
+  defaults: z12.record(z12.string(), DeliverySchema),
+  coolDown: z12.boolean(),
+  capability: z12.string().optional()
+});
+var NotificationSettingsSchema = z12.looseObject({
+  channels: z12.array(z12.string()),
+  events: z12.array(EventDefinitionSchema),
+  muted: z12.boolean(),
+  cells: z12.record(z12.string(), z12.record(z12.string(), DeliverySchema)),
+  overrides: z12.record(z12.string(), z12.record(z12.string(), DeliverySchema)).default({})
+});
+var SentNotificationSchema = z12.looseObject({
+  id: z12.string(),
+  channel: z12.string(),
+  /** the events it told them about (several when folded) */
+  eventKeys: z12.array(z12.string()),
+  subject: z12.string(),
+  /** the provider's message id, when it gave one */
+  providerId: z12.string().nullable(),
+  sentAt: z12.string()
+});
+var SentNotificationListSchema = z12.object({ sent: z12.array(SentNotificationSchema) });
+var MailCountsSchema = z12.object({
+  sent: z12.number(),
+  retrying: z12.number(),
+  givenUp: z12.number(),
+  suppressed: z12.number(),
+  dropped: z12.number()
+});
+var MailAdminSchema = z12.object({
+  config: z12.object({
+    driver: z12.string(),
+    from: z12.string(),
+    fromName: z12.string(),
+    replyTo: z12.string().nullable(),
+    configurationSet: z12.string().nullable(),
+    /** outside invitations are on (`INVITES`) */
+    invites: z12.boolean()
+  }),
+  health: z12.object({
+    /** the first hour counted (UTC, `2026-10-28T14`) */
+    since: z12.string(),
+    /** the hours with any activity, oldest first */
+    hours: z12.array(MailCountsSchema.extend({ hour: z12.string() })),
+    totals: MailCountsSchema,
+    /** the latest failed sends, newest first */
+    failures: z12.array(
+      z12.object({
+        at: z12.string(),
+        batchId: z12.string(),
+        eventKeys: z12.array(z12.string()),
+        reason: z12.string(),
+        detail: z12.string().nullable()
+      })
+    )
+  }),
+  /** test emails this admin may still send this hour, of `limit` */
+  tests: z12.object({ remaining: z12.number(), limit: z12.number() })
+});
+var MailTestRequestSchema = z12.object({
+  to: z12.string().trim().toLowerCase().min(3).max(254)
+});
+var MailTestResultSchema = z12.discriminatedUnion("ok", [
+  z12.object({ ok: z12.literal(true), providerId: z12.string().nullable(), subject: z12.string() }),
+  z12.object({
+    ok: z12.literal(false),
+    reason: z12.string(),
+    detail: z12.string().nullable(),
+    error: z12.string()
+  })
+]);
+var CellChangeSchema = z12.object({
+  event: EventKeySchema,
+  channel: ChannelIdSchema,
+  value: z12.enum(["on", "off", "default"])
+});
+function preferencesUpdateOf(change) {
+  const cells = {};
+  for (const c of change.cells ?? []) {
+    cells[c.event] = { ...cells[c.event], [c.channel]: c.value === "default" ? null : c.value };
+  }
+  return {
+    ...change.muted === void 0 ? {} : { muted: change.muted },
+    ...Object.keys(cells).length ? { cells } : {}
+  };
+}
+var SECTION_TITLES = {
+  sharing: "Sharing",
+  groups: "Groups",
+  comments: "Comments"
+};
+var sectionTitle = (section) => SECTION_TITLES[section] ?? section;
+function describeNotificationSettings(settings) {
+  const lines = [
+    settings.muted ? "All notifications are muted: nothing is sent, whatever the settings below say." : `Notifications are on. Channels: ${settings.channels.join(", ")}.`
+  ];
+  let section = "";
+  for (const e of settings.events) {
+    if (e.section !== section) {
+      section = e.section;
+      lines.push("", `${sectionTitle(section)}:`);
+    }
+    const cells = settings.channels.map((ch) => {
+      const value = settings.cells[e.key]?.[ch] ?? "off";
+      const own = settings.overrides[e.key]?.[ch] !== void 0;
+      return `${ch} ${value}${own ? " (yours)" : ""}`;
+    });
+    lines.push(`- ${e.key}: ${e.title} \u2014 ${cells.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+// ../../packages/shared/src/read-files.ts
+var MCP_READ_MAX_BYTES = 1.5 * 1024 * 1024;
+function pageOfFiles(files, opts) {
+  const wanted = opts.paths ? new Set(opts.paths) : null;
+  const selected = wanted ? files.filter((f) => wanted.has(f.path)) : [...files];
+  const found = new Set(selected.map((f) => f.path));
+  const missing = opts.paths ? opts.paths.filter((p) => !found.has(p)) : [];
+  const start = Math.max(0, Number.parseInt(opts.cursor ?? "0", 10) || 0);
+  const page = [];
+  const tooLarge = [];
+  let used = 0;
+  for (let i = start; i < selected.length; i++) {
+    const file = selected[i];
+    if (file.size > opts.budget) {
+      tooLarge.push(file);
+      continue;
+    }
+    if (used + file.size > opts.budget) return { page, tooLarge, missing, nextCursor: String(i) };
+    page.push(file);
+    used += file.size;
+  }
+  return { page, tooLarge, missing };
+}
+function encodeForAgent(path3, bytes) {
+  if (isScannablePath(path3) && !looksBinary(bytes)) {
+    try {
+      return { encoding: "utf8", content: new TextDecoder("utf-8", { fatal: true }).decode(bytes) };
+    } catch {
+    }
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return { encoding: "base64", content: btoa(binary) };
+}
+function describeReadFiles(name, result) {
+  const read = result.files.filter((f) => !f.tooLarge);
+  const big = result.files.filter((f) => f.tooLarge);
+  const lines = [
+    `${read.length} file(s) of ${name}, version ${result.versionId}: ${read.map((f) => f.path).join(", ") || "(none)"}.`
+  ];
+  if (big.length) {
+    lines.push(
+      `Too large to return here (left out; they stay as they are when you publish on this base): ${big.map((f) => f.path).join(", ")}.`
+    );
+  }
+  if (result.missing.length) lines.push(`Not in this version: ${result.missing.join(", ")}.`);
+  if (result.nextCursor) {
+    lines.push(
+      `More files: call fling_read_files again with cursor "${result.nextCursor}" (or name the files you need in \`paths\`).`
+    );
+  }
+  lines.push(
+    `To change the site, call fling_publish with base "${result.versionId}" and only the files you changed or added (and \`remove\` for files to delete): every other file is kept.`
+  );
+  return lines.join("\n");
+}
 
 // ../../packages/shared/src/site-sort.ts
 var SITE_SORTS = ["updated", "created", "name"];
@@ -838,38 +1422,65 @@ function mcpWording(instance) {
     sitesPattern: instanceSitesPattern(instance),
     privateAudience: privateAudience(instance),
     signIn: `their ${instance.auth.displayName} account`,
-    reviewPattern: instance.appOrigin ? reviewUrl(instance.appOrigin, "<name>") : GENERIC_REVIEW
+    reviewPattern: instance.appOrigin ? reviewUrl(instance.appOrigin, "<name>") : GENERIC_REVIEW,
+    defaultAccess: defaultAccessOf(instance),
+    invites: instance.capabilities?.invites === true
   };
 }
+var addressRule = (w) => w.invites ? `Each address must be one that can sign in to ${w.name}, or one from outside it, which is invited as a reviewer (a guest who signs in with an emailed link and sees only what is shared with them; a few a day per person, else \`too_many_invites\`).` : `Each address must be one that can sign in to ${w.name}.`;
+var defaultAccessPhrase = (w) => w.defaultAccess === "members" ? `open to ${w.privateAudience}` : w.defaultAccess === "only_me" ? "visible only to the user" : "given the Fling's default (only the user, unless the Fling is set up otherwise)";
+var ACCESS_NOTE = (w) => "Before publishing a new site, ask the user who should be able to open it, unless they already said, and pass `access`: `only_me` (only the user), `members` (" + w.privateAudience + `), \`groups\` or \`people\` (only the groups in \`groups\`, by slug, and the addresses in \`emails\`; one site may name both), or \`public\` (anyone, no sign-in; only if the user asks). Without \`access\` a new site is ${defaultAccessPhrase(w)}. Re-publishing never changes who can open an existing site: use fling_set_access for that. Share links (fling_share) open a site to anyone who has them.`;
 var NAME_REQUIRED = 'Publishing needs a name: if the user did not give one, propose a short descriptive one (e.g. "q3-report") and confirm it with them first (fling_check_name tells you whether it is free). If the name is taken by someone else the call fails with free suggestions \u2014 offer those to the user and retry with the one they pick.';
 var INLINE_ONLY = "If you created the content in this conversation, pass it directly \u2014 never pass file paths from your sandbox (this server cannot read them) and never try to curl/upload from your sandbox.";
 var NEVER_PUBLISHED = "Fling never publishes dotfiles, gitignored files, secret files (keys, certs, credentials) or files that contain secrets (API keys, tokens, private keys, passwords in database URLs); it stops and tells you which file and line. Remove the secret (or leave the file out) and retry \u2014 there is no way to override this.";
 var ENCODING = '`encoding` is "utf8" (default, for text: HTML, CSS, JS, SVG, JSON, Markdown\u2026) or "base64" (binary: images, fonts, PDFs).';
 var LIST_HTML = "If the files have no root index.html but do include HTML pages, the call does not publish: it reports how many HTML pages there are and asks you to check with the user. Ask them whether to generate an index.html listing those pages (retry with `listHtml: true`) or to publish without one (`listHtml: false` \u2014 the site root will 404, the pages still work at their own paths), then retry.";
-var listHtml = z8.boolean().optional().describe(
+var listHtml = z13.boolean().optional().describe(
   "Only matters when there is no root index.html: true \u2192 generate an index.html linking every HTML page; false \u2192 publish without one (root 404s). Omit until the user has decided"
 );
-var siteName = z8.string().min(1).max(200).describe('Site name, e.g. "q3-report"');
-var sitePath = z8.string().min(1).max(1024).describe(
+var siteName = z13.string().min(1).max(200).describe('Site name, e.g. "q3-report"');
+var PATH_PUBLISH_NOTE = 'With `path` (e.g. "30-10-26"), only that folder of the site is replaced: the files go to <site>/30-10-26/\u2026 (give their paths relative to the folder, its page being "index.html") and every other file of the site stays as it is. Use it to add one report, release note or week\'s page to a shared site without republishing the rest; rolling back removes it again.';
+var PULL_NOTE = "To change a site that is already published (fix a typo, update a page, add one), start from what is live, not from scratch: read its files with fling_read_files, then call fling_publish with `base` (the `versionId` it returned) and only the files you changed or added, plus `remove` for files to delete; every other file stays as it is. If someone published the site in between, it fails with base_changed: read the files again and redo the changes, rather than publishing without `base` over theirs.";
+var base = z13.string().min(1).max(100).optional().describe(
+  "The versionId fling_read_files returned: publish only what changed on top of it. `files` then holds only the files you changed or added, and every other file of the site is kept. Fails with base_changed if the site has changed since. Not with `path`"
+);
+var remove = z13.array(z13.string().min(1).max(1024)).max(MAX_FILES).optional().describe("With `base`: the paths of the files to delete from the site");
+var publishPath = z13.string().min(1).max(1024).optional().describe(
+  'Publish into this folder of the site only, e.g. "30-10-26" or "reports/2026" (served at <site>/30-10-26/), keeping every other file. File paths are relative to it. Omit to replace the whole site'
+);
+var sitePath = z13.string().min(1).max(1024).describe(
   'Site-relative path with forward slashes, e.g. "index.html", "css/app.css", "img/logo.png". The root page must be "index.html". No dotfiles (".env", ".well-known/\u2026")'
 );
-var emails = z8.array(z8.string().min(3).max(254)).max(AUDIENCE_EMAILS_MAX);
-var groupSlugs = z8.array(z8.string().min(1).max(100)).max(AUDIENCE_GROUPS_MAX);
-var groupSlug = z8.string().min(1).max(100).describe(`The group's slug, e.g. "design"`);
-var members = z8.array(z8.string().min(3).max(254)).max(GROUP_MEMBERS_MAX);
-var groupName = z8.string().min(1).max(GROUP_NAME_MAX);
-var commentPath = z8.string().max(1024);
-var commentId = z8.string().min(1).max(100);
-var encoding = z8.enum(["utf8", "base64"]).optional().describe('How `content` is encoded: "utf8" (default) for text, "base64" for binary files');
-var spa = z8.boolean().optional().describe(
+var emails = z13.array(z13.string().min(3).max(254)).max(AUDIENCE_EMAILS_MAX);
+var groupSlugs = z13.array(z13.string().min(1).max(100)).max(AUDIENCE_GROUPS_MAX);
+var roleChange = {
+  add: z13.array(z13.string().min(3).max(254)).max(PUBLISHER_EMAILS_MAX).optional(),
+  remove: z13.array(z13.string().min(3).max(254)).max(PUBLISHER_EMAILS_MAX).optional(),
+  set: z13.array(z13.string().min(3).max(254)).max(PUBLISHER_EMAILS_MAX).optional(),
+  addGroups: z13.array(z13.string().min(1).max(100)).max(PUBLISHER_GROUPS_MAX).optional(),
+  removeGroups: z13.array(z13.string().min(1).max(100)).max(PUBLISHER_GROUPS_MAX).optional(),
+  setGroups: z13.array(z13.string().min(1).max(100)).max(PUBLISHER_GROUPS_MAX).optional()
+};
+var groupSlug = z13.string().min(1).max(100).describe(`The group's slug, e.g. "design"`);
+var members = z13.array(z13.string().min(3).max(254)).max(GROUP_MEMBERS_MAX);
+var groupName = z13.string().min(1).max(GROUP_NAME_MAX);
+var commentPath = z13.string().max(1024);
+var commentId = z13.string().min(1).max(100);
+var encoding = z13.enum(["utf8", "base64"]).optional().describe('How `content` is encoded: "utf8" (default) for text, "base64" for binary files');
+var spa = z13.boolean().optional().describe(
   "Single-page app: serve index.html for unknown paths (client-side routing). Omit to keep the current setting"
 );
 function mcpToolsFor(w) {
   const NAME_RULES = `Site names are 1-${SITE_NAME_MAX} chars of lowercase letters, digits and single hyphens, and are one global namespace (first come, first served): the site is served at ${w.sitesPattern}.`;
-  const VISIBILITY = `Sites are private by default (only ${w.privateAudience} can open them); pass \`public: true\` only if the user asks for a public site. Share links (fling_share) are public to anyone who has them.`;
-  const isPublic = z8.boolean().optional().describe(
-    `true \u2192 anyone can view; false \u2192 only ${w.privateAudience}. Omit to keep the current setting (new sites are private)`
+  const VISIBILITY = ACCESS_NOTE(w);
+  const isPublic = z13.boolean().optional().describe(
+    "Prefer `access` (a new site) or fling_set_access (an existing one). true \u2192 anyone can view; false \u2192 private. Omit to keep the current setting"
+  );
+  const access2 = z13.enum(ACCESS_LEVELS).optional().describe(
+    `Who can open a new site: only_me, members (${w.privateAudience}), groups, people or public. Ask the user before the first publish; omit for the default (${defaultAccessPhrase(w)}). Ignored when the site already exists`
   );
+  const accessEmails = emails.optional().describe('With access "people" (or "groups"): the addresses that may open it');
+  const accessGroups = groupSlugs.optional().describe('With access "groups" (or "people"): the groups, by slug, whose members may open it');
   return {
     whoami: tool({
       name: "fling_whoami",
@@ -883,9 +1494,9 @@ function mcpToolsFor(w) {
       title: "List sites",
       description: "List the user's Fling sites with URL, visibility and share link. With `shared: true`, list instead the restricted sites other people have shared with the user (by address or through a group they're in), with URL, review link and owner.",
       inputSchema: {
-        archived: z8.boolean().optional().describe("List archived sites instead of live ones"),
-        shared: z8.boolean().optional().describe("List the sites others have shared with the user instead of the user's own"),
-        sort: z8.enum(SITE_SORTS).optional().describe(
+        archived: z13.boolean().optional().describe("List archived sites instead of live ones"),
+        shared: z13.boolean().optional().describe("List the sites others have shared with the user instead of the user's own"),
+        sort: z13.enum(SITE_SORTS).optional().describe(
           "Order: updated (last updated, newest first; the default), created (newest first) or name (A\u2013Z)"
         )
       },
@@ -904,7 +1515,20 @@ function mcpToolsFor(w) {
       description: "List the files in a site's current version (or in `versionId`, from fling_info): path, size and content type, sorted by path. Use it to check what was actually published \u2014 e.g. when the user sees a 404, confirm the page exists at that path and that there is a root index.html (without one the site root 404s).",
       inputSchema: {
         name: siteName,
-        versionId: z8.string().min(1).max(100).optional().describe("Version id (from fling_info); omit for the version being served")
+        versionId: z13.string().min(1).max(100).optional().describe("Version id (from fling_info); omit for the version being served")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    }),
+    readFiles: tool({
+      name: "fling_read_files",
+      title: "Read a site's files",
+      description: `Read the files of a site's current version (or \`versionId\`), with their content inline (text as utf8, anything else base64), to change some of them and publish again. Returns up to ${MCP_READ_MAX_BYTES / 1024 / 1024} MB a call, in path order: when there is more, pass the returned \`cursor\` for the next files, or name the files you need in \`paths\` (fling_files lists them). It returns the \`versionId\` to pass to fling_publish as \`base\`. Anyone who can open the site may read it; publishing needs an owner or publisher. ${PULL_NOTE}`,
+      inputSchema: {
+        name: siteName,
+        paths: z13.array(z13.string().min(1).max(1024)).max(MAX_FILES).optional().describe('Only these files (site paths, e.g. "index.html"); omit for all of them'),
+        path: z13.string().min(1).max(1024).optional().describe('Only the files under this folder of the site, e.g. "30-10-26"'),
+        cursor: z13.string().max(20).optional().describe("From the previous call, for the next files"),
+        versionId: z13.string().min(1).max(100).optional().describe("Version id (from fling_info); omit for the version being served")
       },
       annotations: { readOnlyHint: true, openWorldHint: false }
     }),
@@ -912,23 +1536,31 @@ function mcpToolsFor(w) {
       name: "fling_check_name",
       title: "Check a site name",
       description: "Check whether a site name can be used before publishing: `available` (a new site), `yours` (publishing updates the user's existing site), `taken` (someone else's \u2014 free `suggestions` are returned) or `invalid`. " + NAME_RULES,
-      inputSchema: { name: z8.string().min(1).max(200).describe("Site name to check") },
+      inputSchema: { name: z13.string().min(1).max(200).describe("Site name to check") },
       annotations: { readOnlyHint: true, openWorldHint: false }
     }),
     publish: tool({
       name: "fling_publish",
       title: "Publish a site",
-      description: `Publish a static site to Fling in one call and get back its URL. Pass every file of the site inline in \`files\` (whole site, up to ${MCP_PUBLISH_MAX_BYTES / 1024 / 1024} MB decoded in total; bigger sites: fling_upload_begin / fling_upload_file / fling_upload_finish). ${INLINE_ONLY} ${ENCODING} Publishing replaces the whole site with exactly these files (it is not a patch: include unchanged files too); publishing identical content again is a no-op. ${NAME_REQUIRED} ${NAME_RULES} ${VISIBILITY} ${LIST_HTML} ${NEVER_PUBLISHED} The result includes \`warnings\`. Share the returned URL with the user; fling_files shows exactly which files the site has.`,
+      description: `Publish a static site to Fling in one call and get back its URL. Pass every file of the site inline in \`files\` (whole site, up to ${MCP_PUBLISH_MAX_BYTES / 1024 / 1024} MB decoded in total; bigger sites: fling_upload_begin / fling_upload_file / fling_upload_finish). ${INLINE_ONLY} ${ENCODING} Publishing replaces the whole site with exactly these files (it is not a patch: include unchanged files too), unless \`path\` or \`base\` is given; publishing identical content again is a no-op. ${PATH_PUBLISH_NOTE} ${PULL_NOTE} ${NAME_REQUIRED} ${NAME_RULES} ${VISIBILITY} ${LIST_HTML} ${NEVER_PUBLISHED} The result includes \`warnings\`. Share the returned URL with the user; fling_files shows exactly which files the site has.`,
       inputSchema: {
         name: siteName,
-        files: z8.array(
-          z8.object({
+        files: z13.array(
+          z13.object({
             path: sitePath,
-            content: z8.string().describe("The file content, encoded as `encoding` says"),
+            content: z13.string().describe("The file content, encoded as `encoding` says"),
             encoding
           })
-        ).min(1).max(MAX_FILES).describe("Every file of the site"),
+        ).max(MAX_FILES).describe(
+          "Every file of the site (with `path`: of that folder; with `base`: only those changed or added)"
+        ),
+        path: publishPath,
+        base,
+        remove,
         spa,
+        access: access2,
+        emails: accessEmails,
+        groups: accessGroups,
         public: isPublic,
         listHtml
       },
@@ -937,8 +1569,18 @@ function mcpToolsFor(w) {
     uploadBegin: tool({
       name: "fling_upload_begin",
       title: "Start a chunked upload",
-      description: `Start publishing a site too big for one fling_publish call (over ${MCP_PUBLISH_MAX_BYTES / 1024 / 1024} MB, or large binary files). Returns an \`uploadId\`; then send each file with fling_upload_file and finish with fling_upload_finish within ${MCP_UPLOAD_TTL_SECONDS / 60} minutes. ${INLINE_ONLY} ${NAME_REQUIRED} ${VISIBILITY}`,
-      inputSchema: { name: siteName, spa, public: isPublic },
+      description: `Start publishing a site too big for one fling_publish call (over ${MCP_PUBLISH_MAX_BYTES / 1024 / 1024} MB, or large binary files). Returns an \`uploadId\`; then send each file with fling_upload_file and finish with fling_upload_finish within ${MCP_UPLOAD_TTL_SECONDS / 60} minutes. ${INLINE_ONLY} ${NAME_REQUIRED} ${VISIBILITY} ${PATH_PUBLISH_NOTE} With \`base\` (from fling_read_files), send only the files you changed or added, and \`remove\` the ones to delete: every other file of the site is kept.`,
+      inputSchema: {
+        name: siteName,
+        path: publishPath,
+        base,
+        remove,
+        spa,
+        access: access2,
+        emails: accessEmails,
+        groups: accessGroups,
+        public: isPublic
+      },
       annotations: { destructiveHint: false, openWorldHint: false }
     }),
     uploadFile: tool({
@@ -946,20 +1588,20 @@ function mcpToolsFor(w) {
       title: "Upload a file (chunked)",
       description: `Add one file to a chunked upload started with fling_upload_begin. Sending the same path again replaces it. A file larger than ${MCP_UPLOAD_CHUNK_MAX_CHARS / 1024 / 1024} MB of content can span calls: send the first part normally, then the following parts in order with \`append: true\` (same path and encoding; send appends one at a time, not in parallel). ${ENCODING} ${NEVER_PUBLISHED}`,
       inputSchema: {
-        uploadId: z8.string().min(1).max(100).describe("From fling_upload_begin"),
+        uploadId: z13.string().min(1).max(100).describe("From fling_upload_begin"),
         path: sitePath,
-        content: z8.string().max(MCP_UPLOAD_CHUNK_MAX_CHARS).describe("The file content (or the next part of it, with `append`)"),
+        content: z13.string().max(MCP_UPLOAD_CHUNK_MAX_CHARS).describe("The file content (or the next part of it, with `append`)"),
         encoding,
-        append: z8.boolean().optional().describe("Append this content to the file sent earlier with the same path")
+        append: z13.boolean().optional().describe("Append this content to the file sent earlier with the same path")
       },
       annotations: { destructiveHint: false, openWorldHint: false }
     }),
     uploadFinish: tool({
       name: "fling_upload_finish",
       title: "Finish a chunked upload",
-      description: `Publish everything sent with fling_upload_file as the new version of the site and return its URL. The site becomes exactly the uploaded files. ${LIST_HTML} The upload stays open, so just call fling_upload_finish again with \`listHtml\`. The result includes \`warnings\`.`,
+      description: `Publish everything sent with fling_upload_file as the new version of the site and return its URL. The site becomes exactly the uploaded files (with \`path\` or \`base\`, plus the rest of the site). ${LIST_HTML} The upload stays open, so just call fling_upload_finish again with \`listHtml\`. The result includes \`warnings\`.`,
       inputSchema: {
-        uploadId: z8.string().min(1).max(100).describe("From fling_upload_begin"),
+        uploadId: z13.string().min(1).max(100).describe("From fling_upload_begin"),
         listHtml
       },
       annotations: { destructiveHint: false, openWorldHint: true }
@@ -970,22 +1612,34 @@ function mcpToolsFor(w) {
       description: "Get or create a public share link for a site: anyone with the link can view it without signing in (use it to show a private site to someone who cannot sign in). `refresh` replaces the link (the old one stops working); `revoke` removes it.",
       inputSchema: {
         name: siteName,
-        refresh: z8.boolean().optional().describe("Rotate the link"),
-        revoke: z8.boolean().optional().describe("Remove the link")
+        refresh: z13.boolean().optional().describe("Rotate the link"),
+        revoke: z13.boolean().optional().describe("Remove the link")
       },
       annotations: { destructiveHint: false, openWorldHint: true }
     }),
+    setAccess: tool({
+      name: "fling_set_access",
+      title: "Set who can open a site",
+      description: "Set a site's access level: `only_me` (only the user), `members` (" + w.privateAudience + `), \`groups\` and \`people\` (only the user, the groups in \`groups\` by slug and the addresses in \`emails\`; both levels take both, and replace the whole audience), or \`public\` (anyone can open the site; its review page and comments still need sign-in). Only change it when the user asks. ${addressRule(w)} Share links still open the site to anyone who has them. Someone who loses access is shut out within 5 minutes; people and groups added are told by email when the instance sends it.`,
+      inputSchema: {
+        name: siteName,
+        access: z13.enum(ACCESS_LEVELS).describe("only_me, members, groups, people or public"),
+        emails: emails.optional().describe("For groups or people: the addresses that may open it"),
+        groups: groupSlugs.optional().describe("For groups or people: the groups (slugs, fling_groups) whose members may")
+      },
+      annotations: { idempotentHint: true, openWorldHint: true }
+    }),
     setVisibility: tool({
       name: "fling_set_visibility",
       title: "Set visibility",
-      description: `Make a site private (open to ${w.privateAudience}) or public (anyone can open the site; its review page and comments still need sign-in).`,
-      inputSchema: { name: siteName, visibility: z8.enum(["private", "public"]) },
+      description: `Make a site private or public (anyone can open the site; its review page and comments still need sign-in). Making it private gives it back the access it had before (only the user, ${w.privateAudience}, or its audience). fling_set_access sets any level.`,
+      inputSchema: { name: siteName, visibility: z13.enum(["private", "public"]) },
       annotations: { idempotentHint: true, openWorldHint: true }
     }),
     setAudience: tool({
       name: "fling_set_audience",
       title: "Set who can see a private site",
-      description: `Limit a private site to listed people and groups (its audience), or open it again to ${w.privateAudience}. \`add\` and \`remove\` change the addresses and \`set\` replaces them; \`addGroups\`, \`removeGroups\` and \`setGroups\` do the same for groups, by slug (fling_groups lists them); \`clear\` empties both (then every signed-in member can see it again). The owner always sees the site. Each address must be one that can sign in to ${w.name}. The audience only applies while the site is private (fling_set_visibility); share links still open it to anyone. Removing someone takes up to 5 minutes to shut them out. fling_info shows the audience.`,
+      description: `Limit a private site to listed people and groups (its audience), or open it again to ${w.privateAudience}; fling_set_access does the same for whole levels, including only the user. \`add\` and \`remove\` change the addresses and \`set\` replaces them; \`addGroups\`, \`removeGroups\` and \`setGroups\` do the same for groups, by slug (fling_groups lists them); \`clear\` empties both (then every signed-in member can see it again). The owner always sees the site. ${addressRule(w)} The audience only applies while the site is private (fling_set_visibility); share links still open it to anyone. Removing someone takes up to 5 minutes to shut them out. fling_info shows the audience.`,
       inputSchema: {
         name: siteName,
         add: emails.optional().describe("Addresses to let in"),
@@ -994,7 +1648,41 @@ function mcpToolsFor(w) {
         addGroups: groupSlugs.optional().describe("Groups (slugs) to let in"),
         removeGroups: groupSlugs.optional().describe("Groups (slugs) to take out"),
         setGroups: groupSlugs.optional().describe("Replace the groups with exactly these slugs"),
-        clear: z8.boolean().optional().describe("Empty the audience (addresses and groups): every signed-in member sees it")
+        clear: z13.boolean().optional().describe("Empty the audience (addresses and groups): every signed-in member sees it")
+      },
+      annotations: { idempotentHint: true, openWorldHint: false }
+    }),
+    setOwners: tool({
+      name: "fling_set_owners",
+      title: "Set a site's owners",
+      description: `Change who owns a site: people and groups who may do everything the user can with it (publish, roll back, change its access and settings, its owners and publishers, archive and delete it). Only owners change it, and only when the user asks. \`add\` and \`remove\` change the addresses and \`set\` replaces them; \`addGroups\`, \`removeGroups\` and \`setGroups\` do the same for groups, by slug (fling_groups). Only members of ${w.name} may be owners, never guests; a site keeps at least one person (address) as an owner, and has at most ${OWNER_EMAILS_MAX} addresses. Naming a group trusts whoever manages it. fling_info shows the owners and publishers.`,
+      inputSchema: {
+        name: siteName,
+        add: roleChange.add.describe("Addresses to make owners"),
+        remove: roleChange.remove.describe("Addresses to take out of the owners"),
+        set: roleChange.set.describe("Replace the owner addresses with exactly these"),
+        addGroups: roleChange.addGroups.describe("Groups (slugs) to make owners"),
+        removeGroups: roleChange.removeGroups.describe("Groups (slugs) to take out"),
+        setGroups: roleChange.setGroups.describe(
+          "Replace the owner groups with exactly these slugs"
+        )
+      },
+      annotations: { idempotentHint: true, openWorldHint: false }
+    }),
+    setPublishers: tool({
+      name: "fling_set_publishers",
+      title: "Set a site's publishers",
+      description: `Change who publishes a site without owning it: people and groups who may deploy new versions and roll back, but not change its access or settings, add owners or delete it. Only the site's owners change it, and only when the user asks. \`add\` and \`remove\` change the addresses and \`set\` replaces them; \`addGroups\`, \`removeGroups\` and \`setGroups\` do the same for groups, by slug (fling_groups). Only members of ${w.name} may publish, never guests. Someone who is also an owner stays an owner. fling_info shows the owners and publishers.`,
+      inputSchema: {
+        name: siteName,
+        add: roleChange.add.describe("Addresses to make publishers"),
+        remove: roleChange.remove.describe("Addresses to take out of the publishers"),
+        set: roleChange.set.describe("Replace the publisher addresses with exactly these"),
+        addGroups: roleChange.addGroups.describe("Groups (slugs) to make publishers"),
+        removeGroups: roleChange.removeGroups.describe("Groups (slugs) to take out"),
+        setGroups: roleChange.setGroups.describe(
+          "Replace the publisher groups with exactly these slugs"
+        )
       },
       annotations: { idempotentHint: true, openWorldHint: false }
     }),
@@ -1003,7 +1691,7 @@ function mcpToolsFor(w) {
       title: "List groups",
       description: `List the groups on ${w.name}: named lists of people (a team) that any member can use in a site's audience (fling_set_audience \`addGroups\`). Each has a slug, a name, a size and an owner; \`mine\` lists only the user's own. \`members\` lists only the groups of exactly those people: use it before making a group, or to swap a list of addresses in an audience for a group that already holds them.`,
       inputSchema: {
-        mine: z8.boolean().optional().describe("Only the groups the user owns"),
+        mine: z13.boolean().optional().describe("Only the groups the user owns"),
         members: members.optional().describe("Only the groups whose members are exactly these addresses")
       },
       annotations: { readOnlyHint: true, openWorldHint: false }
@@ -1011,14 +1699,14 @@ function mcpToolsFor(w) {
     groupShow: tool({
       name: "fling_group_show",
       title: "Show a group",
-      description: "Show a group and its members (each marked when they have not signed in yet), and whether the user owns it (only the owner can change it).",
+      description: "Show a group and its members (each marked when they have not signed in yet, and when they are a guest invited from outside), and whether the user owns it (only the owner can change it).",
       inputSchema: { slug: groupSlug },
       annotations: { readOnlyHint: true, openWorldHint: false }
     }),
     groupCreate: tool({
       name: "fling_group_create",
       title: "Create a group",
-      description: `Create a group the user owns: a named list of people that anyone signed in to ${w.name} can see and use in a site's audience, but only the user can change. The slug is ${GROUP_SLUG_RULES}, unique on ${w.name}; each member must be an address that can sign in (at most ${GROUP_MEMBERS_MAX}).`,
+      description: `Create a group the user owns: a named list of people that anyone signed in to ${w.name} can see and use in a site's audience, but only the user can change. The slug is ${GROUP_SLUG_RULES}, unique on ${w.name}; at most ${GROUP_MEMBERS_MAX} members. ${addressRule(w)}`,
       inputSchema: {
         slug: groupSlug,
         name: groupName.describe('Its display name, e.g. "Design team"'),
@@ -1029,7 +1717,7 @@ function mcpToolsFor(w) {
     groupMembers: tool({
       name: "fling_group_members",
       title: "Change who is in a group",
-      description: "Add people to a group the user owns, or take them out. Every site whose audience names the group follows: someone taken out is shut out within 5 minutes.",
+      description: `Add people to a group the user owns, or take them out. Every site whose audience names the group follows: someone taken out is shut out within 5 minutes. ${addressRule(w)}`,
       inputSchema: {
         slug: groupSlug,
         add: members.optional().describe("Addresses to add"),
@@ -1050,7 +1738,7 @@ function mcpToolsFor(w) {
       description: "Permanently delete a group the user owns. Sites whose audience names it keep their restriction, and anyone it let in loses access (a site limited to it alone is left to its owner). Cannot be undone \u2014 confirm with the user first and pass `confirm: true`.",
       inputSchema: {
         slug: groupSlug,
-        confirm: z8.literal(true).describe("Must be true: the user has confirmed the deletion")
+        confirm: z13.literal(true).describe("Must be true: the user has confirmed the deletion")
       },
       annotations: { destructiveHint: true, openWorldHint: false }
     }),
@@ -1060,7 +1748,7 @@ function mcpToolsFor(w) {
       description: "Archive a site (it stops being served and is hidden from lists, but its name, files and versions are kept) or, with `unarchive`, bring it back. Prefer this over deleting.",
       inputSchema: {
         name: siteName,
-        unarchive: z8.boolean().optional().describe("Restore an archived site")
+        unarchive: z13.boolean().optional().describe("Restore an archived site")
       },
       annotations: { idempotentHint: true, openWorldHint: false }
     }),
@@ -1070,7 +1758,7 @@ function mcpToolsFor(w) {
       description: "Permanently delete a site and every version of it, freeing its name. Cannot be undone \u2014 confirm with the user first and pass `confirm: true`. Consider fling_archive instead.",
       inputSchema: {
         name: siteName,
-        confirm: z8.literal(true).describe("Must be true: the user has confirmed the deletion")
+        confirm: z13.literal(true).describe("Must be true: the user has confirmed the deletion")
       },
       annotations: { destructiveHint: true, openWorldHint: false }
     }),
@@ -1081,7 +1769,7 @@ function mcpToolsFor(w) {
       inputSchema: {
         name: siteName,
         path: commentPath.optional().describe('Only this page, e.g. "/" or "/docs/"'),
-        includeResolved: z8.boolean().optional().describe("Include resolved threads")
+        includeResolved: z13.boolean().optional().describe("Include resolved threads")
       },
       annotations: { readOnlyHint: true, openWorldHint: false }
     }),
@@ -1091,7 +1779,7 @@ function mcpToolsFor(w) {
       description: `Comment on a page of a site (shown on its review page, ${w.reviewPattern}), or reply to a thread (\`replyTo\`: a thread id from fling_comments_list). Comments are signed with the user's name, so only write one the user asked for.`,
       inputSchema: {
         name: siteName,
-        body: z8.string().min(1).max(COMMENT_MAX_CHARS).describe("The comment (plain text)"),
+        body: z13.string().min(1).max(COMMENT_MAX_CHARS).describe("The comment (plain text)"),
         path: commentPath.optional().describe('The page it is about (default "/"); ignored for a reply'),
         replyTo: commentId.optional().describe("Reply to this thread instead of starting one")
       },
@@ -1104,7 +1792,7 @@ function mcpToolsFor(w) {
       inputSchema: {
         name: siteName,
         id: commentId.describe("The thread id"),
-        reopen: z8.boolean().optional().describe("Reopen a resolved thread")
+        reopen: z13.boolean().optional().describe("Reopen a resolved thread")
       },
       annotations: { idempotentHint: true, openWorldHint: false }
     }),
@@ -1115,19 +1803,39 @@ function mcpToolsFor(w) {
       inputSchema: { name: siteName, id: commentId.describe("The comment id") },
       annotations: { destructiveHint: true, openWorldHint: false }
     }),
+    notifications: tool({
+      name: "fling_notifications",
+      title: "Notification settings",
+      description: `Show what ${w.name} tells the user about and how: each event (a site shared with them, added to a group, a comment on their site, a reply in their thread\u2026) with its key and, per channel (email), whether it is on or off, marking the ones the user chose themselves; and whether everything is muted. Use it before fling_notifications_set, or when the user asks why they get (or do not get) emails.`,
+      inputSchema: {},
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    }),
+    notificationsSet: tool({
+      name: "fling_notifications_set",
+      title: "Change notification settings",
+      description: `Change what ${w.name} tells the user about: \`muted: true\` stops everything (false turns it back on, with their choices kept), and \`cells\` turns single events on or off per channel, or back to the default (\`value: "default"\`). Event keys come from fling_notifications. Only change what the user asked for. Returns the settings after the change.`,
+      inputSchema: {
+        muted: z13.boolean().optional().describe("true: send nothing at all; false: unmute"),
+        cells: z13.array(CellChangeSchema).max(50).optional().describe(
+          'Events to change: `{ event, channel, value }`, value "on", "off" or "default"'
+        )
+      },
+      annotations: { idempotentHint: true, openWorldHint: false }
+    }),
     rollback: tool({
       name: "fling_rollback",
       title: "Roll back",
       description: "Point a site at an earlier version (ids from fling_info). Instant; nothing is uploaded.",
       inputSchema: {
         name: siteName,
-        versionId: z8.string().min(1).max(100).describe("Version id to serve")
+        versionId: z13.string().min(1).max(100).describe("Version id to serve")
       },
       annotations: { idempotentHint: true, openWorldHint: false }
     })
   };
 }
 var mcpTools = mcpToolsFor(mcpWording());
+var NOTIFICATIONS_NOTE = (w) => `${w.name} emails people when a site is shared with them, they are made an owner or publisher of one, they are added to a group, or someone comments on their site or replies in their thread. fling_notifications shows what the user hears about; change it with fling_notifications_set only when they ask.`;
 var COMMENTS_NOTE = (w) => `People review sites at ${w.reviewPattern} and leave comments on its pages. Publishing returns this review link (\`reviewUrl\`): it is the one to share when the user wants feedback; reviewers sign in to use it. fling_comments_list shows the comments; after acting on feedback, resolve the threads with fling_comment_resolve. Only post (fling_comment_add) or delete (fling_comment_delete) comments when the user asks.`;
 var shareForFeedback = (reviewPage2, instanceName) => `Share for feedback: ${reviewPage2} (reviewers sign in to ${instanceName} to see the site and comment).`;
 var MCP_FILES_LISTED = 200;
@@ -1174,7 +1882,7 @@ function describeComments(list, opts = {}) {
 var READY_TIMEOUT_MS = 15e3;
 var NOT_READY_NOTE = "it can take a few more seconds to appear everywhere; reload if you see a 404";
 var isReachableStatus = (status) => status >= 200 && status < 400 || status === 401 || status === 403;
-var defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+var defaultSleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
 async function waitUntilReachable(url, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? READY_TIMEOUT_MS;
   const doFetch = opts.fetch ?? ((u, init) => fetch(u, init));
@@ -1208,109 +1916,123 @@ async function waitUntilReachable(url, opts = {}) {
   }
 }
 function probeUrl(siteUrl2, paths) {
-  const base = siteUrl2.endsWith("/") ? siteUrl2 : `${siteUrl2}/`;
-  if (paths.length === 0 || paths.includes("index.html")) return base;
+  const base2 = siteUrl2.endsWith("/") ? siteUrl2 : `${siteUrl2}/`;
+  if (paths.length === 0 || paths.includes("index.html")) return base2;
   const pick = paths.find((p) => /\.html?$/i.test(p)) ?? paths[0];
-  return base + pick.split("/").map(encodeURIComponent).join("/");
+  return base2 + pick.split("/").map(encodeURIComponent).join("/");
 }
 function readinessWaitDisabled(env) {
   return env.FLING_NO_WAIT === "1" || env.VITEST === "true" || env.NODE_ENV === "test";
 }
 
 // ../../packages/shared/src/review-bridge.ts
-import { z as z9 } from "zod";
-var tag = { fling: z9.literal("review") };
-var path = z9.string().max(COMMENT_PATH_MAX);
-var hash = z9.string().max(COMMENT_PATH_MAX);
-var BridgePinSchema = z9.object({
-  id: z9.string(),
-  n: z9.number().int().min(1),
+import { z as z14 } from "zod";
+var tag = { fling: z14.literal("review") };
+var path = z14.string().max(COMMENT_PATH_MAX);
+var hash = z14.string().max(COMMENT_PATH_MAX);
+var BridgePinSchema = z14.object({
+  id: z14.string(),
+  n: z14.number().int().min(1),
   anchor: CommentAnchorSchema,
-  selected: z9.boolean(),
-  resolved: z9.boolean()
+  selected: z14.boolean(),
+  resolved: z14.boolean()
 });
-var BridgeCursorSchema = z9.object({
-  id: z9.string(),
-  name: z9.string().max(100),
-  colour: z9.string().max(32),
+var BridgeCursorSchema = z14.object({
+  id: z14.string(),
+  name: z14.string().max(100),
+  colour: z14.string().max(32),
   anchor: CommentAnchorSchema
 });
-var ShellMessageSchema = z9.discriminatedUnion("type", [
-  z9.object({ ...tag, type: z9.literal("ready") }),
+var ShellMessageSchema = z14.discriminatedUnion("type", [
+  z14.object({ ...tag, type: z14.literal("ready") }),
   /** the frame is on `path` (normalised, see normalizeCommentPath) with fragment `hash` ('' or '#…') */
-  z9.object({ ...tag, type: z9.literal("location"), path, hash, title: z9.string().max(300) }),
+  z14.object({ ...tag, type: z14.literal("location"), path, hash, title: z14.string().max(300) }),
   /** a pin placed while placing: a click (a spot) or a drag (a box) */
-  z9.object({ ...tag, type: z9.literal("pinPlaced"), anchor: CommentAnchorSchema }),
+  z14.object({ ...tag, type: z14.literal("pinPlaced"), anchor: CommentAnchorSchema }),
   /** the reviewer selected text in the page: an anchor on it, with its quote */
-  z9.object({ ...tag, type: z9.literal("textSelected"), anchor: CommentAnchorSchema }),
-  z9.object({ ...tag, type: z9.literal("pinCancelled") }),
-  z9.object({ ...tag, type: z9.literal("pinClicked"), id: z9.string() }),
+  z14.object({ ...tag, type: z14.literal("textSelected"), anchor: CommentAnchorSchema }),
+  z14.object({ ...tag, type: z14.literal("pinCancelled") }),
+  z14.object({ ...tag, type: z14.literal("pinClicked"), id: z14.string() }),
   /** this reviewer's pointer on the page; null when it left the frame */
-  z9.object({ ...tag, type: z9.literal("cursor"), anchor: CommentAnchorSchema.nullable() }),
+  z14.object({ ...tag, type: z14.literal("cursor"), anchor: CommentAnchorSchema.nullable() }),
   /** a link or form to another origin, stopped: the frame stays on the site */
-  z9.object({ ...tag, type: z9.literal("blocked"), href: z9.string().max(2048) }),
-  z9.object({ ...tag, type: z9.literal("escape") })
+  z14.object({ ...tag, type: z14.literal("blocked"), href: z14.string().max(2048) }),
+  z14.object({ ...tag, type: z14.literal("escape") }),
+  /** preview mode: the thumbnail the page asked for, a PNG of the frame's viewport of `versionId` */
+  z14.object({
+    ...tag,
+    type: z14.literal("captured"),
+    png: z14.instanceof(Blob),
+    versionId: z14.string().max(100)
+  }),
+  /** preview mode: no thumbnail could be drawn (CAPTURE_STALE: the host serves another version) */
+  z14.object({ ...tag, type: z14.literal("captureFailed"), reason: z14.string().max(300) })
 ]);
-var PageMessageSchema = z9.discriminatedUnion("type", [
+var PageMessageSchema = z14.discriminatedUnion("type", [
   /** load `path` (site-relative, may carry `?query` and `#hash`) in the frame */
-  z9.object({ ...tag, type: z9.literal("navigate"), path: z9.string().max(COMMENT_PATH_MAX * 2) }),
-  z9.object({ ...tag, type: z9.literal("reload") }),
-  z9.object({ ...tag, type: z9.literal("placing"), on: z9.boolean() }),
+  z14.object({ ...tag, type: z14.literal("navigate"), path: z14.string().max(COMMENT_PATH_MAX * 2) }),
+  z14.object({ ...tag, type: z14.literal("reload") }),
+  z14.object({ ...tag, type: z14.literal("placing"), on: z14.boolean() }),
   /** the pins on the frame's current page */
-  z9.object({ ...tag, type: z9.literal("pins"), pins: z9.array(BridgePinSchema) }),
+  z14.object({ ...tag, type: z14.literal("pins"), pins: z14.array(BridgePinSchema) }),
   /** scroll the pin into view and draw attention to it */
-  z9.object({ ...tag, type: z9.literal("focusPin"), id: z9.string() }),
-  z9.object({ ...tag, type: z9.literal("cursors"), cursors: z9.array(BridgeCursorSchema) })
+  z14.object({ ...tag, type: z14.literal("focusPin"), id: z14.string() }),
+  z14.object({ ...tag, type: z14.literal("cursors"), cursors: z14.array(BridgeCursorSchema) }),
+  /**
+   * preview mode: once the page has loaded and settled, draw it as a thumbnail (`captured`), only
+   * if the sites host serves `versionId` (the site's current version, as the API says)
+   */
+  z14.object({ ...tag, type: z14.literal("capture"), versionId: z14.string().max(100) })
 ]);
 
 // ../../packages/shared/src/review-live.ts
-import { z as z10 } from "zod";
+import { z as z15 } from "zod";
 var LIVE_PICTURE_MAX = 1024;
-var LivePeerSchema = z10.object({
-  id: z10.string(),
-  name: z10.string().max(100),
-  colour: z10.string().max(32),
+var LivePeerSchema = z15.object({
+  id: z15.string(),
+  name: z15.string().max(100),
+  colour: z15.string().max(32),
   /** their profile picture (https), when sign-in gave one; else clients show initials */
-  picture: z10.string().max(LIVE_PICTURE_MAX).optional()
+  picture: z15.string().max(LIVE_PICTURE_MAX).optional()
 });
-var LiveTicketSchema = z10.object({
-  url: z10.string(),
-  ticket: z10.string(),
+var LiveTicketSchema = z15.object({
+  url: z15.string(),
+  ticket: z15.string(),
   /** seconds the ticket is good for: connect before then */
-  expiresIn: z10.number().int()
+  expiresIn: z15.number().int()
 });
-var path2 = z10.string().max(COMMENT_PATH_MAX);
-var hash2 = z10.string().max(COMMENT_PATH_MAX);
-var LiveClientMessageSchema = z10.discriminatedUnion("type", [
-  z10.object({ type: z10.literal("hello") }),
+var path2 = z15.string().max(COMMENT_PATH_MAX);
+var hash2 = z15.string().max(COMMENT_PATH_MAX);
+var LiveClientMessageSchema = z15.discriminatedUnion("type", [
+  z15.object({ type: z15.literal("hello") }),
   /** where this peer's pointer is; `anchor` null when it left the page */
-  z10.object({
-    type: z10.literal("cursor"),
+  z15.object({
+    type: z15.literal("cursor"),
     path: path2,
     hash: hash2,
     anchor: CommentAnchorSchema.nullable()
   }),
-  z10.object({ type: z10.literal("ping") })
+  z15.object({ type: z15.literal("ping") })
 ]);
-var LiveServerMessageSchema = z10.discriminatedUnion("type", [
+var LiveServerMessageSchema = z15.discriminatedUnion("type", [
   /** the answer to `hello`: who this connection is, and who else is in the room */
-  z10.object({ type: z10.literal("welcome"), you: LivePeerSchema, peers: z10.array(LivePeerSchema) }),
-  z10.object({ type: z10.literal("join"), peer: LivePeerSchema }),
-  z10.object({ type: z10.literal("leave"), peerId: z10.string() }),
-  z10.object({
-    type: z10.literal("cursor"),
-    peerId: z10.string(),
+  z15.object({ type: z15.literal("welcome"), you: LivePeerSchema, peers: z15.array(LivePeerSchema) }),
+  z15.object({ type: z15.literal("join"), peer: LivePeerSchema }),
+  z15.object({ type: z15.literal("leave"), peerId: z15.string() }),
+  z15.object({
+    type: z15.literal("cursor"),
+    peerId: z15.string(),
     path: path2,
     hash: hash2,
     anchor: CommentAnchorSchema.nullable()
   }),
   /** the site's comments changed: refetch them */
-  z10.object({ type: z10.literal("comments") }),
-  z10.object({ type: z10.literal("pong") })
+  z15.object({ type: z15.literal("comments") }),
+  z15.object({ type: z15.literal("pong") })
 ]);
 
 // src/cli.ts
-import chalk11 from "chalk";
+import chalk13 from "chalk";
 import { Command, Option } from "commander";
 
 // src/commands/auth.ts
@@ -1360,7 +2082,7 @@ function exitCodeFor(error) {
 // package.json
 var package_default = {
   name: "@nearform/fling",
-  version: "0.6.0",
+  version: "0.7.0",
   license: "MIT",
   description: "Fling a folder of static files at a Fling server and get a link back. CLI + MCP server.",
   type: "module",
@@ -1369,9 +2091,7 @@ var package_default = {
   },
   files: [
     "dist/cli.js",
-    "dist/cli.js.map",
-    "README.md",
-    "CHANGELOG.md"
+    "README.md"
   ],
   engines: {
     node: ">=22"
@@ -1403,6 +2123,7 @@ var package_default = {
     zod: "^4.6.7"
   },
   devDependencies: {
+    "@anthropic-ai/mcpb": "^2.1.2",
     "@fling/shared": "workspace:*",
     "@types/node": "^24.0.0",
     esbuild: "^0.25.12",
@@ -1543,7 +2264,7 @@ function errorFromResponse(status, body, method, path3) {
       code,
       body,
       message: envelope.data.error.message,
-      hint: code ? NEVER_PUBLISHED_HINTS[code] : void 0
+      hint: code ? ERROR_HINTS[code] : void 0
     });
     const extra = body.error;
     if (Array.isArray(extra?.findings)) Object.assign(error, { findings: extra.findings });
@@ -1557,6 +2278,10 @@ var NEVER_PUBLISHED_HINTS = {
   secret_file: "Move the secret files out of the folder, or add them to .flingignore if the site does not need them.",
   dotfile: `Dotfiles are never flung. Update the CLI (\`npm i -g ${PACKAGE_NAME}@latest\`), which skips them.`
 };
+var ERROR_HINTS = {
+  ...NEVER_PUBLISHED_HINTS,
+  too_many_invites: "Nothing changed. Addresses from outside are invited as reviewers, a few a day per person: add them tomorrow, or ask an admin to invite them."
+};
 function describeCause(cause) {
   if (cause instanceof Error) {
     const inner = cause.cause;
@@ -1571,7 +2296,7 @@ function describeCause(cause) {
 import { chmod, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { z as z11 } from "zod";
+import { z as z16 } from "zod";
 var CONFIG_DIR_NAME = ".fling";
 var CONFIG_FILE_NAME = "config.json";
 var ENV = {
@@ -1584,14 +2309,14 @@ var ENV = {
   /** A server the local MCP server adds to the remembered ones on start (the .mcpb bakes it in). */
   addServer: "FLING_ADD_SERVER"
 };
-var serverEntrySchema = z11.object({
+var serverEntrySchema = z16.object({
   /** What the server said about itself at login. A copy this CLI can't read is just refetched. */
   instance: InstanceMetadataSchema.optional().catch(void 0),
-  apiKey: z11.string().min(1).optional().catch(void 0),
-  user: z11.object({
-    email: z11.string().optional(),
-    name: z11.string().optional(),
-    userSlug: z11.string().optional()
+  apiKey: z16.string().min(1).optional().catch(void 0),
+  user: z16.object({
+    email: z16.string().optional(),
+    name: z16.string().optional(),
+    userSlug: z16.string().optional()
   }).optional().catch(void 0)
 });
 function systemLocateOptions(env = process.env) {
@@ -1809,6 +2534,18 @@ async function loadInstance(store, config, fetch2) {
     return null;
   }
 }
+async function loadInstanceWith(store, config, fetch2, capability) {
+  const stored = await loadInstance(store, config, fetch2);
+  if (stored?.capabilities[capability] === true || !config.serverUrl) return stored;
+  try {
+    const instance = await fetchInstance(config.serverUrl, fetch2);
+    if (config.remembered)
+      await store.putServer(config.serverUrl, { instance }, { makeCurrent: false });
+    return instance;
+  } catch {
+    return stored;
+  }
+}
 
 // src/auth.ts
 var CALLBACK_PORT_START = 8765;
@@ -1878,8 +2615,8 @@ async function startCallbackServer(options = {}) {
   const timeoutMs = options.timeoutMs ?? LOGIN_TIMEOUT_MS;
   let settle;
   let timer;
-  const result = new Promise((resolve5, reject) => {
-    settle = { resolve: resolve5, reject };
+  const result = new Promise((resolve6, reject) => {
+    settle = { resolve: resolve6, reject };
   }).finally(() => clearTimeout(timer));
   result.catch(() => {
   });
@@ -1940,7 +2677,7 @@ ${close ? "<script>setTimeout(function(){window.close()},800)</script>" : ""}
   res.end(html);
 }
 function listenOnFreePort(server) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let port = CALLBACK_PORT_START;
     const tryNext = () => {
       if (port > CALLBACK_PORT_END) {
@@ -1962,7 +2699,7 @@ function listenOnFreePort(server) {
       });
       server.listen(port, "127.0.0.1", () => {
         server.removeAllListeners("error");
-        resolve5(port);
+        resolve6(port);
       });
     };
     tryNext();
@@ -2057,7 +2794,7 @@ function logo(options = {}) {
   const tagline = options.tagline ?? "throw static files at the web, get a link back";
   if (columns < LOGO_WIDTH + 2) return `${gradient("\u25B6\u25B6 fling")}  ${chalk2.dim(tagline)}`;
   const lines = WORDMARK.map(
-    (row, i) => chalk2.dim(TRAILS[i] ?? "") + gradient(row, WORDMARK[0].length)
+    (row2, i) => chalk2.dim(TRAILS[i] ?? "") + gradient(row2, WORDMARK[0].length)
   );
   return ["", ...lines, `${" ".repeat(TRAILS[0].length)}${chalk2.dim(tagline)}`, ""].join("\n");
 }
@@ -2125,7 +2862,7 @@ function formatJson(value) {
 }
 function renderTable(rows, columns) {
   if (rows.length === 0) return chalk4.dim("(no results)");
-  const cells = rows.map((row) => columns.map((column) => formatCell(column.value(row))));
+  const cells = rows.map((row2) => columns.map((column) => formatCell(column.value(row2))));
   const widths = columns.map(
     (column, i) => Math.max(column.header.length, ...cells.map((line) => line[i]?.length ?? 0))
   );
@@ -2209,8 +2946,8 @@ function requireClient(ctx) {
 }
 
 // src/sites.ts
-import { z as z12 } from "zod";
-var ShareResponseSchema2 = z12.looseObject({ shareUrl: z12.string() });
+import { z as z17 } from "zod";
+var ShareResponseSchema2 = z17.looseObject({ shareUrl: z17.string() });
 var sitePath2 = (name) => `/api/sites/${encodeURIComponent(name)}`;
 function whoami(client) {
   return client.request("GET", "/api/me", { schema: MeSchema });
@@ -2223,11 +2960,11 @@ function checkName(client, name) {
 function sitesBaseOf(instance) {
   return instance ? { protocol: `${instance.siteScheme}:`, domain: instance.sitesDomain } : null;
 }
-function siteUrlFor(name, base) {
-  return siteUrl(name, base.domain, base.protocol);
+function siteUrlFor(name, base2) {
+  return siteUrl(name, base2.domain, base2.protocol);
 }
-function sitesPattern(base) {
-  return base ? siteUrlFor("<name>", base) : "<name>.<sites domain>";
+function sitesPattern(base2) {
+  return base2 ? siteUrlFor("<name>", base2) : "<name>.<sites domain>";
 }
 async function listSites(client, opts = {}) {
   const res = await client.request("GET", "/api/sites", {
@@ -2269,6 +3006,15 @@ async function setVisibility(client, name, visibility) {
   const raw = await client.request("PATCH", sitePath2(name), { body: { visibility } });
   return siteAfter(client, name, raw);
 }
+async function setAccess(client, name, access2, audience) {
+  return client.request("PATCH", sitePath2(name), {
+    schema: SiteWithAudienceSchema,
+    body: { access: access2, ...audience ? { audience } : {} }
+  });
+}
+function accessLevelsEnabled(instance) {
+  return instance?.capabilities.accessLevels === true;
+}
 async function getAudience(client, name) {
   const site = await getSite(client, name);
   if (!site.audience) throw noAudiences();
@@ -2303,6 +3049,37 @@ function audiencesEnabled(instance) {
   if (!instance) return false;
   return instance.capabilities.audiences ?? true;
 }
+function siteRolesEnabled(instance) {
+  return instance?.capabilities.siteRoles === true;
+}
+function pathPublishEnabled(instance) {
+  return instance?.capabilities.pathPublish === true;
+}
+function pullEnabled(instance) {
+  return instance?.capabilities.pull === true;
+}
+var noRoles = () => new CliError("This Fling does not support site owners and publishers", {
+  hint: "Ask its operator to update it."
+});
+var withRoles = (site) => {
+  if (!site.owners) throw noRoles();
+  return {
+    ...site,
+    owners: site.owners,
+    publishers: site.publishers ?? { emails: [], groups: [] }
+  };
+};
+async function getRoles(client, name) {
+  return withRoles(await getSite(client, name));
+}
+async function setRoles(client, name, which, change) {
+  const current = await getRoles(client, name);
+  const site = await client.request("PATCH", sitePath2(name), {
+    schema: SiteWithAudienceSchema,
+    body: { [which]: editRoleInput(current[which], change) }
+  });
+  return withRoles(site);
+}
 var groupPath = (slug) => `/api/groups/${encodeURIComponent(slug)}`;
 async function listGroups(client, opts = {}) {
   const res = await client.request("GET", "/api/groups", {
@@ -2389,6 +3166,42 @@ function commentsEnabled(instance) {
   if (!instance) return false;
   return instance.capabilities.comments ?? true;
 }
+function notificationsEnabled(instance) {
+  if (!instance) return false;
+  return instance.capabilities.notifications ?? true;
+}
+async function notificationsCall(name, call) {
+  try {
+    return await call();
+  } catch (err) {
+    if (err instanceof CliApiError && err.status === 404) {
+      throw new CliError(`${name} has no notifications`);
+    }
+    throw err;
+  }
+}
+function getNotifications(client, name = "This Fling") {
+  return notificationsCall(
+    name,
+    () => client.request("GET", "/api/me/notifications", { schema: NotificationSettingsSchema })
+  );
+}
+function setNotifications(client, change, name = "This Fling") {
+  return notificationsCall(
+    name,
+    () => client.request("PUT", "/api/me/notifications", {
+      schema: NotificationSettingsSchema,
+      body: preferencesUpdateOf(change)
+    })
+  );
+}
+async function listSentNotifications(client, name = "This Fling") {
+  const res = await notificationsCall(
+    name,
+    () => client.request("GET", "/api/me/notifications/sent", { schema: SentNotificationListSchema })
+  );
+  return res.sent;
+}
 
 // src/commands/auth.ts
 async function loginServer(ctx, url) {
@@ -2602,8 +3415,8 @@ async function runUncomment(ctx, name, id, opts) {
 }
 
 // src/commands/deploy.ts
-import { stat as stat4 } from "node:fs/promises";
-import { resolve as resolve3 } from "node:path";
+import { stat as stat5 } from "node:fs/promises";
+import { relative as relative4, resolve as resolve3 } from "node:path";
 import chalk7 from "chalk";
 
 // src/deploy.ts
@@ -2624,7 +3437,7 @@ import { join as join2, relative, sep } from "node:path";
 import ignore from "ignore";
 var GIT_TIMEOUT_MS = 2e4;
 function git(cwd, args, input) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     try {
       const child = execFile(
         "git",
@@ -2632,14 +3445,14 @@ function git(cwd, args, input) {
         { timeout: GIT_TIMEOUT_MS, maxBuffer: 256 * 1024 * 1024, encoding: "utf8" },
         (error, stdout) => {
           const code = error?.code;
-          if (error && !(args[0] === "check-ignore" && code === 1)) resolve5(null);
-          else resolve5(stdout);
+          if (error && !(args[0] === "check-ignore" && code === 1)) resolve6(null);
+          else resolve6(stdout);
         }
       );
-      child.on("error", () => resolve5(null));
+      child.on("error", () => resolve6(null));
       if (input !== void 0) child.stdin?.end(input);
     } catch {
-      resolve5(null);
+      resolve6(null);
     }
   });
 }
@@ -2680,9 +3493,9 @@ function nestedMode() {
   return {
     mode: "nested",
     ignores(rel, isDir) {
-      for (const { base, ig } of levels) {
-        if (base && !rel.startsWith(`${base}/`)) continue;
-        const sub = base ? rel.slice(base.length + 1) : rel;
+      for (const { base: base2, ig } of levels) {
+        if (base2 && !rel.startsWith(`${base2}/`)) continue;
+        const sub = base2 ? rel.slice(base2.length + 1) : rel;
         if (sub && ig.ignores(isDir ? `${sub}/` : sub)) return true;
       }
       return false;
@@ -3084,6 +3897,20 @@ async function nameTakenError(client, name, body) {
   }
   return new NameTakenError(name, suggestions);
 }
+var BaseChangedError = class extends CliError {
+  constructor(siteName2, base2, hint) {
+    super(
+      `${siteName2} has changed since you pulled it (version ${base2}): someone published it since`,
+      {
+        hint: hint ?? "Pull it again into another folder, redo your changes there and deploy that, or deploy with --force to replace what they published."
+      }
+    );
+    this.siteName = siteName2;
+    this.base = base2;
+    this.name = "BaseChangedError";
+  }
+  code = "base_changed";
+};
 var UPLOAD_CONCURRENCY = 8;
 var UPLOAD_RETRIES = 3;
 function resolveSiteName(dir, name) {
@@ -3104,39 +3931,62 @@ function resolveSiteName(dir, name) {
   return derived;
 }
 var defaultSleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var baseChanged = (error) => error instanceof CliApiError && error.status === 409 && error.code === "base_changed";
 async function deploy(deps, opts) {
   const name = resolveSiteName(opts.dir, opts.name);
   const local = opts.manifest ?? await buildManifest(opts.dir);
-  const base = {
+  try {
+    return await deployOnce(deps, opts, name, local);
+  } catch (error) {
+    if (opts.path === void 0 || !baseChanged(error)) throw error;
+    return deployOnce(deps, opts, name, local);
+  }
+}
+async function deployOnce(deps, opts, name, local) {
+  const onBaseChanged = (error) => opts.base !== void 0 && baseChanged(error) ? new BaseChangedError(name, opts.base) : error;
+  const folder = opts.path;
+  const prefix = folder ?? opts.within;
+  const sitePath3 = (file) => prefix === void 0 ? file : `${prefix}/${file}`;
+  const base2 = {
     name,
     fileCount: local.files.length,
     totalBytes: local.totalBytes,
-    warnings: local.warnings
+    warnings: local.warnings,
+    ...folder === void 0 ? {} : { path: folder }
   };
   const path3 = `/api/sites/${encodeURIComponent(name)}/deploys`;
+  const manifest = toManifest(local);
   const res = await deps.client.request("POST", path3, {
     schema: DeployResponseSchema,
     body: {
-      manifest: toManifest(local),
+      manifest: { files: manifest.files.map((f) => ({ ...f, path: sitePath3(f.path) })) },
+      ...folder === void 0 ? {} : { path: folder },
+      ...opts.base === void 0 ? {} : {
+        base: opts.base,
+        ...opts.partial ? { partial: true, remove: opts.remove ?? [] } : {}
+      },
       ...opts.spa !== void 0 ? { spa: opts.spa } : {},
-      ...opts.public ? { visibility: "public" } : {}
+      ...opts.public ? { visibility: "public" } : {},
+      ...opts.access ? { access: opts.access } : {},
+      ...opts.audience ? { audience: opts.audience } : {}
     }
   }).catch(async (error) => {
     if (error instanceof CliApiError && error.status === 409 && error.code === "name_taken")
       throw await nameTakenError(deps.client, name, error.body);
-    throw error;
+    throw onBaseChanged(error);
   });
   if (res.status !== "upload") {
     return {
-      ...base,
+      ...base2,
       status: res.status,
       url: res.site.url,
       versionId: res.versionId,
       site: res.site,
-      uploaded: 0
+      uploaded: 0,
+      first: false
     };
   }
-  const byPath = new Map(local.files.map((f) => [f.path, f]));
+  const byPath = new Map(local.files.map((f) => [sitePath3(f.path), f]));
   const uploads = res.uploads.map((u) => {
     const file = byPath.get(u.path);
     if (!file) throw new CliError(`Server asked for a file that is not in the manifest: ${u.path}`);
@@ -3152,18 +4002,19 @@ async function deploy(deps, opts) {
     bytes += u.file.size;
     opts.onProgress?.({ uploaded: done, total: uploads.length, bytes, totalBytes });
   });
-  const fin = await deps.client.request(
-    "POST",
-    `${path3}/${encodeURIComponent(res.versionId)}/finalize`,
-    { schema: FinalizeResponseSchema }
-  );
+  const fin = await deps.client.request("POST", `${path3}/${encodeURIComponent(res.versionId)}/finalize`, {
+    schema: FinalizeResponseSchema
+  }).catch((error) => {
+    throw onBaseChanged(error);
+  });
   return {
-    ...base,
+    ...base2,
     status: "live",
     url: fin.site.url,
     versionId: fin.versionId,
     site: fin.site,
-    uploaded: uploads.length
+    uploaded: uploads.length,
+    first: fin.first === true
   };
 }
 async function uploadWithRetry(deps, file, url, headers) {
@@ -3291,7 +4142,7 @@ function zipDotEntry(name) {
 async function extractZip(data, dest, skippedDotfiles = []) {
   const unsafe = [];
   let declared = 0;
-  let count = 0;
+  let count2 = 0;
   let entries;
   try {
     entries = unzipSync(data, {
@@ -3306,7 +4157,7 @@ async function extractZip(data, dest, skippedDotfiles = []) {
           if (dot && !skippedDotfiles.includes(dot)) skippedDotfiles.push(dot);
           return false;
         }
-        count++;
+        count2++;
         declared += file.originalSize;
         if (file.originalSize > MAX_FILE_BYTES)
           throw new CliError(
@@ -3316,7 +4167,7 @@ async function extractZip(data, dest, skippedDotfiles = []) {
           throw new CliError(
             `The zip expands to more than ${formatBytes(MAX_DEPLOY_BYTES)}, the limit per deploy`
           );
-        if (count > MAX_FILES) throw new CliError(`The zip has more than ${MAX_FILES} files`);
+        if (count2 > MAX_FILES) throw new CliError(`The zip has more than ${MAX_FILES} files`);
         return true;
       }
     });
@@ -3387,40 +4238,307 @@ function wrapperPage(file) {
 `;
 }
 
-// src/commands/deploy.ts
-async function runDeploy(ctx, input, opts) {
-  const client = requireClient(ctx);
-  const ask = ctx.interactive && !opts.yes;
-  const instance = await loadInstance(ctx.store, ctx.config, ctx.fetch);
-  const base = sitesBaseOf(instance);
-  const path3 = resolve3(input ?? ".");
-  if (!await stat4(path3).catch(() => null))
-    throw new CliError(`No such file or folder: ${input ?? "."}`, {
-      hint: `Give the path to a folder, .html, .zip or other file, e.g. \`${ctx.binName} deploy ./dist\`.`
-    });
-  const prepared = await prepareInput(path3);
+// src/pull.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile6, rm as rm2, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname2, join as join5 } from "node:path";
+import { z as z18 } from "zod";
+var SITE_LINK_FILE = ".fling-site.json";
+var DOWNLOAD_CONCURRENCY = 8;
+var DOWNLOAD_RETRIES = 3;
+var SiteLinkSchema = z18.object({
+  /** the Fling it was pulled from */
+  server: z18.string(),
+  name: z18.string(),
+  /** the version pulled, or the one the last deploy made */
+  versionId: z18.string(),
+  /** a pull of one folder of the site: the folder is this folder */
+  path: z18.string().optional(),
+  /** every file pulled (or deployed), by site path: its SHA-256 */
+  files: z18.record(z18.string(), z18.string())
+});
+async function readSiteLink(dir) {
+  let raw;
   try {
-    await deployPrepared(ctx, client, instance, base, prepared, opts, ask);
+    raw = await readFile6(join5(dir, SITE_LINK_FILE), "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    return SiteLinkSchema.parse(JSON.parse(raw));
+  } catch {
+    throw new CliError(`${join5(dir, SITE_LINK_FILE)} is not a site link Fling can read`, {
+      hint: "Delete it to deploy the folder as a plain folder, or pull the site again."
+    });
+  }
+}
+async function writeSiteLink(dir, link) {
+  await writeFile3(join5(dir, SITE_LINK_FILE), `${JSON.stringify(link, null, 2)}
+`);
+}
+var siteFiles = (link, local) => Object.fromEntries(
+  local.files.map((f) => [link.path === void 0 ? f.path : `${link.path}/${f.path}`, f.sha256])
+);
+function onLink(link, local) {
+  const now = siteFiles(link, local);
+  const changes = { changed: [], added: [], removed: [] };
+  for (const [path3, sha] of Object.entries(now)) {
+    const was = link.files[path3];
+    if (was === void 0) changes.added.push(path3);
+    else if (was !== sha) changes.changed.push(path3);
+  }
+  for (const path3 of Object.keys(link.files)) if (!(path3 in now)) changes.removed.push(path3);
+  return {
+    base: link.versionId,
+    ...link.path === void 0 ? {} : { partial: true, within: link.path, remove: changes.removed },
+    changes
+  };
+}
+var linkAfter = (link, versionId, local) => ({
+  ...link,
+  versionId,
+  files: siteFiles(link, local)
+});
+function describeChanges(c) {
+  const parts = [
+    c.changed.length ? `${c.changed.length} changed` : "",
+    c.added.length ? `${c.added.length} added` : "",
+    c.removed.length ? `${c.removed.length} removed` : ""
+  ].filter(Boolean);
+  return parts.length ? parts.join(", ") : "no changes";
+}
+var defaultSleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function pullSite(deps, opts) {
+  const existing = await stat4(opts.dir).catch(() => null);
+  if (existing && !existing.isDirectory()) throw new CliError(`${opts.dir} is not a folder`);
+  const entries = existing ? await readdir2(opts.dir) : [];
+  if (entries.length > 0 && !opts.force) {
+    throw new CliError(`${opts.dir} is not empty`, {
+      hint: "Pull into a new folder, or pass --force to write the files over what is there."
+    });
+  }
+  const before = entries.includes(SITE_LINK_FILE) ? await readSiteLink(opts.dir) : null;
+  const pulled = await deps.client.request(
+    "GET",
+    `/api/sites/${encodeURIComponent(opts.name)}/pull`,
+    {
+      schema: PullResponseSchema,
+      query: { version: opts.versionId, path: opts.path }
+    }
+  );
+  const prefix = opts.path === void 0 ? "" : `${opts.path}/`;
+  const local = (f) => {
+    const rel = f.path.slice(prefix.length);
+    if (!f.path.startsWith(prefix) || !isValidSitePath(rel)) {
+      throw new CliError(`The server sent a file outside the site: ${f.path}`);
+    }
+    return rel;
+  };
+  const totalBytes = pulled.files.reduce((n, f) => n + f.size, 0);
+  let done = 0;
+  let bytes = 0;
+  await mkdir3(opts.dir, { recursive: true });
+  opts.onProgress?.({ done, total: pulled.files.length, bytes, totalBytes });
+  await mapLimit(pulled.files, DOWNLOAD_CONCURRENCY, async (f) => {
+    const target = join5(opts.dir, local(f));
+    const body = await download(deps, f);
+    await mkdir3(dirname2(target), { recursive: true });
+    await writeFile3(target, body);
+    done++;
+    bytes += f.size;
+    opts.onProgress?.({ done, total: pulled.files.length, bytes, totalBytes });
+  });
+  if (before && before.server === deps.client.serverUrl && before.name === opts.name) {
+    const now = new Set(pulled.files.map((f) => f.path));
+    const beforePrefix = before.path === void 0 ? "" : `${before.path}/`;
+    for (const path3 of Object.keys(before.files)) {
+      if (now.has(path3) || !path3.startsWith(beforePrefix)) continue;
+      const rel = path3.slice(beforePrefix.length);
+      if (isValidSitePath(rel)) await rm2(join5(opts.dir, rel), { force: true });
+    }
+  }
+  await writeSiteLink(opts.dir, {
+    server: deps.client.serverUrl,
+    name: opts.name,
+    versionId: pulled.versionId,
+    ...pulled.path === void 0 ? {} : { path: pulled.path },
+    files: Object.fromEntries(pulled.files.map((f) => [f.path, f.sha256]))
+  });
+  return {
+    server: deps.client.serverUrl,
+    name: opts.name,
+    dir: opts.dir,
+    versionId: pulled.versionId,
+    ...pulled.path === void 0 ? {} : { path: pulled.path },
+    fileCount: pulled.files.length,
+    totalBytes
+  };
+}
+async function download(deps, file) {
+  const sleep = deps.sleep ?? defaultSleep3;
+  for (let attempt = 0; ; attempt++) {
+    let retryable = true;
+    let why;
+    try {
+      const res = await deps.fetch(file.url, { signal: AbortSignal.timeout(5 * 6e4) });
+      if (res.ok) {
+        const body = new Uint8Array(await res.arrayBuffer());
+        if (createHash2("sha256").update(body).digest("hex") === file.sha256) return body;
+        why = "the bytes do not match their hash";
+      } else {
+        await res.arrayBuffer().catch(() => {
+        });
+        retryable = res.status >= 500 || res.status === 408 || res.status === 429;
+        why = `HTTP ${res.status}`;
+      }
+    } catch (error) {
+      why = `network error (${error.message})`;
+    }
+    if (!retryable || attempt >= DOWNLOAD_RETRIES) {
+      throw new CliError(`Download of ${file.path} failed: ${why}`, {
+        hint: retryable ? "Check your connection and pull again." : `Download links last ${PULL_URL_TTL_SECONDS / 60} minutes: pull again.`
+      });
+    }
+    await sleep(500 * 2 ** attempt);
+  }
+}
+
+// src/commands/deploy.ts
+function accessChoice(opts, bin = "fling") {
+  const emails2 = splitEmails(opts.add ?? []);
+  const groups2 = splitGroups(opts.group ?? []);
+  const named = emails2.length + groups2.length > 0;
+  let level;
+  if (opts.access !== void 0) {
+    const parsed = parseAccessLevel(opts.access);
+    if (!parsed) {
+      throw new CliError(`Unknown access "${opts.access}"`, {
+        hint: "Use only_me, members, groups, people or public."
+      });
+    }
+    level = parsed;
+  } else if (named) level = emails2.length ? "people" : "groups";
+  if (!level) return {};
+  if (opts.public) throw new CliError("Use --access or --public, not both");
+  if (needsAudience(level) && !named) {
+    throw new CliError(`--access ${level} needs someone to let in`, {
+      hint: `Add --add <emails> or --group <slugs> (\`${bin} groups\` lists them).`
+    });
+  }
+  if (!needsAudience(level) && named) {
+    throw new CliError(`--access ${level} lets no one else in: leave out --add and --group`);
+  }
+  return { access: level, ...needsAudience(level) ? { audience: { emails: emails2, groups: groups2 } } : {} };
+}
+async function runDeploy(ctx, input, opts) {
+  const path3 = resolve3(input ?? ".");
+  const found = await stat5(path3).catch(() => null);
+  if (!found)
+    throw new CliError(`No such file or folder: ${input ?? "."}`, {
+      hint: `Give the path to a folder, .html, .zip or other file, e.g. \`${ctx.binName} deploy ./dist\`.`
+    });
+  const linked = found.isDirectory() ? await linkedTo(ctx, await readSiteLink(path3), opts) : null;
+  if (linked) ctx = linked.ctx;
+  const link = linked?.link ?? null;
+  const client = requireClient(ctx);
+  const ask = ctx.interactive && !opts.yes;
+  const choice = accessChoice(opts, ctx.binName);
+  const folder = publishFolder(ctx, opts);
+  const needs = folder !== void 0 ? "pathPublish" : link && !opts.force ? "pull" : choice.access ? "accessLevels" : null;
+  const instance = needs ? await loadInstanceWith(ctx.store, ctx.config, ctx.fetch, needs) : await loadInstance(ctx.store, ctx.config, ctx.fetch);
+  const base2 = sitesBaseOf(instance);
+  if (folder !== void 0 && !pathPublishEnabled(instance)) {
+    throw new CliError(`${instance?.name ?? "This Fling"} can't publish to a path yet`, {
+      hint: "Leave out --path to publish the whole site, or ask its operator to update it."
+    });
+  }
+  if (link && !opts.force && !pullEnabled(instance)) {
+    throw new CliError(`${instance?.name ?? "This Fling"} can't publish on a pulled version yet`, {
+      hint: "Deploy with --force to replace the whole site with the folder, or ask its operator to update it."
+    });
+  }
+  if (choice.access && instance && !accessLevelsEnabled(instance)) {
+    throw new CliError(`${instance.name} can't take --access yet`, {
+      hint: `Leave it out, then use \`${ctx.binName} access\` or \`${ctx.binName} visibility\`.`
+    });
+  }
+  const prepared = await prepareInput(path3);
+  try {
+    const { access: _asked, path: _path, ...rest } = opts;
+    await deployPrepared(
+      ctx,
+      client,
+      instance,
+      base2,
+      prepared,
+      { ...rest, ...choice, folder, link },
+      ask
+    );
   } finally {
     await prepared.cleanup();
   }
 }
-async function deployPrepared(ctx, client, instance, base, prepared, opts, ask) {
+async function linkedTo(ctx, link, opts) {
+  if (!link) return null;
+  const plain = (why) => {
+    ctx.log.info(`The folder was pulled from ${link.name} on ${link.server}; ${why}`);
+    return null;
+  };
+  if (opts.name !== void 0 && opts.name !== link.name) {
+    return plain(`deploying it to ${opts.name} as a plain folder.`);
+  }
+  if (opts.path !== void 0) return plain("--path deploys it as a plain folder.");
+  if (ctx.config.serverUrl === link.server) return { link, ctx };
+  if (ctx.config.serverUrlSource === "flag" || ctx.config.serverUrlSource === "env") {
+    return plain(`deploying it to ${ctx.config.serverUrl} as a plain folder.`);
+  }
+  const config = await ctx.store.resolve({ serverUrl: link.server });
+  if (!config.apiKey) {
+    throw new CliError(`Not signed in to ${link.server}, where the folder was pulled from`, {
+      exitCode: EXIT_NOT_LOGGED_IN,
+      hint: `Run \`${ctx.binName} login ${link.server}\` first.`
+    });
+  }
+  return { link, ctx: { ...ctx, config } };
+}
+function publishFolder(ctx, opts) {
+  if (opts.path === void 0) return void 0;
+  const folder = normalizePublishPath(opts.path);
+  if (folder === null) {
+    throw new CliError(`Invalid --path "${opts.path}"`, {
+      hint: "Use a folder of the site, like 30-10-26 or reports/2026 (no dotfiles)."
+    });
+  }
+  if (opts.name === void 0) {
+    throw new CliError("--path needs --name: the site to publish into", {
+      hint: `e.g. \`${ctx.binName} deploy ./report --name changelog --path ${folder}\`.`
+    });
+  }
+  return folder;
+}
+async function deployPrepared(ctx, client, instance, base2, prepared, opts, ask) {
+  const { link } = opts;
+  const folder = opts.folder ?? link?.path;
+  const inFolder = (file) => folder === void 0 ? file : `${folder}/${file}`;
   let local = await buildManifest(prepared.dir);
   local.skipped.dotfiles.unshift(...prepared.skippedDotfiles);
   for (const line of describeSkipped(local.skipped)) ctx.log.info(line);
-  let name = opts.name !== void 0 ? resolveSiteName(prepared.dir, opts.name) : prepared.defaultName;
-  if (opts.name === void 0 && ask) name = await confirmSiteName(ctx, client, name, base);
-  if (!hasRootIndex(local)) {
+  let name = link ? link.name : opts.name !== void 0 ? resolveSiteName(prepared.dir, opts.name) : prepared.defaultName;
+  if (!link && opts.name === void 0 && ask) {
+    name = await confirmSiteName(ctx, client, name, base2);
+  }
+  if (!link && !hasRootIndex(local)) {
     const pages = htmlPages(local).length;
-    const root = base ? siteUrlFor(name, base) : "the site root";
-    const warning = `No index.html at the root \u2014 ${root} will show a 404.`;
+    const root = base2 ? siteUrlFor(name, base2) + (folder ? `${folder}/` : "") : "the site root";
+    const warning = `No index.html ${folder ? `in ${folder}/` : "at the root"} \u2014 ${root} will show a 404.`;
     const choice = opts.listHtml === true ? "list" : opts.listHtml === false ? "fling" : ask ? await askNoIndex(ctx, pages) : pages > 0 ? "list" : "fling";
     if (choice === "list") {
       local = await withHtmlListing(local, name);
       ctx.log.info(`Generated index.html listing ${pages} HTML page${pages === 1 ? "" : "s"}`);
     } else ctx.log.warn(warning);
   }
+  const onBase = link && !opts.force ? onLink(link, local) : null;
+  const changes = link ? onLink(link, local).changes : null;
   let progressShown = false;
   const result = await deploy(
     { client, fetch: ctx.fetch },
@@ -3428,8 +4546,15 @@ async function deployPrepared(ctx, client, instance, base, prepared, opts, ask)
       dir: prepared.dir,
       name,
       manifest: local,
+      path: opts.folder,
+      ...onBase ? {
+        base: onBase.base,
+        ...onBase.partial ? { partial: true, remove: onBase.remove, within: onBase.within } : {}
+      } : {},
       spa: opts.spa ? true : void 0,
       public: opts.public,
+      access: opts.access,
+      audience: opts.audience,
       onProgress: (p) => {
         if (p.total === 0) return;
         progressShown = true;
@@ -3438,49 +4563,80 @@ async function deployPrepared(ctx, client, instance, base, prepared, opts, ask)
         );
       }
     }
-  ).finally(() => {
+  ).catch((error) => {
+    if (!(error instanceof BaseChangedError)) throw error;
+    const dir = relative4(process.cwd(), prepared.dir) || ".";
+    throw new BaseChangedError(
+      error.siteName,
+      error.base,
+      `Pull it again into another folder (\`${ctx.binName} pull ${name} ${dir}-latest\`), redo your changes there and deploy that; or \`${ctx.binName} deploy ${dir} --force\` to replace what they published with this folder.`
+    );
+  }).finally(() => {
     if (progressShown) ctx.progress(null);
   });
+  if (link) {
+    await writeSiteLink(
+      prepared.dir,
+      linkAfter({ ...link, server: client.serverUrl }, result.versionId, local)
+    );
+  }
   for (const warning of result.warnings) if (warning !== NO_INDEX_WARNING) ctx.log.warn(warning);
-  const summary = `${result.fileCount} files, ${formatBytes(result.totalBytes)}`;
+  const summary = changes ? `${describeChanges(changes)} since ${link?.versionId}` : `${result.fileCount} files, ${formatBytes(result.totalBytes)}`;
   if (result.status === "unchanged") ctx.log.info(`Unchanged ${chalk7.dim(`(${summary})`)}`);
   else if (result.status === "repointed")
     ctx.log.success(`Restored version ${result.versionId} ${chalk7.dim(`(${summary})`)}`);
   else
     ctx.log.success(
-      `Deployed ${result.name} ${chalk7.dim(`(${summary}; uploaded ${result.uploaded}, version ${result.versionId})`)}`
+      `Deployed ${result.name}${folder ? ` to /${folder}/` : ""} ${chalk7.dim(`(${summary}; uploaded ${result.uploaded}, version ${result.versionId})`)}`
     );
+  const url = folder ? new URL(`${folder}/`, result.url).href : result.url;
   const ready = result.status === "unchanged" ? true : (await waitWithSpinner(
     ctx.waitReady,
-    result.url,
-    local.files.map((f) => f.path),
+    url,
+    local.files.map((f) => inFolder(f.path)),
     { progress: ctx.progress, warn: (m) => ctx.log.warn(m) }
   )).ready;
-  const who = instance ? `${privateAudience(instance)} can open it` : "sign-in required";
-  const privateNote = `Private: ${who}. Share publicly with \`${ctx.binName} share ${result.name}\`.`;
+  const members2 = instance ? privateAudience(instance) : "anyone signed in to this Fling";
+  const level = siteAccessLevel(result.site);
+  const who = describeSiteAccess(result.site, members2);
+  if (!result.first && opts.access) {
+    ctx.log.warn(
+      `--access only applies to a new site: ${result.name} keeps its access. Change it with \`${ctx.binName} access ${result.name}\`.`
+    );
+  }
+  const accessNotes = result.first ? [
+    `Who can open it: ${who}`,
+    accessChangeHint("cli", result.name, {
+      bin: ctx.binName,
+      invites: instance?.capabilities.invites === true
+    })
+  ] : level === "public" ? [] : [`${who} Share it with a link: \`${ctx.binName} share ${result.name}\`.`];
   const review = instance && commentsEnabled(instance) ? reviewUrl(instance.appOrigin, result.name) : void 0;
   const reviewNote = instance ? `Share for feedback (reviewers sign in to ${instance.name}):` : "Share for feedback:";
   const data = {
     status: result.status,
     site: result.site,
+    ...folder ? { path: folder, url } : {},
+    ...changes && link ? { base: opts.force ? null : link.versionId, changes } : {},
+    access: level,
+    ...result.first ? { created: true } : {},
     ...review ? { reviewUrl: review } : {},
     ready,
     skipped: local.skipped
   };
   ctx.out.data(data, () => {
-    const isPrivate = result.site.visibility === "private";
     if (ctx.out.tty)
       return box(
         [
           ...review ? [chalk7.dim(reviewNote), brand.url(review), "", chalk7.dim("Site:")] : [],
-          brand.url(result.url),
-          ...isPrivate ? [chalk7.dim(privateNote)] : []
+          brand.url(url),
+          ...accessNotes.map((n) => chalk7.dim(n))
         ],
-        isPrivate ? chalk7.bold("flung \xB7 private") : chalk7.bold("flung \xB7 public")
+        chalk7.bold(`flung \xB7 ${ACCESS_LABELS[level].toLowerCase()}`)
       );
-    const lines = [chalk7.bold(result.url)];
+    const lines = [chalk7.bold(url)];
     if (review) lines.push(chalk7.dim(`${reviewNote} ${review}`));
-    if (isPrivate) lines.push(chalk7.dim(privateNote));
+    for (const n of accessNotes) lines.push(chalk7.dim(n));
     return lines.join("\n");
   });
 }
@@ -3501,8 +4657,8 @@ async function askNoIndex(ctx, pages) {
       });
   }
 }
-async function confirmSiteName(ctx, client, generated, base) {
-  const where = (n) => base ? ` \u2192 ${siteUrlFor(n, base)}` : "";
+async function confirmSiteName(ctx, client, generated, base2) {
+  const where = (n) => base2 ? ` \u2192 ${siteUrlFor(n, base2)}` : "";
   const describe2 = (n, note) => ctx.log.info(`Site name: ${chalk7.bold(n)}${where(n)}  ${chalk7.dim(`(${note})`)}`);
   let candidate = generated;
   for (; ; ) {
@@ -3606,21 +4762,165 @@ async function runGroupDelete(ctx, slug, opts) {
   if (ctx.json) ctx.out.data(result, () => "");
 }
 
+// src/commands/notifications.ts
+import chalk9 from "chalk";
+var VALUES = ["on", "off", "default"];
+function notificationsClient(ctx) {
+  const instance = ctx.config.instance;
+  if (instance && !notificationsEnabled(instance)) {
+    throw new CliError(`${instance.name} has no notifications`);
+  }
+  return { client: requireClient(ctx), name: instance?.name ?? "This Fling" };
+}
+function renderSettings(settings) {
+  const marked = (key, channel) => {
+    const value = settings.cells[key]?.[channel] ?? "off";
+    return settings.overrides[key]?.[channel] !== void 0 ? `${value}*` : value;
+  };
+  const table = renderTable(settings.events, [
+    { header: "SECTION", value: (e) => sectionTitle(e.section) },
+    { header: "EVENT", value: (e) => e.key },
+    ...settings.channels.map((channel) => ({
+      header: channel.toUpperCase(),
+      value: (e) => marked(e.key, channel)
+    })),
+    { header: "WHEN", value: (e) => e.title }
+  ]);
+  const lines = [table, "", chalk9.dim("* your choice; the rest are the defaults")];
+  if (settings.muted) {
+    lines.unshift(
+      chalk9.yellow(
+        "Muted: nothing is sent, whatever the table says (`fling notifications unmute` to undo)."
+      ),
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+async function runNotifications(ctx) {
+  const { client, name } = notificationsClient(ctx);
+  const settings = await getNotifications(client, name);
+  ctx.out.data(settings, () => renderSettings(settings));
+}
+async function runNotificationsSet(ctx, event, channel, value) {
+  const { client, name } = notificationsClient(ctx);
+  if (!VALUES.includes(value)) {
+    throw new CliError(`"${value}" is not on, off or default`);
+  }
+  const current = await getNotifications(client, name);
+  if (!current.events.some((e) => e.key === event)) {
+    throw new CliError(`${name} has no event "${event}"`, {
+      hint: `Events: ${current.events.map((e) => e.key).join(", ")}.`
+    });
+  }
+  if (!current.channels.includes(channel)) {
+    throw new CliError(`${name} has no channel "${channel}"`, {
+      hint: `Channels: ${current.channels.join(", ")}.`
+    });
+  }
+  const settings = await setNotifications(
+    client,
+    { cells: [{ event, channel, value }] },
+    name
+  );
+  const now = settings.cells[event]?.[channel] ?? "off";
+  ctx.log.success(
+    value === "default" ? `${event} on ${channel} is back to the default (${now})` : `${event} on ${channel} is ${now}`
+  );
+  if (settings.muted) ctx.log.warn("Everything is muted, so nothing is sent until you unmute.");
+  ctx.out.data(settings, () => renderSettings(settings));
+}
+async function runNotificationsMute(ctx, muted) {
+  const { client, name } = notificationsClient(ctx);
+  const settings = await setNotifications(client, { muted }, name);
+  ctx.log.success(
+    muted ? `Muted: ${name} sends you nothing` : `Unmuted: ${name} sends what the table says`
+  );
+  if (ctx.json) ctx.out.data(settings, () => "");
+}
+async function runNotificationsSent(ctx) {
+  const { client, name } = notificationsClient(ctx);
+  const sent = await listSentNotifications(client, name);
+  ctx.out.data(
+    { sent },
+    () => sent.length ? renderTable(sent, [
+      { header: "SENT", value: (s) => formatDate(s.sentAt) },
+      { header: "CHANNEL", value: (s) => s.channel },
+      { header: "SUBJECT", value: (s) => s.subject },
+      { header: "EVENTS", value: (s) => s.eventKeys.join(", ") }
+    ]) : chalk9.dim("Nothing was sent to you in the last 30 days.")
+  );
+}
+
+// src/commands/pull.ts
+import { relative as relative5, resolve as resolve4 } from "node:path";
+import chalk10 from "chalk";
+async function runPull(ctx, name, dir, opts) {
+  const client = requireClient(ctx);
+  const instance = await loadInstanceWith(ctx.store, ctx.config, ctx.fetch, "pull");
+  if (instance && !pullEnabled(instance)) {
+    throw new CliError(`${instance.name} can't pull sites yet`, {
+      hint: "Ask its operator to update it."
+    });
+  }
+  let path3;
+  if (opts.path !== void 0) {
+    const folder = normalizePublishPath(opts.path);
+    if (folder === null) {
+      throw new CliError(`Invalid --path "${opts.path}"`, {
+        hint: "Use a folder of the site, like 30-10-26 or reports/2026 (no dotfiles)."
+      });
+    }
+    path3 = folder;
+  }
+  const target = resolve4(dir ?? name);
+  let progressShown = false;
+  const pulled = await pullSite(
+    { client, fetch: ctx.fetch },
+    {
+      name,
+      dir: target,
+      ...opts.versionId ? { versionId: opts.versionId } : {},
+      ...path3 === void 0 ? {} : { path: path3 },
+      force: opts.force,
+      onProgress: (p) => {
+        if (p.total === 0) return;
+        progressShown = true;
+        ctx.progress(
+          `downloading ${p.done}/${p.total} files \xB7 ${formatBytes(p.bytes)}/${formatBytes(p.totalBytes)}`
+        );
+      }
+    }
+  ).finally(() => {
+    if (progressShown) ctx.progress(null);
+  });
+  const shown = relative5(process.cwd(), pulled.dir) || ".";
+  ctx.log.success(
+    `Pulled ${name}${path3 ? ` /${path3}/` : ""} into ${shown} ${chalk10.dim(`(${pulled.fileCount} files, ${formatBytes(pulled.totalBytes)}, version ${pulled.versionId})`)}`
+  );
+  ctx.out.data(
+    pulled,
+    () => chalk10.dim(
+      `Change what you need, then \`${ctx.binName} deploy ${shown}\`: it publishes on version ${pulled.versionId}, and stops if someone publishes ${name} before you do.`
+    )
+  );
+}
+
 // src/commands/setup.ts
 import { intro, outro, spinner } from "@clack/prompts";
-import chalk9 from "chalk";
+import chalk11 from "chalk";
 
 // src/claude.ts
 import { execFile as execFile2 } from "node:child_process";
-import { access, mkdtemp as mkdtemp2, writeFile as writeFile3 } from "node:fs/promises";
+import { access, mkdtemp as mkdtemp2, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 var MARKETPLACE_SOURCE = REPO_SLUG;
 var MARKETPLACE_NAME = "fling";
 var PLUGIN_NAME = "fling";
 var PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
 var MCPB_PATH = "/downloads/fling.mcpb";
-var runClaude = (args) => new Promise((resolve5) => {
+var runClaude = (args) => new Promise((resolve6) => {
   execFile2(
     "claude",
     [...args],
@@ -3628,7 +4928,7 @@ var runClaude = (args) => new Promise((resolve5) => {
     (error, stdout, stderr) => {
       const missing = error?.code === "ENOENT";
       const code = !error ? 0 : missing ? -1 : typeof error.code === "number" ? error.code : 1;
-      resolve5({ code, stdout: String(stdout), stderr: String(stderr) });
+      resolve6({ code, stdout: String(stdout), stderr: String(stderr) });
     }
   );
 });
@@ -3674,7 +4974,7 @@ async function findClaudeDesktop(platform = process.platform, env = process.env,
   () => true,
   () => false
 )) {
-  const candidates = platform === "darwin" ? ["/Applications/Claude.app", join5(homedir3(), "Applications", "Claude.app")] : platform === "win32" && env.LOCALAPPDATA ? [join5(env.LOCALAPPDATA, "AnthropicClaude"), join5(env.LOCALAPPDATA, "Programs", "Claude")] : [];
+  const candidates = platform === "darwin" ? ["/Applications/Claude.app", join6(homedir3(), "Applications", "Claude.app")] : platform === "win32" && env.LOCALAPPDATA ? [join6(env.LOCALAPPDATA, "AnthropicClaude"), join6(env.LOCALAPPDATA, "Programs", "Claude")] : [];
   for (const path3 of candidates) if (await exists(path3)) return path3;
   return null;
 }
@@ -3682,9 +4982,9 @@ async function downloadExtension(serverUrl, fetch2) {
   const url = new URL(MCPB_PATH, serverUrl).toString();
   const response = await fetch2(url);
   if (!response.ok) throw new Error(`Could not download ${url} (HTTP ${response.status})`);
-  const dir = await mkdtemp2(join5(tmpdir2(), "fling-mcpb-"));
-  const file = join5(dir, "fling.mcpb");
-  await writeFile3(file, Buffer.from(await response.arrayBuffer()));
+  const dir = await mkdtemp2(join6(tmpdir2(), "fling-mcpb-"));
+  const file = join6(dir, "fling.mcpb");
+  await writeFile4(file, Buffer.from(await response.arrayBuffer()));
   return file;
 }
 
@@ -3701,14 +5001,14 @@ async function runSetup(baseCtx, opts, deps = {}) {
     ...baseCtx,
     log: createLogger({
       debug: baseCtx.config.debug,
-      write: (line) => process.stderr.write(`${chalk9.gray("\u2502")}  ${line}
+      write: (line) => process.stderr.write(`${chalk11.gray("\u2502")}  ${line}
 `)
     })
   } : baseCtx;
   if (fancy) {
     process.stderr.write(`${logo()}
 `);
-    intro(chalk9.bold(" fling setup "), { output: process.stderr });
+    intro(chalk11.bold(" fling setup "), { output: process.stderr });
   }
   const login = await stepLogin(ctx, opts.url);
   const results = {
@@ -3722,7 +5022,7 @@ async function runSetup(baseCtx, opts, deps = {}) {
   const failed = Object.values(results).includes("failed");
   if (fancy)
     outro(
-      failed ? chalk9.yellow("Setup finished with problems \u2014 see above, then run `fling setup` again.") : `You're set. Try ${chalk9.bold(`${ctx.binName} deploy ./dist`)}, or ask Claude to \u201Cfling this\u201D.`,
+      failed ? chalk11.yellow("Setup finished with problems \u2014 see above, then run `fling setup` again.") : `You're set. Try ${chalk11.bold(`${ctx.binName} deploy ./dist`)}, or ask Claude to \u201Cfling this\u201D.`,
       { output: process.stderr }
     );
   ctx.out.data(results, () => "");
@@ -3745,7 +5045,7 @@ async function signIn(ctx, serverUrl) {
     try {
       const me = await whoami(requireClient(ctx));
       if (ctx.config.remembered) await ctx.store.setCurrent(serverUrl);
-      ctx.log.success(`Signed in as ${chalk9.bold(me.name)} ${chalk9.dim(`<${me.email}>`)}`);
+      ctx.log.success(`Signed in as ${chalk11.bold(me.name)} ${chalk11.dim(`<${me.email}>`)}`);
       return "already";
     } catch (error) {
       if (exitCodeFor(error) !== 2) {
@@ -3766,7 +5066,7 @@ async function signIn(ctx, serverUrl) {
 async function stepClaudeCode(ctx, run, scope, ask, fancy) {
   const status = await claudeCodeStatus(run);
   if (status.claude === "missing") {
-    ctx.log.info(`Claude Code not found ${chalk9.dim("(no `claude` on your PATH) \u2014 skipped")}`);
+    ctx.log.info(`Claude Code not found ${chalk11.dim("(no `claude` on your PATH) \u2014 skipped")}`);
     ctx.log.hint(
       `Once it is installed, run \`${ctx.binName} setup\` again, or in Claude Code: /plugin marketplace add ${MARKETPLACE_SOURCE} then /plugin install ${PLUGIN_ID}`
     );
@@ -3775,7 +5075,7 @@ async function stepClaudeCode(ctx, run, scope, ask, fancy) {
   const installed = "installed" in status && status.installed;
   const question = installed ? `The Fling plugin is installed in Claude Code${status.version ? ` (${status.version})` : ""}. Update it to the latest?` : "Install the Fling plugin (skill + MCP server) into Claude Code?";
   if (ask && !await ctx.confirm(question)) {
-    ctx.log.info(chalk9.dim("Claude Code plugin: skipped"));
+    ctx.log.info(chalk11.dim("Claude Code plugin: skipped"));
     return installed ? "already" : "skipped";
   }
   const s = fancy ? spinner({ output: process.stderr }) : null;
@@ -3789,7 +5089,7 @@ async function stepClaudeCode(ctx, run, scope, ask, fancy) {
     else ctx.log.error(message);
     return "failed";
   }
-  const done = installed ? `Claude Code plugin ${PLUGIN_NAME} is up to date` : `Claude Code plugin ${PLUGIN_NAME} installed ${chalk9.dim(`(${scope} scope)`)}`;
+  const done = installed ? `Claude Code plugin ${PLUGIN_NAME} is up to date` : `Claude Code plugin ${PLUGIN_NAME} installed ${chalk11.dim(`(${scope} scope)`)}`;
   if (s) s.stop(done);
   else ctx.log.success(done);
   ctx.log.hint("Restart Claude Code (or run /reload-plugins) to pick it up.");
@@ -3799,7 +5099,7 @@ async function stepClaudeDesktop(ctx, deps, ask, fancy) {
   const app = await (deps.findClaudeDesktop ?? findClaudeDesktop)();
   if (!app) return "missing";
   if (ask && !await ctx.confirm("Add the Fling extension to Claude Desktop too?")) {
-    ctx.log.info(chalk9.dim("Claude Desktop extension: skipped"));
+    ctx.log.info(chalk11.dim("Claude Desktop extension: skipped"));
     return "skipped";
   }
   const s = fancy ? spinner({ output: process.stderr }) : null;
@@ -3820,7 +5120,7 @@ async function stepClaudeDesktop(ctx, deps, ask, fancy) {
 }
 
 // src/commands/sites.ts
-import chalk10 from "chalk";
+import chalk12 from "chalk";
 async function runList(ctx, opts) {
   const sites = await listSites(requireClient(ctx), opts);
   ctx.out.data(
@@ -3829,9 +5129,10 @@ async function runList(ctx, opts) {
       { header: "NAME", value: (s) => s.name },
       { header: "URL", value: (s) => s.url },
       {
-        header: "VISIBILITY",
-        value: (s) => s.archived ? `${s.visibility} (archived)` : s.visibility
+        header: "ACCESS",
+        value: (s) => accessLabel(s) + (s.archived ? " (archived)" : "")
       },
+      ...sites.some((s) => s.role) ? [{ header: "ROLE", value: (s) => s.role ?? "-" }] : [],
       { header: "SHARE", value: (s) => s.shareUrl },
       { header: "UPDATED", value: (s) => formatDate(s.updatedAt) }
     ])
@@ -3854,37 +5155,50 @@ async function runListShared(ctx, opts) {
     ])
   );
 }
+var accessLabel = (site) => ACCESS_LABELS[siteAccessLevel(site)];
+var row = (label, value) => `${chalk12.bold(`${label}:`.padEnd(14))}${value}`;
 function describeSite(site) {
-  const row = (label, value) => `${chalk10.bold(`${label}:`.padEnd(12))}${value}`;
   return [
     row("Name", site.name),
     row("URL", site.url),
-    row("Visibility", site.visibility + (site.archived ? chalk10.yellow(" (archived)") : "")),
+    row("Access", accessLabel(site) + (site.archived ? chalk12.yellow(" (archived)") : "")),
     row("SPA", site.spa ? "yes" : "no"),
     row("Share link", site.shareUrl ?? "-"),
     row("Version", site.currentVersionId ?? "-"),
-    ...filesRow(site, row),
+    ...filesRow(site),
     row("Created", formatDate(site.createdAt)),
     row("Updated", formatDate(site.updatedAt))
   ];
 }
-function filesRow(site, row) {
+function rolesRows(site) {
+  return [
+    ...site.owners ? [row("Owners", whoHolds(site.owners))] : [],
+    ...site.owners ? [row("Publishers", whoHolds(site.publishers))] : [],
+    ...site.role ? [row("You", site.role)] : []
+  ];
+}
+function filesRow(site) {
   const current = site.versions?.find((v) => v.id === site.currentVersionId);
   if (!current) return [];
   const n = current.fileCount;
-  return [row("Files", `${n} file${n === 1 ? "" : "s"}, ${formatBytes(current.totalBytes)}`)];
+  return [
+    row("Files", `${n} file${n === 1 ? "" : "s"}, ${formatBytes(current.totalBytes)}`),
+    ...current.publishedBy ? [row("Published by", current.publishedBy)] : [],
+    ...current.path ? [row("Published to", `/${current.path}/`)] : []
+  ];
 }
 var membersOf = (ctx) => ctx.config.instance ? privateAudience(ctx.config.instance) : "anyone signed in to this Fling";
 async function runInfo(ctx, name) {
   const site = await getSite(requireClient(ctx), name);
-  const access2 = site.audience && audiencesEnabled(ctx.config.instance) ? [`${chalk10.bold("Access:".padEnd(12))}${describeAudience(site, membersOf(ctx))}`] : [];
+  const access2 = site.audience && audiencesEnabled(ctx.config.instance) ? [`${chalk12.bold("Who:".padEnd(14))}${describeAudience(site, membersOf(ctx))}`] : [];
   ctx.out.data(
     site,
     () => [
       ...describeSite(site),
       ...access2,
+      ...rolesRows(site),
       "",
-      chalk10.dim(
+      chalk12.dim(
         `${site.versions.length} version(s) \u2014 \`fling versions ${name}\`; files \u2014 \`fling files ${name}\``
       )
     ].join("\n")
@@ -3899,6 +5213,8 @@ async function runVersions(ctx, name) {
       { header: "VERSION", value: (v) => v.id },
       { header: "FILES", value: (v) => v.fileCount },
       { header: "SIZE", value: (v) => formatBytes(v.totalBytes) },
+      { header: "BY", value: (v) => v.publishedBy ?? "-" },
+      { header: "PATH", value: (v) => v.path ? `/${v.path}/` : "-" },
       { header: "CREATED", value: (v) => formatDate(v.createdAt) }
     ])
   );
@@ -3910,7 +5226,7 @@ async function runFiles(ctx, name, versionId) {
   }
   ctx.out.data(result, () => {
     const n = result.files.length;
-    const header = chalk10.dim(
+    const header = chalk12.dim(
       `${result.versionId}${result.current ? " (current)" : " (not served)"} \u2014 ${n} file${n === 1 ? "" : "s"}, ${formatBytes(result.totalBytes)}${result.generatedIndex ? ", generated index.html" : ""}`
     );
     const table = renderTable(result.files, [
@@ -3946,7 +5262,7 @@ async function runShare(ctx, name, opts) {
     ctx.log.success("Share link created \u2014 anyone with it can view the site");
   ctx.out.data(
     ready === void 0 ? result : { ...result, ready },
-    () => result.shareUrl ? result.shareUrl : chalk10.dim("(no share link)")
+    () => result.shareUrl ? result.shareUrl : chalk12.dim("(no share link)")
   );
 }
 async function runVisibility(ctx, name, visibility) {
@@ -3959,7 +5275,18 @@ async function runVisibility(ctx, name, visibility) {
   );
   ctx.out.data(site, () => site.url);
 }
+function levelOf(opts) {
+  const levels = [
+    ...opts.onlyMe ? ["only_me"] : [],
+    ...opts.members ? ["members"] : [],
+    ...opts.public ? ["public"] : []
+  ];
+  if (levels.length > 1) throw new CliError("Use one of --only-me, --members and --public");
+  return levels[0];
+}
 async function runAccess(ctx, name, opts) {
+  const level = levelOf(opts);
+  if (level) return runSetLevel(ctx, name, level, opts);
   const instance = ctx.config.instance;
   if (instance && !audiencesEnabled(instance)) {
     throw new CliError(`${instance.name} can't limit a site to listed people`);
@@ -3980,6 +5307,49 @@ async function runAccess(ctx, name, opts) {
   for (const w of warnings) ctx.log.warn(w);
   ctx.out.data({ ...site, warnings }, () => describeAudience(site, membersOf(ctx)));
 }
+async function runSetLevel(ctx, name, level, opts) {
+  if (opts.add?.length || opts.remove?.length || opts.group?.length || opts.removeGroup?.length || opts.clear) {
+    throw new CliError(`--${level === "only_me" ? "only-me" : level} lets no one else in`, {
+      hint: "Leave out --add, --remove, --group, --remove-group and --clear."
+    });
+  }
+  const instance = await loadInstanceWith(ctx.store, ctx.config, ctx.fetch, "accessLevels");
+  if (instance && !accessLevelsEnabled(instance)) {
+    throw new CliError(`${instance.name} has no access levels yet`, {
+      hint: `Use \`${ctx.binName} visibility ${name} public|private\` and \`${ctx.binName} access ${name} --clear\`.`
+    });
+  }
+  const site = await setAccess(requireClient(ctx), name, level);
+  const warnings = audienceWarnings(site);
+  for (const w of warnings) ctx.log.warn(w);
+  ctx.out.data({ ...site, warnings }, () => describeAudience(site, membersOf(ctx)));
+}
+async function runRoles(ctx, which, name, opts) {
+  const instance = await loadInstanceWith(ctx.store, ctx.config, ctx.fetch, "siteRoles");
+  if (instance && !siteRolesEnabled(instance)) {
+    throw new CliError(`${instance.name} has no site owners and publishers yet`, {
+      hint: "Ask its operator to update it."
+    });
+  }
+  const change = {
+    ...opts.set ? { set: splitEmails(opts.set) } : {},
+    add: splitEmails(opts.add ?? []),
+    remove: splitEmails(opts.remove ?? []),
+    addGroups: splitGroups(opts.group ?? []),
+    removeGroups: splitGroups(opts.removeGroup ?? [])
+  };
+  if (instance && (change.addGroups.length || change.removeGroups.length)) {
+    if (!groupsEnabled(instance)) throw new CliError(`${instance.name} has no groups`);
+  }
+  const client = requireClient(ctx);
+  const changed = changesAudience(change);
+  const site = changed ? await setRoles(client, name, which, change) : await getRoles(client, name);
+  if (changed) ctx.log.success(`${name}'s ${which} changed`);
+  ctx.out.data(
+    { name: site.name, role: site.role, owners: site.owners, publishers: site.publishers },
+    () => describeRoles(site)
+  );
+}
 async function runArchive(ctx, name, unarchive = false) {
   const site = await archiveSite(requireClient(ctx), name, { unarchive });
   ctx.log.success(
@@ -4004,15 +5374,15 @@ async function runRemove(ctx, name, opts) {
 }
 
 // src/mcp.ts
-import { mkdir as mkdir3, mkdtemp as mkdtemp3, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir4, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile5 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename3, dirname as dirname2, join as join6 } from "node:path";
+import { basename as basename3, dirname as dirname3, join as join7, resolve as resolvePath } from "node:path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z13 } from "zod";
+import { z as z19 } from "zod";
 
 // src/locate.ts
-import { lstat, readdir as readdir2, readFile as readFile6, realpath as realpath3, stat as stat5 } from "node:fs/promises";
+import { lstat, readdir as readdir3, readFile as readFile7, realpath as realpath3, stat as stat6 } from "node:fs/promises";
 import { posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 var DOWNLOADS_DIR_ENV = "FLING_DOWNLOADS_DIR";
@@ -4025,7 +5395,7 @@ var SANDBOX_PATH_RE = /^\/(mnt\/user-data|mnt\/data|sessions|home\/claude|tmp\/o
 var nodeFs = {
   async stat(path3) {
     try {
-      const s = await stat5(path3);
+      const s = await stat6(path3);
       return { isFile: s.isFile(), isDirectory: s.isDirectory(), mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       return null;
@@ -4033,11 +5403,11 @@ var nodeFs = {
   },
   async readdir(path3) {
     try {
-      const entries = await readdir2(path3, { withFileTypes: true });
+      const entries = await readdir3(path3, { withFileTypes: true });
       const out = [];
       for (const e of entries) {
         if (e.isSymbolicLink()) {
-          const s = await stat5(`${path3}/${e.name}`).catch(() => null);
+          const s = await stat6(`${path3}/${e.name}`).catch(() => null);
           out.push({ name: e.name, isFile: Boolean(s?.isFile()), isDirectory: false });
         } else out.push({ name: e.name, isFile: e.isFile(), isDirectory: e.isDirectory() });
       }
@@ -4052,7 +5422,7 @@ var nodeFs = {
   async readText(path3) {
     try {
       if (!(await lstat(path3)).isFile()) return null;
-      return await readFile6(path3, "utf8");
+      return await readFile7(path3, "utf8");
     } catch {
       return null;
     }
@@ -4427,12 +5797,14 @@ var mcpLocalInstructions = (w, opts = {}) => [
   ...[serversInstructions(opts.servers ?? [])].filter((p) => p !== void 0),
   "Content you created in this conversation (an HTML page, a report, a small app): call fling_publish with every file inline (text as utf8, binary as base64). Never pass file paths from your sandbox (e.g. /mnt/user-data/outputs/\u2026, /sessions/\u2026) \u2014 this computer cannot see them \u2014 and never curl or upload from the sandbox.",
   'A file or folder the user has on this computer (a downloaded .html, a .zip, a build folder): call fling_deploy with its path, or just its file name (e.g. "Pitch Deck.html") \u2014 it is looked up in Downloads, Desktop, Documents/Claude and Claude Desktop output folders. Use fling_find_files to see recent candidates when unsure which file the user means.',
+  "To change a site that is already published, start from what is live: fling_pull downloads its files into a folder on this computer; edit them there, then fling_deploy that folder publishes on the version pulled, sending only what changed. If it says base_changed, someone published in between: pull again into another folder and redo the changes, rather than force over their work. (fling_read_files and fling_publish with `base` do the same inline, for content you edit in this conversation.)",
   "Confirm the site name with the user before publishing (fling_check_name shows whether it is free and, for a path, the generated name). Names are global, first come first served; when one is taken, offer the suggestions.",
   "When there is no index.html but there are HTML pages, fling_deploy and fling_publish do not publish: ask the user whether to generate an index page listing the pages (`listHtml: true`) or publish without one (`listHtml: false`, the root URL 404s), then retry.",
   NEVER_PUBLISHED,
   "Not logged in? Call fling_login, let the user finish signing in in the browser, then retry.",
-  `Sites are private (open to ${w.privateAudience}) by default; only make one public if asked. Use fling_share for a link people who cannot sign in can open. ${opts.comments ? "Always give the user the links that come back: the review link first, as the one to share for feedback, then the site URL." : "Always give the user the URL that comes back."}`,
-  ...opts.comments ? [COMMENTS_NOTE(w)] : []
+  `${ACCESS_NOTE(w)} Use fling_share for a link people who cannot sign in can open. ${opts.comments ? "Always give the user the links that come back: the review link first, as the one to share for feedback, then the site URL." : "Always give the user the URL that comes back."}`,
+  ...opts.comments ? [COMMENTS_NOTE(w)] : [],
+  ...opts.notifications ? [NOTIFICATIONS_NOTE(w)] : []
 ].join("\n\n");
 var onFling = (url, instance) => `
 Fling: ${serverLabel(url)}${instance ? ` (${instance.name})` : ""}`;
@@ -4446,7 +5818,7 @@ function createMcpServer(deps = {}) {
   const several = servers.length > 1;
   const wording = mcpWording(several ? null : servers[0]?.instance);
   const mcpTools2 = mcpToolsFor(wording);
-  const serverArg = z13.string().min(1).max(500).optional().describe(serverArgDescription(servers));
+  const serverArg = z19.string().min(1).max(500).optional().describe(serverArgDescription(servers));
   const note = serverToolNote(servers);
   const serverTool = (def, description = def.description) => ({
     title: def.title,
@@ -4489,6 +5861,58 @@ Not reachable yet at ${url}: ${NOT_READY_NOTE}.`
       }
     };
   }
+  async function membersOn(target2) {
+    const instance = await target2.instance();
+    return instance ? privateAudience(instance) : "anyone signed in to this Fling";
+  }
+  async function requireAccessLevels(target2) {
+    const instance = await loadInstanceWith(store, target2.config, fetchImpl, "accessLevels");
+    if (instance && !accessLevelsEnabled(instance)) {
+      throw new CliError(
+        `${instance.name} (${serverLabel(target2.url)}) has no access levels yet: leave out \`access\`, then use fling_set_visibility or fling_set_audience`
+      );
+    }
+  }
+  async function requireSiteRoles(target2) {
+    const instance = await loadInstanceWith(store, target2.config, fetchImpl, "siteRoles");
+    if (instance && !siteRolesEnabled(instance)) {
+      throw new CliError(
+        `${instance.name} (${serverLabel(target2.url)}) has no site owners and publishers yet`
+      );
+    }
+    return instance;
+  }
+  async function publishFolder2(target2, raw) {
+    const folder = normalizePublishPath(raw);
+    if (folder === null) {
+      throw new CliError(
+        `Invalid path "${raw}": use a folder of the site, like "30-10-26" or "reports/2026" (no dotfiles)`
+      );
+    }
+    const instance = await loadInstanceWith(store, target2.config, fetchImpl, "pathPublish");
+    if (!pathPublishEnabled(instance)) {
+      throw new CliError(
+        `${instance?.name ?? "This Fling"} (${serverLabel(target2.url)}) can't publish to a path yet: publish the whole site instead`
+      );
+    }
+    return folder;
+  }
+  async function requirePull(target2) {
+    const instance = await loadInstanceWith(store, target2.config, fetchImpl, "pull");
+    if (!pullEnabled(instance)) {
+      throw new CliError(
+        `${instance?.name ?? "This Fling"} (${serverLabel(target2.url)}) can't pull sites or publish on a pulled version yet`
+      );
+    }
+  }
+  async function linkedServer(path3) {
+    try {
+      const located = await resolveInput(path3, locate);
+      return located.isDirectory ? (await readSiteLink(located.path))?.server : void 0;
+    } catch {
+      return void 0;
+    }
+  }
   async function run(tool2, server2, op) {
     try {
       const { summary, data } = await op(await target(server2, tool2));
@@ -4500,18 +5924,29 @@ ${JSON.stringify(data, null, 2)}`);
     }
   }
   async function deployFolder(t2, dir, opts) {
+    if (opts.access) await requireAccessLevels(t2);
+    const link = opts.link ?? null;
+    if (link && !opts.force || opts.base !== void 0) await requirePull(t2);
+    if (opts.base !== void 0 && opts.folder !== void 0) {
+      throw new CliError("Pass `base` or `path`, not both");
+    }
+    const folder = opts.folder === void 0 ? void 0 : await publishFolder2(t2, opts.folder);
+    const shownFolder = folder ?? link?.path;
+    const inFolder = (file) => shownFolder === void 0 ? file : `${shownFolder}/${file}`;
+    const top = folder === void 0 ? "at the root" : `in /${folder}/`;
     let local = await buildManifest(dir);
     local.skipped.dotfiles.unshift(...opts.skippedDotfiles ?? []);
     const skippedNote = describeSkipped(local.skipped).map((l) => `
 ${l}.`).join("");
     let generatedIndex = false;
-    if (!hasRootIndex(local)) {
+    const asItIs = link !== null || opts.base !== void 0;
+    if (!asItIs && !hasRootIndex(local)) {
       const pages = htmlPages(local).map((f) => f.path);
       if (pages.length > 0 && opts.listHtml === void 0) {
         const shown = pages.slice(0, 20);
         return {
           kind: "needs_decision",
-          summary: `Not published yet: there is no index.html at the root, but there ${pages.length === 1 ? "is 1 HTML page" : `are ${pages.length} HTML pages`}. Ask the user whether to generate an index.html listing them (call again with \`listHtml: true\`) or to publish without one (\`listHtml: false\` \u2014 the root URL will 404, the pages still work at their own paths). Then call ${opts.retryWith} again with the same arguments plus \`listHtml\`.`,
+          summary: `Not published yet: there is no index.html ${top}, but there ${pages.length === 1 ? "is 1 HTML page" : `are ${pages.length} HTML pages`}. Ask the user whether to generate an index.html listing them (call again with \`listHtml: true\`) or to publish without one (\`listHtml: false\` \u2014 the root URL will 404, the pages still work at their own paths). Then call ${opts.retryWith} again with the same arguments plus \`listHtml\`.`,
           data: {
             status: "needs_decision",
             htmlPages: shown,
@@ -4525,10 +5960,31 @@ ${l}.`).join("");
         generatedIndex = true;
       }
     }
+    const onBase = link && !opts.force ? onLink(link, local) : null;
+    const changes = link ? onLink(link, local).changes : null;
     const result = await deploy(
       { client: t2.client, fetch: fetchImpl },
-      { dir, name: opts.name, manifest: local, spa: opts.spa, public: opts.public }
+      {
+        dir,
+        name: opts.name,
+        manifest: local,
+        path: folder,
+        ...onBase ? {
+          base: onBase.base,
+          ...onBase.partial ? { partial: true, remove: onBase.remove, within: onBase.within } : {}
+        } : opts.base !== void 0 ? { base: opts.base, partial: true, remove: opts.remove ?? [] } : {},
+        spa: opts.spa,
+        ...opts.access ? {
+          access: opts.access,
+          ...needsAudience(opts.access) ? { audience: { emails: opts.emails ?? [], groups: opts.groups ?? [] } } : {}
+        } : { public: opts.public }
+      }
     ).catch((error) => {
+      if (error instanceof BaseChangedError) {
+        throw new CliError(
+          `Not published: ${error.message}. ` + (link ? `Pull it again with fling_pull into another folder, redo the changes there and deploy that; or call ${opts.retryWith} again with \`force: true\` to replace what they published, only if the user says so.` : "Read the files again with fling_read_files and redo the changes on the new version.")
+        );
+      }
       if (!(error instanceof NameTakenError)) throw error;
       const how = opts.nameGiven ? "" : ` (generated from ${opts.nameFrom ?? "the folder"})`;
       const pick = error.suggestions.length ? ` Free alternatives: ${error.suggestions.join(", ")}.` : "";
@@ -4536,23 +5992,30 @@ ${l}.`).join("");
         `Not deployed: the site name "${error.siteName}"${how} is taken by someone else on ${serverLabel(t2.url)}.${pick} Ask the user which name to use (one of these or their own), then call ${opts.retryWith} again with \`name\`.`
       );
     });
-    const what = result.status === "unchanged" ? "Unchanged \u2014 already live" : result.status === "repointed" ? `Restored version ${result.versionId}` : `Deployed ${result.fileCount} files (uploaded ${result.uploaded})`;
+    if (link) await writeSiteLink(dir, linkAfter(link, result.versionId, local));
+    const what = result.status === "unchanged" ? "Unchanged \u2014 already live" : result.status === "repointed" ? `Restored version ${result.versionId}` : changes && link ? `Deployed ${describeChanges(changes)} since version ${link.versionId}${link.path === void 0 ? "" : ` in /${link.path}/`} (uploaded ${result.uploaded})` : opts.base !== void 0 ? `Published ${result.fileCount} changed or added file${result.fileCount === 1 ? "" : "s"} on version ${opts.base} (the rest of the site kept as it was)` : `Deployed ${result.fileCount} files${folder === void 0 ? "" : ` to /${folder}/ (the rest of the site kept as it was)`} (uploaded ${result.uploaded})`;
     const warnings = result.warnings.length ? `
 Warnings:
 - ${result.warnings.join("\n- ")}` : "";
     const edge = result.status === "unchanged" ? { ready: true, note: "" } : await edgeReady(
       result.url,
-      local.files.map((f) => f.path)
+      local.files.map((f) => inFolder(f.path))
     );
+    const url = shownFolder === void 0 ? result.url : new URL(`${shownFolder}/`, result.url).href;
     const instance = await t2.instance();
     const review = instance && commentsEnabled(instance) ? reviewUrl(instance.appOrigin, result.name) : void 0;
     const listing2 = generatedIndex ? " \u2014 with a generated index.html listing the HTML pages" : "";
+    const level = result.site.access ?? result.site.visibility;
     const head = review ? `${what}${listing2}.
 ${shareForFeedback(review, instance?.name ?? "Fling")}
-Site: ${result.url} (${result.site.visibility})` : `${what}: ${result.url} (${result.site.visibility})${listing2}`;
+Site: ${url} (${level})` : `${what}: ${url} (${level})${listing2}`;
+    const who = describeSiteAccess(result.site, await membersOn(t2));
+    const access3 = result.first ? `
+Who can open it: ${who} ${accessChangeHint("mcp", result.name, { invites: instance?.capabilities.invites === true })}` : opts.access ? `
+Its access is unchanged (deploying never changes it for an existing site): ${who} ${accessChangeHint("mcp", result.name, { invites: instance?.capabilities.invites === true })}` : "";
     return {
       kind: "deployed",
-      summary: `${head}${warnings}${skippedNote}${edge.note}${onFling(t2.url, instance)}
+      summary: `${head}${access3}${warnings}${skippedNote}${edge.note}${onFling(t2.url, instance)}
 To check exactly which files the site has, call fling_files with name "${result.name}".`,
       data: {
         status: result.status,
@@ -4562,6 +6025,9 @@ To check exactly which files the site has, call fling_files with name "${result.
         nameGenerated: !opts.nameGiven,
         versionId: result.versionId,
         site: result.site,
+        ...shownFolder === void 0 ? {} : { path: shownFolder, url },
+        ...changes && link ? { base: opts.force ? null : link.versionId, changes } : {},
+        ...result.first ? { created: true } : {},
         ...review ? { reviewUrl: review } : {},
         generatedIndex,
         warnings: result.warnings,
@@ -4574,42 +6040,65 @@ To check exactly which files the site has, call fling_files with name "${result.
     {
       instructions: mcpLocalInstructions(wording, {
         comments: servers.some((s) => commentsEnabled(s.instance)),
+        notifications: servers.some((s) => notificationsEnabled(s.instance)),
         servers
       })
     }
   );
-  const { listHtml: listHtml2, spa: spa2, public: isPublic } = mcpTools2.publish.inputSchema;
+  const { listHtml: listHtml2, spa: spa2, public: isPublic, access: access2, emails: emails2, groups: groups2 } = mcpTools2.publish.inputSchema;
   server.registerTool(
     "fling_deploy",
     {
       title: "Deploy a file or folder from this computer",
-      description: `Fling something that is on the user's computer and return its stable URL (${wording.sitesPattern}): a folder of static files (e.g. a build output like dist/), a single .html file (served as the site's index.html), a .zip of a site (extracted; a single top-level folder is unwrapped), or any other single file (.pdf, .svg, .png\u2026, served next to a generated page that shows it). \`path\` can be absolute, relative to the working directory, or just a file name ("Pitch Deck.html"): names are looked up, newest first, in Downloads, Desktop, Documents/Claude and Claude Desktop output folders, and the result says where the file was found. Never pass paths from your own sandbox (/mnt/user-data/\u2026, /sessions/\u2026): for content you created, use fling_publish. Without \`name\`, a name is generated: from the file name for files ("Pitch Deck (1).html" \u2192 pitch-deck), from the project and folder for folders (~/work/rocketpod/docs \u2192 rocketpod-docs). Site names are one global namespace, first come first served \u2014 confirm the name with the user first (fling_check_name with \`path\` shows the generated one). If the name is taken it fails with free suggestions \u2014 ask the user to pick one, then retry with \`name\`. If there is no index.html but there are HTML pages, it does not deploy: ask the user whether to generate an index page listing them (\`listHtml: true\`) or deploy without one (\`listHtml: false\`), then retry. Re-deploying identical content is a no-op. Sites are private (open to ${wording.privateAudience}) unless \`public\` is set. ${NEVER_PUBLISHED}${note}`,
+      description: `Fling something that is on the user's computer and return its stable URL (${wording.sitesPattern}): a folder of static files (e.g. a build output like dist/), a single .html file (served as the site's index.html), a .zip of a site (extracted; a single top-level folder is unwrapped), or any other single file (.pdf, .svg, .png\u2026, served next to a generated page that shows it). \`path\` can be absolute, relative to the working directory, or just a file name ("Pitch Deck.html"): names are looked up, newest first, in Downloads, Desktop, Documents/Claude and Claude Desktop output folders, and the result says where the file was found. Never pass paths from your own sandbox (/mnt/user-data/\u2026, /sessions/\u2026): for content you created, use fling_publish. Without \`name\`, a name is generated: from the file name for files ("Pitch Deck (1).html" \u2192 pitch-deck), from the project and folder for folders (~/work/rocketpod/docs \u2192 rocketpod-docs). Site names are one global namespace, first come first served \u2014 confirm the name with the user first (fling_check_name with \`path\` shows the generated one). If the name is taken it fails with free suggestions \u2014 ask the user to pick one, then retry with \`name\`. If there is no index.html but there are HTML pages, it does not deploy: ask the user whether to generate an index page listing them (\`listHtml: true\`) or deploy without one (\`listHtml: false\`), then retry. Re-deploying identical content is a no-op. ${ACCESS_NOTE(wording)} ${PATH_PUBLISH_NOTE.replace("With `path`", "With `sitePath`")} A folder made by fling_pull publishes to the site and Fling it was pulled from, on the version pulled: only what changed is sent, and if someone published the site since, it stops (base_changed) rather than replace their work; \`force: true\` replaces it anyway (only when the user says so). ${NEVER_PUBLISHED}${note}`,
       inputSchema: {
-        path: z13.string().min(1).describe(
+        path: z19.string().min(1).describe(
           "File or folder on this computer: absolute, relative to the working directory, or just its name (looked up in Downloads, Desktop and Claude output folders)"
         ),
-        name: z13.string().optional().describe(
+        name: z19.string().optional().describe(
           "Site name (lowercase letters, digits, single hyphens; max 50). Defaults to a name generated from the file or folder"
         ),
+        sitePath: z19.string().min(1).max(1024).optional().describe(
+          'Publish into this folder of the site only, e.g. "30-10-26" (served at <site>/30-10-26/), keeping every other file of the site. Needs `name`. Omit to replace the whole site'
+        ),
         spa: spa2,
+        access: access2,
+        emails: emails2,
+        groups: groups2,
         public: isPublic,
         listHtml: listHtml2,
+        force: z19.boolean().optional().describe(
+          "A folder made by fling_pull: publish it without a base, replacing whatever is live even if someone published since. Only when the user says so"
+        ),
         server: serverArg
       },
       annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
-    (args) => run("fling_deploy", args.server, async (t2) => {
+    async (args) => run("fling_deploy", args.server ?? await linkedServer(args.path), async (t2) => {
       const located = await resolveInput(args.path, locate);
+      if (args.sitePath !== void 0 && args.name === void 0) {
+        throw new CliError(
+          "`sitePath` needs `name`: the site to publish into. Ask the user which site, then call fling_deploy again"
+        );
+      }
       const prepared = await prepareInput(located.path);
       try {
-        const name = args.name !== void 0 ? resolveSiteName(prepared.dir, args.name) : prepared.defaultName;
+        const found = prepared.kind === "folder" ? await readSiteLink(prepared.dir) : null;
+        const link = found && (args.name === void 0 || args.name === found.name) && args.sitePath === void 0 && found.server === t2.url ? found : null;
+        const name = link ? link.name : args.name !== void 0 ? resolveSiteName(prepared.dir, args.name) : prepared.defaultName;
         const outcome = await deployFolder(t2, prepared.dir, {
+          link,
+          force: args.force,
           name,
-          nameGiven: args.name !== void 0,
+          nameGiven: args.name !== void 0 || link !== null,
           nameFrom: prepared.kind === "folder" ? "the folder" : "the file name",
           spa: args.spa,
           public: args.public,
+          access: args.access,
+          emails: args.emails,
+          groups: args.groups,
           listHtml: args.listHtml,
+          folder: args.sitePath,
           retryWith: "fling_deploy",
           skippedDotfiles: prepared.skippedDotfiles
         });
@@ -4632,15 +6121,97 @@ To check exactly which files the site has, call fling_files with name "${result.
       }
     })
   );
+  server.registerTool(
+    "fling_pull",
+    {
+      title: "Download a site's files to change them",
+      description: `Download a site's files into a folder on this computer, to change some or all of them and publish again: by default ~/Documents/Claude/fling/<name>. Then edit the files there and call fling_deploy with the folder: it publishes on the version pulled, sending only what changed. Anyone who can open the site may pull it; publishing needs an owner or publisher. \`path\` pulls one folder of the site (its files at the top of the folder); deploying it keeps the rest of the site. If the folder is not empty it stops, unless \`force\` (it then writes over what is there). When fling_deploy says base_changed, someone published in between: pull again into another folder and redo the changes there.` + note,
+      inputSchema: {
+        name: z19.string().min(1).max(200).describe("Site name"),
+        dir: z19.string().min(1).optional().describe(
+          "Folder to write the files to (absolute, or relative to the working directory). Default ~/Documents/Claude/fling/<name>"
+        ),
+        versionId: z19.string().min(1).max(100).optional().describe(
+          "Another version than the live one (owners and publishers; ids from fling_info)"
+        ),
+        path: z19.string().min(1).max(1024).optional().describe('Only this folder of the site, e.g. "30-10-26"'),
+        force: z19.boolean().optional().describe("Write into the folder even if it is not empty"),
+        server: serverArg
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    (args) => run("fling_pull", args.server, async (t2) => {
+      await requirePull(t2);
+      const path3 = args.path === void 0 ? void 0 : normalizePublishPath(args.path);
+      if (path3 === null) {
+        throw new CliError(
+          `Invalid path "${args.path}": use a folder of the site, like "30-10-26" (no dotfiles)`
+        );
+      }
+      const dir = args.dir === void 0 ? join7(locate.home, "Documents", "Claude", "fling", args.name) : resolvePath(cwd, args.dir);
+      const pulled = await pullSite(
+        { client: t2.client, fetch: fetchImpl },
+        {
+          name: args.name,
+          dir,
+          ...args.versionId ? { versionId: args.versionId } : {},
+          ...path3 === void 0 ? {} : { path: path3 },
+          force: args.force
+        }
+      );
+      return {
+        summary: `Pulled ${pulled.fileCount} file(s) of ${pulled.name}${path3 ? ` /${path3}/` : ""} (version ${pulled.versionId}, ${formatBytes(pulled.totalBytes)}) into ${pulled.dir}. Edit the files there, then call fling_deploy with path "${pulled.dir}": it publishes on version ${pulled.versionId}.`,
+        data: pulled
+      };
+    })
+  );
+  server.registerTool(
+    mcpTools2.readFiles.name,
+    serverTool(mcpTools2.readFiles),
+    (args) => run(mcpTools2.readFiles.name, args.server, async (t2) => {
+      await requirePull(t2);
+      const path3 = args.path === void 0 ? void 0 : normalizePublishPath(args.path);
+      if (path3 === null) throw new CliError(`Invalid path "${args.path}"`);
+      const pulled = await t2.client.request(
+        "GET",
+        `/api/sites/${encodeURIComponent(args.name)}/pull`,
+        { schema: PullResponseSchema, query: { version: args.versionId, path: path3 } }
+      );
+      const { page, tooLarge, missing, nextCursor } = pageOfFiles(pulled.files, {
+        paths: args.paths,
+        cursor: args.cursor,
+        budget: MCP_READ_MAX_BYTES
+      });
+      const read = await Promise.all(
+        page.map(async ({ url, ...f }) => {
+          const res = await fetchImpl(url);
+          if (!res.ok) throw new CliError(`Could not read ${f.path}: HTTP ${res.status}`);
+          return { ...f, ...encodeForAgent(f.path, new Uint8Array(await res.arrayBuffer())) };
+        })
+      );
+      const files = [
+        ...read,
+        ...tooLarge.map(({ url: _url, ...f }) => ({ ...f, tooLarge: true }))
+      ].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+      const result = {
+        name: args.name,
+        versionId: pulled.versionId,
+        files,
+        missing,
+        ...nextCursor ? { nextCursor } : {}
+      };
+      return { summary: describeReadFiles(args.name, result), data: result };
+    })
+  );
   server.registerTool(
     "fling_find_files",
     {
       title: "Find files to fling",
       description: "List recent things on this computer that could be flung, newest first: .html/.htm and .zip files, and folders containing an index.html, from the working directory, Downloads, Desktop, Documents/Claude, ~/Claude and Claude Desktop output folders. Each has its path, where it was found, size and modified time. Use it when the user refers to a file they downloaded or that Claude Desktop saved, then pass the chosen path (or name) to fling_deploy.",
       inputSchema: {
-        query: z13.string().optional().describe('Only names containing this text (case-insensitive), e.g. "deck"'),
-        limit: z13.number().int().min(1).max(100).optional().describe("Max results (default 20)"),
-        days: z13.number().int().min(1).max(3650).optional().describe("Only things modified in the last N days (default 14)")
+        query: z19.string().optional().describe('Only names containing this text (case-insensitive), e.g. "deck"'),
+        limit: z19.number().int().min(1).max(100).optional().describe("Max results (default 20)"),
+        days: z19.number().int().min(1).max(3650).optional().describe("Only things modified in the last N days (default 14)")
       },
       annotations: { readOnlyHint: true, openWorldHint: false }
     },
@@ -4678,7 +6249,12 @@ ${JSON.stringify(data, null, 2)}`);
     ),
     (args) => run(publishDef.name, args.server, async (t2) => {
       const name = resolveSiteName(".", args.name);
-      const tmp = await mkdtemp3(join6(tmpdir3(), "fling-publish-"));
+      if (args.remove?.length && args.base === void 0) {
+        throw new CliError("`remove` needs `base`: the versionId fling_read_files returned");
+      }
+      if (args.files.length === 0 && !args.remove?.length)
+        throw new CliError("No files to publish");
+      const tmp = await mkdtemp3(join7(tmpdir3(), "fling-publish-"));
       try {
         const { skippedDotfiles } = await writeInlineFiles(tmp, args.files);
         return await deployFolder(t2, tmp, {
@@ -4687,11 +6263,16 @@ ${JSON.stringify(data, null, 2)}`);
           nameGiven: true,
           spa: args.spa,
           public: args.public,
+          access: args.access,
+          emails: args.emails,
+          groups: args.groups,
           listHtml: args.listHtml,
+          folder: args.path,
+          ...args.base === void 0 ? {} : { base: args.base, remove: args.remove },
           retryWith: "fling_publish"
         });
       } finally {
-        await rm2(tmp, { recursive: true, force: true });
+        await rm3(tmp, { recursive: true, force: true });
       }
     })
   );
@@ -4701,8 +6282,8 @@ ${JSON.stringify(data, null, 2)}`);
       ...serverTool(mcpTools2.checkName),
       description: `${mcpTools2.checkName.description} Pass \`path\` instead of \`name\` to see the name fling_deploy would generate for a file or folder on this computer (same lookup as fling_deploy), so you can confirm it with the user.${note}`,
       inputSchema: {
-        name: z13.string().min(1).max(200).optional().describe("Site name to check"),
-        path: z13.string().optional().describe("File or folder whose generated default name to check (path or file name)"),
+        name: z19.string().min(1).max(200).optional().describe("Site name to check"),
+        path: z19.string().optional().describe("File or folder whose generated default name to check (path or file name)"),
         server: serverArg
       }
     },
@@ -4716,8 +6297,8 @@ ${JSON.stringify(data, null, 2)}`);
         name = defaultNameFor(source.path, source.isDirectory);
       }
       const check2 = await checkName(t2.client, name);
-      const base = check2.status === "invalid" ? null : sitesBaseOf(await t2.instance());
-      const url = base ? siteUrlFor(name, base) : null;
+      const base2 = check2.status === "invalid" ? null : sitesBaseOf(await t2.instance());
+      const url = base2 ? siteUrlFor(name, base2) : null;
       const suggestions = check2.suggestions.length ? ` Suggestions: ${check2.suggestions.join(", ")}.` : "";
       const summary = {
         available: `"${name}" is available${url ? ` \u2192 ${url}` : ""}.`,
@@ -4743,7 +6324,7 @@ ${JSON.stringify(data, null, 2)}`);
       title: "Sign in to Fling",
       description: `Sign the user in to ${several ? "a Fling" : wording.name}: opens their browser to sign in with ${wording.signIn} and stores the key on this computer (shared with the fling CLI). Waits up to ~30 seconds; if sign-in is not finished by then, it keeps waiting in the background for up to 5 minutes \u2014 tell the user to finish signing in in the browser, then retry what you were doing. Call it when another tool says the user is not logged in. Pass \`server\` (its address) to sign in to another Fling, including one not set up on this computer yet: it is remembered, and becomes the current one only when none is.` + note,
       inputSchema: {
-        server: z13.string().min(1).max(500).optional().describe(
+        server: z19.string().min(1).max(500).optional().describe(
           `The Fling to sign in to: its address (e.g. "https://fling.example.com"), or the host of one set up on this computer. ${several ? `Required while several Flings are set up (${servers.map((s) => serverLabel(s.url)).join(", ")})` : `Omit it to use ${servers[0] ? serverLabel(servers[0].url) : "the one this computer knows"}`}`
         )
       },
@@ -4827,7 +6408,7 @@ ${known.join("\n")}` : ""
       title: "List the Flings on this computer",
       description: `List the Flings set up on this computer, read now: each one's address, name, who is signed in (or "signed out") and which is current, the user's usual one. Call it when unsure which Fling the user means or which exist; the list may have changed since this conversation started. Pass \`use\` to make one the current Fling, the same as running \`${NPX_COMMAND} use <server>\`: it changes the default of the fling CLI too, so only do it when the user asks. It does not replace passing \`server\` to the other tools while several Flings are set up.`,
       inputSchema: {
-        use: z13.string().min(1).max(500).optional().describe(
+        use: z19.string().min(1).max(500).optional().describe(
           "Make this Fling current (address, host or unique part of it), like `fling use`"
         )
       },
@@ -4892,18 +6473,21 @@ ${lines}` : ""}`,
       return { summary: `${sites.length} site(s) on ${serverLabel(url)}`, data: { sites } };
     })
   );
-  const membersOn = async (target2) => {
-    const instance = await target2.instance();
-    return instance ? privateAudience(instance) : "anyone signed in to this Fling";
-  };
   server.registerTool(
     t.info.name,
     serverTool(t.info),
     (args) => run(t.info.name, args.server, async (target2) => {
       const site = await getSite(target2.client, args.name);
-      const access2 = site.audience ? `
+      const access3 = site.audience ? `
 ${describeAudience(site, await membersOn(target2))}` : "";
-      return { summary: `${site.name}: ${site.url}${access2}`, data: site };
+      const current = site.versions.find((v) => v.id === site.currentVersionId);
+      const by = current?.publishedBy ? ` by ${current.publishedBy}` : "";
+      const to = current?.path ? ` to /${current.path}/` : "";
+      const published = by || to ? `
+Current version published${by}${to}` : "";
+      const roles = site.owners ? `
+${describeRoles(site)}` : "";
+      return { summary: `${site.name}: ${site.url}${access3}${roles}${published}`, data: site };
     })
   );
   server.registerTool(
@@ -4939,6 +6523,24 @@ ${describeAudience(site, await membersOn(target2))}` : "";
       };
     })
   );
+  server.registerTool(
+    t.setAccess.name,
+    serverTool(t.setAccess),
+    (args) => run(t.setAccess.name, args.server, async (target2) => {
+      await requireAccessLevels(target2);
+      const site = await setAccess(
+        target2.client,
+        args.name,
+        args.access,
+        needsAudience(args.access) ? { emails: args.emails ?? [], groups: args.groups ?? [] } : void 0
+      );
+      const instance = await target2.instance();
+      return {
+        summary: `${site.name}: ${describeAudience(site, await membersOn(target2))}${onFling(target2.url, instance)}`,
+        data: site
+      };
+    })
+  );
   server.registerTool(
     t.setVisibility.name,
     serverTool(t.setVisibility),
@@ -4980,6 +6582,36 @@ ${describeAudience(site, await membersOn(target2))}` : "";
       })
     );
   }
+  for (const [def, which] of [
+    [t.setOwners, "owners"],
+    [t.setPublishers, "publishers"]
+  ]) {
+    server.registerTool(
+      def.name,
+      serverTool(def),
+      (args) => run(def.name, args.server, async (target2) => {
+        const instance = await requireSiteRoles(target2);
+        const change = {
+          add: args.add,
+          remove: args.remove,
+          set: args.set,
+          addGroups: args.addGroups,
+          removeGroups: args.removeGroups,
+          setGroups: args.setGroups
+        };
+        if (!changesAudience(change)) {
+          throw new CliError(
+            "Pass `add`, `remove`, `set`, `addGroups`, `removeGroups` or `setGroups`"
+          );
+        }
+        const site = await setRoles(target2.client, args.name, which, change);
+        return {
+          summary: `${site.name}: ${describeRoles(site)}${onFling(target2.url, instance)}`,
+          data: site
+        };
+      })
+    );
+  }
   if (servers.some((s) => groupsEnabled(s.instance))) {
     const withGroups = async (target2) => {
       const instance = await target2.instance();
@@ -4993,15 +6625,15 @@ ${describeAudience(site, await membersOn(target2))}` : "";
       serverTool(t.groups),
       (args) => run(t.groups.name, args.server, async (target2) => {
         const instance = await withGroups(target2);
-        const [groups2, me] = await Promise.all([
+        const [groups3, me] = await Promise.all([
           listGroups(target2.client, { mine: args.mine, members: args.members }),
           whoami(target2.client)
         ]);
         const which = args.members ? " of exactly those people" : "";
         return {
-          summary: args.members && groups2.length === 0 ? `No group has exactly those people${onFling(target2.url, instance)}` : `${groups2.length} ${args.mine ? "of your " : ""}group(s)${which}${onFling(target2.url, instance)}
-${describeGroups(groups2, me.email)}`,
-          data: { groups: groups2 }
+          summary: args.members && groups3.length === 0 ? `No group has exactly those people${onFling(target2.url, instance)}` : `${groups3.length} ${args.mine ? "of your " : ""}group(s)${which}${onFling(target2.url, instance)}
+${describeGroups(groups3, me.email)}`,
+          data: { groups: groups3 }
         };
       })
     );
@@ -5157,15 +6789,54 @@ ${describeGroups(groups2, me.email)}`,
       })
     );
   }
+  if (servers.some((s) => notificationsEnabled(s.instance))) {
+    const withNotifications = async (target2) => {
+      const instance = await target2.instance();
+      const name = `${instance?.name ?? "This Fling"} (${serverLabel(target2.url)})`;
+      if (instance && !notificationsEnabled(instance)) {
+        throw new CliError(`${name} has no notifications`);
+      }
+      return { name, fling: onFling(target2.url, instance) };
+    };
+    server.registerTool(
+      t.notifications.name,
+      serverTool(t.notifications),
+      (args) => run(t.notifications.name, args.server, async (target2) => {
+        const { name, fling } = await withNotifications(target2);
+        const settings = await getNotifications(target2.client, name);
+        return { summary: `${describeNotificationSettings(settings)}${fling}`, data: settings };
+      })
+    );
+    server.registerTool(
+      t.notificationsSet.name,
+      serverTool(t.notificationsSet),
+      (args) => run(t.notificationsSet.name, args.server, async (target2) => {
+        const { name, fling } = await withNotifications(target2);
+        if (args.muted === void 0 && !args.cells?.length) {
+          throw new CliError("Pass `muted` or `cells`");
+        }
+        const settings = await setNotifications(
+          target2.client,
+          { muted: args.muted, cells: args.cells },
+          name
+        );
+        return {
+          summary: `Saved.
+${describeNotificationSettings(settings)}${fling}`,
+          data: settings
+        };
+      })
+    );
+  }
   server.registerTool(
     t.whoami.name,
     serverTool(t.whoami),
     (args) => run(t.whoami.name, args.server, async (target2) => {
       const me = await whoami(target2.client);
       const instance = await target2.instance();
-      const base = sitesBaseOf(instance);
+      const base2 = sitesBaseOf(instance);
       return {
-        summary: `Signed in to ${serverLabel(target2.url)}${instance ? ` (${instance.name})` : ""} as ${me.email} (sites are served at ${sitesPattern(base)})`,
+        summary: `Signed in to ${serverLabel(target2.url)}${instance ? ` (${instance.name})` : ""} as ${me.email} (sites are served at ${sitesPattern(base2)})`,
         data: { ...me, server: target2.url }
       };
     })
@@ -5196,9 +6867,9 @@ async function writeInlineFiles(dir, files) {
     total += bytes.length;
     if (total > MAX_DEPLOY_BYTES)
       throw new CliError(`The site is larger than ${formatBytes(MAX_DEPLOY_BYTES)}`);
-    const target = join6(dir, ...path3.split("/"));
-    await mkdir3(dirname2(target), { recursive: true });
-    await writeFile4(target, bytes);
+    const target = join7(dir, ...path3.split("/"));
+    await mkdir4(dirname3(target), { recursive: true });
+    await writeFile5(target, bytes);
   }
   if (secretFiles.length > 0) throw new SecretFilesError(secretFiles);
   return { skippedDotfiles };
@@ -5242,10 +6913,10 @@ async function runMcpServer(deps = {}) {
 }
 
 // src/route.ts
-import { stat as stat6 } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
+import { stat as stat7 } from "node:fs/promises";
+import { resolve as resolve5 } from "node:path";
 var PASS_THROUGH = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version"]);
-var pathExists = (path3) => stat6(resolve4(path3)).then(
+var pathExists = (path3) => stat7(resolve5(path3)).then(
   () => true,
   () => false
 );
@@ -5296,18 +6967,18 @@ program.name(BIN_NAME).description("Fling a folder of static files at Fling and
   `server for this command: a URL, or the host of one you signed in to (default: $${ENV.url}, else the current one)`
 ).option("--json", "print JSON instead of human output", false).showHelpAfterError().configureHelp({
   sortSubcommands: false,
-  styleTitle: (title) => chalk11.bold(brand.primary(title)),
-  styleCommandText: (text2) => chalk11.bold(text2),
+  styleTitle: (title) => chalk13.bold(brand.primary(title)),
+  styleCommandText: (text2) => chalk13.bold(text2),
   styleSubcommandText: (text2) => brand.accent(text2),
   styleOptionText: (text2) => brand.accent(text2),
-  styleArgumentText: (text2) => chalk11.dim(text2)
+  styleArgumentText: (text2) => chalk13.dim(text2)
 }).addHelpText(
   "before",
   () => process.stdout.isTTY ? logo({ columns: process.stdout.columns }) : ""
 ).addHelpText(
   "after",
   () => `
-${chalk11.bold(brand.primary("Examples:"))}
+${chalk13.bold(brand.primary("Examples:"))}
   $ ${BIN_NAME} login https://fling.example.com  sign in to your Fling (once; there is no default)
   $ ${BIN_NAME} setup                      sign in and add Fling to Claude Code / Claude Desktop
   $ ${BIN_NAME} use                        list the Flings you signed in to; \`use <url>\` switches
@@ -5318,7 +6989,7 @@ ${chalk11.bold(brand.primary("Examples:"))}
   $ ${BIN_NAME} site.zip                   a zip of a site
   $ ${BIN_NAME} share my-app               public link for people who can't sign in
 
-${chalk11.dim(`Exit codes: 0 ok \xB7 1 error \xB7 2 not logged in \xB7 3 forbidden
+${chalk13.dim(`Exit codes: 0 ok \xB7 1 error \xB7 2 not logged in \xB7 3 forbidden
 Env:        ${ENV.apiKey} \xB7 ${ENV.url} \xB7 ${ENV.configDir} \xB7 ${ENV.debug}`)}`
 );
 function action(handler) {
@@ -5362,17 +7033,36 @@ program.command("deploy [path]").helpGroup("Deploy:").description(
 ).option(
   "-n, --name <name>",
   "site name \u2014 names are global, first come first served (default: generated from the project and folder, e.g. rocketpod-docs; you confirm it on a terminal)"
+).option(
+  "--path <folder>",
+  "publish into this folder of the site (e.g. 30-10-26, served at <site>/30-10-26/) and keep the rest of the site; needs --name"
 ).option("--spa", "single-page app: serve index.html for unknown paths").option(
+  "--access <level>",
+  "who can open a new site: only_me, members (everyone signed in), groups, people or public (default: the Fling's, usually only_me). A deployed site keeps its access: see `access`"
+).option("--add <emails...>", "with --access people: the addresses that may open it").option("--group <slugs...>", "with --access groups: the groups whose members may open it").option(
   "--public",
-  "make the site public: anyone can open it, reviewing still needs sign-in (default: sign-in required)"
+  "make the site public: anyone can open it, reviewing still needs sign-in (on every deploy; for a new site prefer --access public)"
 ).option(
   "-y, --yes",
   "never prompt: accept the generated name; without index.html, list the HTML pages (or fling anyway if there are none)"
-).option("--list-html", "no index.html at the root: generate one listing the HTML pages").option("--no-list-html", "no index.html at the root: fling anyway (the root will 404)").action(
+).option("--list-html", "no index.html at the root: generate one listing the HTML pages").option("--no-list-html", "no index.html at the root: fling anyway (the root will 404)").option(
+  "--force",
+  "a pulled folder: publish it without a base, replacing whatever is live (even if someone published since you pulled)"
+).action(
   action(
     (ctx, path3, opts) => runDeploy(ctx, path3, opts)
   )
 );
+program.command("pull <name> [dir]").helpGroup("Deploy:").description(
+  "download a site's files into dir (default: ./<name>) to change them; `deploy` in that folder publishes on the version pulled"
+).option(
+  "--version-id <id>",
+  "another version than the live one (owners and publishers; ids from `versions`)"
+).option("--path <folder>", "only this folder of the site (e.g. 30-10-26), at the top of dir").option("--force", "write into dir even if it is not empty").action(
+  action(
+    (ctx, name, dir, opts) => runPull(ctx, name, dir, opts)
+  )
+);
 program.command("setup [url]").helpGroup("Setup:").description(
   "sign in (to the Fling at url, which becomes current), then add the Fling plugin to Claude Code and the extension to Claude Desktop"
 ).option("-y, --yes", "do every step without asking").option("-s, --scope <scope>", "Claude Code plugin scope: user, project or local", "user").action(
@@ -5422,11 +7112,43 @@ program.command("share <name>").helpGroup("Sites:").description("print (or creat
 program.command("visibility <name> <visibility>").helpGroup("Sites:").description(
   "private (sign-in required) or public (anyone can open the site; reviewing it still needs sign-in)"
 ).action(action((ctx, name, visibility) => runVisibility(ctx, name, visibility)));
-program.command("access <name>").helpGroup("Sites:").description("show who can open a private site, or limit it to listed people and groups").option("--add <emails...>", "let these addresses in (comma-separated or repeated)").option("--remove <emails...>", "take these addresses out").option("--group <slugs...>", "let these groups in (see `fling groups`)").option("--remove-group <slugs...>", "take these groups out").option("--clear", "empty the audience: everyone signed in can open it again").action(
+program.command("access <name>").helpGroup("Sites:").description(
+  "show who can open a site, or change it: only you, everyone signed in, listed people and groups, or anyone"
+).addOption(new Option("--only-me", "only you can open it").conflicts(["members", "public"])).addOption(new Option("--members", "everyone signed in can open it").conflicts("public")).addOption(
+  new Option("--public", "anyone can open it; reviewing still needs sign-in").conflicts([
+    "add",
+    "group",
+    "clear"
+  ])
+).option(
+  "--add <emails...>",
+  "let these addresses in (comma-separated or repeated); where the Fling invites by sharing, an address from outside is invited as a reviewer"
+).option("--remove <emails...>", "take these addresses out").option("--group <slugs...>", "let these groups in (see `fling groups`)").option("--remove-group <slugs...>", "take these groups out").option("--clear", "empty the audience: everyone signed in can open it again").action(
   action(
     (ctx, name, opts) => runAccess(ctx, name, opts)
   )
 );
+for (const [which, does] of [
+  [
+    "owners",
+    "own it: publish, change its access and settings, its owners and publishers, delete it"
+  ],
+  [
+    "publishers",
+    "publish it and roll it back, but can't change its access or settings or delete it"
+  ]
+]) {
+  program.command(`${which} <name>`).helpGroup("Sites:").description(
+    `show who ${which === "owners" ? "owns" : "publishes"} a site, or change it (${which} ${does})`
+  ).option("--add <emails...>", `add these addresses (members of this Fling only)`).option("--remove <emails...>", "take these addresses out").option("--set <emails...>", `make these addresses the whole list (groups stay)`).option(
+    "--group <slugs...>",
+    "add these groups (see `fling groups`); whoever manages a group decides who is in it"
+  ).option("--remove-group <slugs...>", "take these groups out").action(
+    action(
+      (ctx, name, opts) => runRoles(ctx, which, name, opts)
+    )
+  );
+}
 program.command("archive <name>").helpGroup("Sites:").description("take a site offline (404) but keep its files; undo with unarchive").action(action((ctx, name) => runArchive(ctx, name)));
 program.command("unarchive <name>").helpGroup("Sites:").description("bring an archived site back").action(action((ctx, name) => runArchive(ctx, name, true)));
 program.command("rm <name>").helpGroup("Sites:").alias("delete").description("delete a site and all its versions (asks first unless --yes)").option("-y, --yes", "do not ask for confirmation").action(action((ctx, name, opts) => runRemove(ctx, name, opts)));
@@ -5470,6 +7192,16 @@ program.command("uncomment <name> <id>").helpGroup("Comments:").alias("delete-co
     (ctx, name, id, opts) => runUncomment(ctx, name, id, opts)
   )
 );
+var notifications = program.command("notifications").helpGroup("Notifications:").description("what this Fling tells you about, and how (default: show the table)");
+notifications.command("show", { isDefault: true }).description("show each event and channel: on or off, * where you chose it").action(action((ctx) => runNotifications(ctx)));
+notifications.command("set <event> <channel> <value>").description("turn one event on or off on a channel, or back to its default (on|off|default)").action(
+  action(
+    (ctx, event, channel, value) => runNotificationsSet(ctx, event, channel, value)
+  )
+);
+notifications.command("mute").description("stop all notifications (your choices are kept)").action(action((ctx) => runNotificationsMute(ctx, true)));
+notifications.command("unmute").description("turn notifications back on").action(action((ctx) => runNotificationsMute(ctx, false)));
+notifications.command("sent").description("list what was sent to you in the last 30 days").action(action((ctx) => runNotificationsSent(ctx)));
 program.command("mcp").helpGroup("Agents:").description("run the MCP server on stdio (used by the Claude Code plugin)").action(async (_opts, command) => {
   const globals = command.optsWithGlobals();
   await runMcpServer({ server: globals.server });
@@ -5492,4 +7224,3 @@ async function main() {
   await program.parseAsync(route.args, { from: "user" });
 }
 await main();
-//# sourceMappingURL=cli.js.map