@koda-sl/baker-cli 0.567.0 → 0.569.0

package/dist/chunk-4PAGS7QH.js

@@ -0,0 +1,76 @@
+import {
+  handleConnectionError,
+  isNotConnectedError,
+  writeAdsJson
+} from "./chunk-MK4HCMEA.js";
+import {
+  ApiError
+} from "./chunk-QEREDRZO.js";
+
+// src/commands/ads/google/service-read-errors.ts
+var KNOWN_REFUSALS = [
+  {
+    match: /BILLING_SETUP_NOT_ON_MONTHLY_INVOICING/,
+    code: "NOT_INVOICED",
+    message: "This account is not billed by monthly invoicing, so Google issues no invoices through the API.",
+    explanation: "Degrade, don't abort: the account pays automatically (card or bank), and its receipts are in Google Ads \u2192 Billing \u2192 Documents for the user to download. Spend itself is readable with `query --preset account-summary`. Carry on with the rest of the job."
+  },
+  {
+    match: /no approved billing setup/i,
+    code: "NO_BILLING_SETUP",
+    message: "This account has no approved billing setup, so it has no invoices.",
+    explanation: "Degrade, don't abort: nothing is billed to this account yet (or a manager account pays). Carry on with the rest of the job."
+  },
+  {
+    match: /BILLING_NOT_ON_MONTHLY_INVOICING|verification is only open to customers with billing setup for monthly invoicing/,
+    code: "VERIFICATION_NOT_READABLE",
+    message: "Google only reports advertiser verification through the API for accounts on monthly invoicing.",
+    explanation: "Degrade, don't abort: the status is in Google Ads \u2192 Billing \u2192 Advertiser verification, where the user can read it. Say that, and carry on with the rest of the job."
+  },
+  {
+    match: /UNSUPPORTED_AD_TYPE/,
+    code: "NO_PREVIEW_FOR_AD_TYPE",
+    message: "Google has no shareable preview for this ad type: --ads previews only video ads of Video campaigns, live on YouTube (search, display and Demand Gen ads answer unsupported).",
+    explanation: "Degrade, don't abort: preview a Performance Max campaign with --asset-groups, and describe any other ad from its copy (`ads list`, `query --preset ad-copy-performance`). Carry on with the rest of the job."
+  }
+];
+function serviceReadRefusal(message) {
+  const known = KNOWN_REFUSALS.find((refusal) => refusal.match.test(message));
+  if (!known) return null;
+  return {
+    ok: false,
+    error: {
+      code: known.code,
+      message: known.message,
+      fix: { action: "reject", explanation: known.explanation },
+      retryable: false
+    }
+  };
+}
+function exitWithServiceReadError(err) {
+  if (err instanceof ApiError) {
+    if (isNotConnectedError(err.code, err.message)) handleConnectionError("google_ads", err.message);
+    writeAdsJson(
+      serviceReadRefusal(err.message) ?? {
+        ok: false,
+        error: {
+          code: err.code,
+          message: err.message,
+          fix: { action: "reject", explanation: err.message },
+          retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE"
+        }
+      }
+    );
+    process.exit(1);
+  }
+  writeAdsJson({
+    ok: false,
+    error: { code: "NETWORK_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+  });
+  process.exit(1);
+}
+
+export {
+  exitWithServiceReadError
+};
+//# sourceMappingURL=chunk-4PAGS7QH.js.map

package/dist/chunk-5C4RRCKM.js

@@ -0,0 +1,69 @@
+import {
+  parseXApiError
+} from "./chunk-FIN4ZXGJ.js";
+import {
+  cacheGet,
+  cacheSet,
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-MK4HCMEA.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-QEREDRZO.js";
+
+// src/commands/ads/x/run-list.ts
+function buildCleanParams(opts) {
+  const out = {};
+  for (const [k, v] of Object.entries(opts.params)) {
+    if (v !== void 0 && v !== "") {
+      out[k] = v;
+    }
+  }
+  if (!opts.useCache) {
+    out["skip-cache"] = "true";
+  }
+  return out;
+}
+function emitFromCache(opts) {
+  if (!opts.useCache || opts.cacheTtlMs === void 0) return false;
+  const cached = cacheGet(opts.cacheCategory, opts.cacheKey);
+  if (!cached) return false;
+  const hints = opts.hintsFor?.(cached.data) ?? [];
+  writeAdsJson({ ok: true, data: cached.data, cached: true, ...hints.length > 0 ? { hints } : {} });
+  return true;
+}
+function emitData(opts, data) {
+  const hints = opts.hintsFor?.(data) ?? [];
+  if (opts.format !== "json") {
+    writeAdsOutput(data, opts.format, void 0, hints);
+    return;
+  }
+  writeAdsJson({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+}
+function emitError(opts, err) {
+  if (err instanceof ApiError) {
+    writeAdsJson(parseXApiError(err.message, opts.accountId ?? "\u2014"));
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+async function runListCommand(opts) {
+  if (emitFromCache(opts)) return;
+  const params = buildCleanParams(opts);
+  try {
+    const data = await apiGet(opts.path, params);
+    if (opts.useCache && opts.cacheTtlMs !== void 0) {
+      cacheSet(opts.cacheCategory, opts.cacheKey, data, opts.cacheTtlMs);
+    }
+    emitData(opts, data);
+  } catch (err) {
+    emitError(opts, err);
+  }
+}
+
+export {
+  runListCommand
+};
+//# sourceMappingURL=chunk-5C4RRCKM.js.map

package/dist/chunk-5ZHXLY7Y.js

@@ -0,0 +1,219 @@
+import {
+  bareAccountId,
+  failWriteValidation,
+  numberFlag,
+  requireTarget,
+  stageOp,
+  stageOps
+} from "./chunk-JED4JBIK.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+
+// src/commands/ads/meta/asset-writes.ts
+import { defineCommand } from "citty";
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads meta draft`.";
+var accountArg = { type: "string", description: "Meta ad account ID (act_123)" };
+var schemaId = (what) => ({ type: "positional", description: what, required: true });
+function command(input) {
+  registerSchema({
+    command: input.schema,
+    description: input.schemaDescription,
+    args: Object.fromEntries(
+      Object.entries(input.args).map(([key, arg]) => [
+        key,
+        { type: arg.type, description: arg.description, required: arg.required === true }
+      ])
+    )
+  });
+  return defineCommand({
+    meta: { name: input.name, description: `${input.description} ${STAGED_NOTE}` },
+    args: input.args,
+    run: async ({ args, rawArgs }) => {
+      await input.run(args, rawArgs);
+    }
+  });
+}
+var creativesDeleteCommand = command({
+  schema: "ads.meta.creatives.delete",
+  name: "delete",
+  description: "Stage deleting an ad creative. Meta deletes only a creative no ad runs \u2014 repoint or delete the ad first. Permanent.",
+  schemaDescription: "Stage deleting a Meta ad creative (status DELETED) \u2014 applied at publish, permanent. Meta refuses a creative an ad still runs.",
+  args: { id: { type: "positional", description: "Creative id", required: true }, "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "adCreative.update",
+      accountId: await bareAccountId(args),
+      target: requireTarget(args, "creative"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var mediaDeleteCommand = command({
+  schema: "ads.meta.media.delete",
+  name: "delete",
+  description: "Stage taking an image out of the ad account's image library, by its hash (`baker ads meta images`), or one of its videos by id (`--video-id`, from `baker ads meta media`). Meta refuses an image a creative still uses.",
+  schemaDescription: "Stage deleting an image from a Meta ad account's image library by hash, or a video from its video library by id \u2014 applied at publish. Meta refuses an image a creative uses.",
+  args: {
+    "account-id": accountArg,
+    "image-hash": { type: "string", description: "The image's hash" },
+    "video-id": { type: "string", description: "Or a video of the ad account, by id" }
+  },
+  run: async (args) => {
+    const imageHash = typeof args["image-hash"] === "string" ? args["image-hash"] : void 0;
+    const videoId = typeof args["video-id"] === "string" ? args["video-id"] : void 0;
+    if (imageHash === void 0 === (videoId === void 0)) {
+      failWriteValidation("pass --image-hash (from `baker ads meta images`) or --video-id \u2014 one of them");
+    }
+    await stageOp({ kind: "media.delete", accountId: await bareAccountId(args), payload: { imageHash, videoId } });
+  }
+});
+var customConversionsUpdateCommand = command({
+  schema: "ads.meta.custom-conversions.update",
+  name: "update",
+  description: "Stage renaming a Custom Conversion, its description or its value per conversion. Meta keeps a conversion's rule and event category for good \u2014 a conversion that counts something else is a new one.",
+  schemaDescription: "Stage a change to a Meta Custom Conversion: --name, --description, --value (value per conversion, account currency). The rule and event category cannot change (Meta accepts and ignores them).",
+  args: {
+    id: { type: "positional", description: "Custom conversion id", required: true },
+    "account-id": accountArg,
+    name: { type: "string", description: "New name" },
+    description: { type: "string", description: "New description" },
+    value: { type: "string", description: "Value of one conversion, in the account currency" }
+  },
+  run: async (args) => {
+    const payload = Object.fromEntries(
+      Object.entries({
+        name: args.name,
+        description: args.description,
+        default_conversion_value: numberFlag(args.value, "--value")
+      }).filter(([, value]) => value !== void 0)
+    );
+    await stageOp({
+      kind: "customConversion.update",
+      accountId: await bareAccountId(args),
+      target: requireTarget(args, "custom conversion"),
+      payload
+    });
+  }
+});
+var customConversionsDeleteCommand = command({
+  schema: "ads.meta.custom-conversions.delete",
+  name: "delete",
+  description: "Stage deleting a Custom Conversion. Meta archives it: it stops counting and leaves the active list, and still uses one of the account's slots. Ad sets optimizing toward it stop finding conversions.",
+  schemaDescription: "Stage deleting (archiving) a Meta Custom Conversion \u2014 applied at publish. Not reversible; it keeps its slot in the account's cap.",
+  args: { id: schemaId("Custom conversion id"), "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "customConversion.update",
+      accountId: await bareAccountId(args),
+      target: requireTarget(args, "custom conversion"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var labelsCreateCommand = command({
+  schema: "ads.meta.labels.create",
+  name: "create",
+  description: 'Stage a new ad label. File things under it with `labels attach <ref> --campaigns \u2026` in the same chat. Example: baker ads meta labels create --name "Q4 launch"',
+  schemaDescription: "Stage a new Meta ad label (created at publish). Returns a meta_temp_* ref `labels attach` takes.",
+  args: { "account-id": accountArg, name: { type: "string", description: "Label name" } },
+  run: async (args) => {
+    await stageOp({ kind: "adLabel.create", accountId: await bareAccountId(args), payload: { name: args.name } });
+  }
+});
+var labelsRenameCommand = command({
+  schema: "ads.meta.labels.rename",
+  name: "rename",
+  description: "Stage renaming an ad label.",
+  schemaDescription: "Stage renaming a Meta ad label.",
+  args: { id: schemaId("Label id"), "account-id": accountArg, name: { type: "string", description: "New name" } },
+  run: async (args) => {
+    await stageOp({
+      kind: "adLabel.update",
+      accountId: await bareAccountId(args),
+      target: requireTarget(args, "label"),
+      payload: { name: args.name }
+    });
+  }
+});
+var labelsDeleteCommand = command({
+  schema: "ads.meta.labels.delete",
+  name: "delete",
+  description: "Stage deleting an ad label. Everything filed under it keeps running, unlabelled.",
+  schemaDescription: "Stage deleting a Meta ad label \u2014 applied at publish; labelled objects keep running.",
+  args: { id: schemaId("Label id"), "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "adLabel.update",
+      accountId: await bareAccountId(args),
+      target: requireTarget(args, "label"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var LABELLED = [
+  ["campaigns", "campaign.update"],
+  ["adsets", "adSet.update"],
+  ["ads", "ad.update"],
+  ["creatives", "adCreative.update"]
+];
+var targetArgs = {
+  campaigns: { type: "string", description: "Campaign ids (comma-separated or repeated)" },
+  adsets: { type: "string", description: "Ad set ids" },
+  ads: { type: "string", description: "Ad ids" },
+  creatives: {
+    type: "string",
+    description: "Creative ids (live ones \u2014 a creative created in this chat is labelled later)"
+  }
+};
+function idsOf(rawArgs, flag, parsed) {
+  return repeatedValues(rawArgs, flag, parsed).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+}
+async function stageLabelChange(verb, args, rawArgs) {
+  const accountId = await bareAccountId(args);
+  const label = requireTarget(args, "label");
+  const targets = LABELLED.flatMap(([flag, kind]) => idsOf(rawArgs, flag, args[flag]).map((id) => ({ kind, id })));
+  if (targets.length === 0) {
+    failWriteValidation("name what to label: --campaigns, --adsets, --ads or --creatives");
+  }
+  await stageOps(
+    targets.map((target) => ({ kind: target.kind, accountId, target: target.id, payload: { [verb]: [label] } }))
+  );
+}
+var labelsAttachCommand = command({
+  schema: "ads.meta.labels.attach",
+  name: "attach",
+  description: "Stage filing campaigns, ad sets, ads or creatives under a label (a label id, or a meta_temp_* ref from `labels create`). Their other labels stay. Example: baker ads meta labels attach 120249 --campaigns 6123,6124",
+  schemaDescription: "Stage adding a Meta ad label to campaigns/ad sets/ads/creatives (--campaigns, --adsets, --ads, --creatives; comma-separated). One staged change per object; other labels kept.",
+  args: { id: schemaId("Label id or meta_temp_* ref"), "account-id": accountArg, ...targetArgs },
+  run: async (args, rawArgs) => {
+    await stageLabelChange("addLabels", args, rawArgs);
+  }
+});
+var labelsDetachCommand = command({
+  schema: "ads.meta.labels.detach",
+  name: "detach",
+  description: "Stage taking a label off campaigns, ad sets, ads or creatives. Their other labels stay.",
+  schemaDescription: "Stage removing a Meta ad label from campaigns/ad sets/ads/creatives (--campaigns, --adsets, --ads, --creatives). Other labels kept.",
+  args: { id: schemaId("Label id"), "account-id": accountArg, ...targetArgs },
+  run: async (args, rawArgs) => {
+    await stageLabelChange("removeLabels", args, rawArgs);
+  }
+});
+
+export {
+  command,
+  creativesDeleteCommand,
+  mediaDeleteCommand,
+  customConversionsUpdateCommand,
+  customConversionsDeleteCommand,
+  labelsCreateCommand,
+  labelsRenameCommand,
+  labelsDeleteCommand,
+  labelsAttachCommand,
+  labelsDetachCommand
+};
+//# sourceMappingURL=chunk-5ZHXLY7Y.js.map

package/dist/chunk-6E4KJMXO.js

@@ -0,0 +1,51 @@
+import {
+  failApi
+} from "./chunk-UJTIMPEE.js";
+import {
+  HUBSPOT_MISSING_GRANT_MARKER,
+  HUBSPOT_NOT_CONNECTED_MESSAGE
+} from "./chunk-2Q7K4F4H.js";
+import {
+  ApiError
+} from "./chunk-QEREDRZO.js";
+import {
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+
+// src/commands/hubspot/refusal.ts
+var CONTINUE = "Keep going with the wider task: say which part you could not read, skip it, and finish everything else. If the `request_connection` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 HubSpot.";
+function hubspotRefusal(code, message, reason = "so I can count a contact becoming a customer") {
+  if (code === "NOT_FOUND" && message.includes(HUBSPOT_NOT_CONNECTED_MESSAGE)) {
+    return {
+      code: "NO_HUBSPOT_CONNECTION",
+      fix: {
+        action: "request_connection",
+        explanation: `AGENT INSTRUCTION: HubSpot is not connected, and only the user can connect it. Call the \`request_connection\` tool with { platform: "hubspot", reason } \u2014 reason in their words, e.g. "${reason}" \u2014 and they connect it inside the chat; then run this command again. ` + CONTINUE
+      }
+    };
+  }
+  if (code === "FORBIDDEN" && message.includes(HUBSPOT_MISSING_GRANT_MARKER)) {
+    return {
+      code: "HUBSPOT_RECONNECT_REQUIRED",
+      fix: {
+        action: "request_connection",
+        explanation: 'AGENT INSTRUCTION: HubSpot is connected \u2014 do not tell the user it is missing, and do not retry. Its access does not cover this read (it was connected before Baker asked for it, or the access was withdrawn), and only the user can widen it. Call the `request_connection` tool with { platform: "hubspot", reason } naming what you need to read; the card offers them a Reconnect button. Run this command again once they have. ' + CONTINUE
+      }
+    };
+  }
+  return null;
+}
+function failNotConnected(err, reason) {
+  const refusal = err instanceof ApiError ? hubspotRefusal(err.code, err.message, reason) : null;
+  if (err instanceof ApiError && refusal !== null) {
+    writeJson({ ok: false, error: { code: refusal.code, message: err.message, fix: refusal.fix } });
+    process.exit(1);
+  }
+  failApi(err);
+}
+
+export {
+  hubspotRefusal,
+  failNotConnected
+};
+//# sourceMappingURL=chunk-6E4KJMXO.js.map

package/dist/chunk-7CORYCEZ.js

@@ -0,0 +1,142 @@
+import {
+  avatarsOf
+} from "./chunk-2JBPS2CV.js";
+import {
+  readAvatars
+} from "./chunk-OFMFBRSL.js";
+import {
+  readCreativeContext,
+  workspaceOfCreative
+} from "./chunk-E3PYHCQL.js";
+import {
+  frontmatterOf,
+  ruleTells
+} from "./chunk-UKZKLXTE.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-N3PASNUA.js";
+import {
+  isAdSpec,
+  nativeCopy,
+  readAdSpec
+} from "./chunk-H3HA22Z3.js";
+import {
+  marketFromCompanyDoc
+} from "./chunk-2WZI36D3.js";
+
+// src/engine/creative-context/ad-words.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+var json = (file) => readFile(file, "utf8").then((raw) => JSON.parse(raw)).catch(() => null);
+var text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+function waivedOf(spec) {
+  const waive = spec?.waive;
+  return Array.isArray(waive) ? waive.flatMap((w) => text(w?.rule) ?? []) : [];
+}
+function sceneWords(scene) {
+  const s = scene ?? {};
+  const spoken = Array.isArray(s.dialogue) ? s.dialogue.flatMap((d) => text(d?.line) ?? []) : [];
+  const shown = Array.isArray(s.overlays) ? s.overlays.flatMap((o) => text(o?.text) ?? []) : [];
+  return [...spoken, ...shown];
+}
+async function sceneFiles(creativeDir) {
+  const dir = path.join(creativeDir, "scenes");
+  const files = (await readdir(dir).catch(() => [])).filter((f) => f.endsWith(".json")).sort();
+  return await Promise.all(files.map((f) => json(path.join(dir, f))));
+}
+async function videoLanguage(creativeDir) {
+  const definition = frontmatterOf(await readFile(path.join(creativeDir, "_definition.md"), "utf8").catch(() => ""));
+  const beats = await json(path.join(creativeDir, "ad.spec.json"));
+  return text(definition?.language) ?? text(beats?.voice?.language);
+}
+async function videoWords(raw, creativeDir) {
+  const global = raw.global ?? {};
+  const transcript = text(global.transcript);
+  const scenes = [...Array.isArray(raw.scenes) ? raw.scenes : [], ...await sceneFiles(creativeDir)];
+  const lines = [.../* @__PURE__ */ new Set([...transcript ? [transcript] : [], ...scenes.flatMap(sceneWords)])];
+  const language = await videoLanguage(creativeDir);
+  return { kind: "video", lines, ...language ? { language } : {} };
+}
+function staticWords(raw) {
+  try {
+    const spec = readAdSpec(raw);
+    const lines = spec.native ? nativeCopy(spec.native) : spec.copy.map((l) => l.text);
+    const language = spec.viewer?.market?.language;
+    return { kind: "static", lines, ...language ? { language } : {} };
+  } catch {
+    return null;
+  }
+}
+async function readAdWords(creativeDir) {
+  const raw = await json(path.join(creativeDir, "prompt.json"));
+  if (!raw || typeof raw !== "object") return null;
+  const video = !isAdSpec(raw) && ("global" in raw || "scenes" in raw);
+  const words = video ? await videoWords(raw, creativeDir) : staticWords(raw);
+  if (!words) return null;
+  const product = text(raw.product);
+  const definition = frontmatterOf(await readFile(path.join(creativeDir, "_definition.md"), "utf8").catch(() => ""));
+  const platform = text(definition?.platform);
+  const listed = definition?.platforms;
+  const platforms = Array.isArray(listed) ? listed.map(text).filter((p) => p !== void 0) : [];
+  return {
+    ...words,
+    ...product ? { product } : {},
+    ...platform ? { platform } : {},
+    ...platforms.length > 0 ? { platforms } : {},
+    waived: waivedOf(raw)
+  };
+}
+
+// src/commands/canvas/rule-gate.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+function tellLine(tell) {
+  const where = tell.kind === "forbidden" ? `"${tell.line ?? ""}" says "${tell.phrase}"` : `No line says "${tell.phrase}"`;
+  const words = tell.quote ? ` Their words: ${tell.quote}` : "";
+  return `${where}: ${tell.rule} (${tell.strength}) \u2014 ${tell.text}${words}`;
+}
+function ruleRefusal(tells) {
+  if (tells.length === 0) return null;
+  return {
+    problems: [...new Set(tells.map(tellLine))],
+    fix: 'Rewrite each line named above within its rule (a static: its `copy` in prompt.json; a video: its scene files and ad.spec.json), then re-run. Only when the person explicitly asked for these words in this ad, keep them and add to prompt.json `"waive": [{"rule": "<id>", "why": "<their ask>"}]`.'
+  };
+}
+var liveRoster = () => readAvatars("/api/avatars", { status: "ready" }).then(avatarsOf, () => null);
+async function heldRules(creativeDir, ad) {
+  const words = ad === void 0 ? await readAdWords(creativeDir) : ad;
+  const root = findWorkspaceRoot(creativeDir) ?? workspaceOfCreative(creativeDir);
+  const context = await readCreativeContext(
+    root,
+    {
+      ...words ? { kind: words.kind } : {},
+      ...words?.product ? { product: words.product } : {},
+      ...words?.platform ? { platform: words.platform } : {},
+      ...words?.platforms ? { platforms: words.platforms } : {}
+    },
+    { waived: words?.waived ?? [] }
+  );
+  const language = words?.language ?? marketFromCompanyDoc(await readFile2(path2.join(root, "COMPANY.md"), "utf8").catch(() => null))?.language;
+  return { rules: context.rules, ...language ? { language } : {} };
+}
+async function ruleGate(creativeDir, roster = liveRoster) {
+  const ad = await readAdWords(creativeDir);
+  if (!ad) return { broken: null, realOnly: null };
+  const { rules, language } = await heldRules(creativeDir, ad);
+  const people = rules.find((r) => r.check?.people === "real" && r.strength !== "prefer");
+  return {
+    broken: ruleRefusal(ruleTells(ad.lines, rules, language)),
+    realOnly: people ? {
+      rule: { id: people.id, text: people.text, ...people.source.quote ? { quote: people.source.quote } : {} },
+      avatars: await roster().catch(() => null)
+    } : null
+  };
+}
+
+export {
+  readAdWords,
+  ruleRefusal,
+  heldRules,
+  ruleGate
+};
+//# sourceMappingURL=chunk-7CORYCEZ.js.map