@koda-sl/baker-cli 0.489.0-dev.63e618e80 → 0.490.0

package/dist/chunk-EOY6BK4C.js

@@ -0,0 +1,148 @@
+import {
+  RULES_DIR,
+  SAME_WORDS,
+  frontmatterOf,
+  parseIdea,
+  parseInsight
+} from "./chunk-G2LGMWNG.js";
+import {
+  rememberedJev
+} from "./chunk-FNA277HP.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-5WMTPYKT.js";
+
+// src/commands/creatives/ideas-judgments.ts
+var STATISTIC_QUESTION = `\`quote\` was filed as something a customer said. Is it instead a statistic about a group of people, a share or a figure from a survey, a study or an article ("39% of UK homeowners say\u2026", "a quarter of buyers\u2026", "1 in 3 owners\u2026"), rather than one person's own words about their own experience? A person giving their own number ("My bill dropped 40%") is their own words. The quote may be in any language.`;
+var STATISTIC_HELD = 0.65;
+var SAME_MESSAGE_QUESTION = `\`a\` and \`b\` are the messages of two ads. Do they make the same core promise to the viewer (the same benefit, the same reason to act), even when one adds a detail or a few words, says it in other words, or is in another language? Two messages that promise different things about the same product are not the same.`;
+var SAME_MESSAGE_HELD = 0.42;
+async function withStatisticsRead(insights, ask) {
+  const observed = insights.filter((i) => i.status === "observed");
+  if (observed.length === 0) return [...insights];
+  const answers = await ask(observed.map((i) => ({ instructions: { quote: i.quote, question: STATISTIC_QUESTION } })));
+  if (answers === null) return [...insights];
+  const statistics = new Set(observed.filter((_, i) => (answers[i] ?? 0) >= STATISTIC_HELD).map((i) => i.id));
+  return insights.map((i) => statistics.has(i.id) ? { ...i, status: "interpreted" } : i);
+}
+async function sameMessageRead(ideas, ask) {
+  const failed = ideas.filter((i) => i.status === "failed");
+  const pairs = failed.flatMap(
+    (f) => ideas.filter((i) => i.id !== f.id && !SAME_WORDS(i.message, f.message)).map((i) => [f.message, i.message])
+  );
+  if (pairs.length === 0) return SAME_WORDS;
+  const answers = await ask(pairs.map(([a, b]) => ({ instructions: { a, b, question: SAME_MESSAGE_QUESTION } })));
+  if (answers === null) return SAME_WORDS;
+  const same = new Set(
+    pairs.filter((_, i) => (answers[i] ?? 0) >= SAME_MESSAGE_HELD).map(([a, b]) => `${a}\0${b}`)
+  );
+  return (a, b) => SAME_WORDS(a, b) || same.has(`${a}\0${b}`) || same.has(`${b}\0${a}`);
+}
+
+// src/commands/creatives/ideas-workspace.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+var IDEAS_DIR = path.join("src", "creatives", "_ideas");
+var INSIGHTS_DIR = path.join("src", "content", "insights");
+async function markdownFiles(dir, recursive = false) {
+  const entries = await readdir(dir, { recursive }).catch(() => []);
+  return entries.filter((f) => f.endsWith(".md")).sort();
+}
+var idOf = (file) => file.replace(/\\/g, "/").replace(/\.md$/, "");
+function workspaceIdeasJudge(root) {
+  const cacheDir = path.join(root, "canvas", ".cache");
+  const spent = [];
+  return {
+    ask: rememberedJev(path.join(cacheDir, "ideas-answers.json"), (u) => spent.push(u)),
+    done: () => holdUnbilledSpend(cacheDir, spent.splice(0)).catch(() => void 0)
+  };
+}
+async function readInsights(root, opts = {}) {
+  const dir = path.join(root, INSIGHTS_DIR);
+  const insights = [];
+  for (const file of await markdownFiles(dir, true)) {
+    const insight = parseInsight(idOf(file), await readFile(path.join(dir, file), "utf8").catch(() => ""));
+    if (insight) insights.push(insight);
+  }
+  if (opts.ask) return withStatisticsRead(insights, opts.ask);
+  const judge = workspaceIdeasJudge(root);
+  const read = await withStatisticsRead(insights, judge.ask);
+  await judge.done();
+  return read;
+}
+async function readIdeas(root) {
+  const dir = path.join(root, IDEAS_DIR);
+  const ideas = [];
+  const unreadable = [];
+  for (const file of await markdownFiles(dir)) {
+    const id = idOf(file);
+    const parsed = parseIdea(id, await readFile(path.join(dir, file), "utf8").catch(() => ""));
+    if (parsed.idea) ideas.push(parsed.idea);
+    else unreadable.push({ id, problems: parsed.problems });
+  }
+  return { ideas, unreadable };
+}
+async function readPersonaIds(root) {
+  return (await markdownFiles(path.join(root, "src", "content", "personas"), true)).map(idOf);
+}
+var MAX_KNOWLEDGE_CHARS = 2e5;
+async function readKnowledgeCorpus(root) {
+  const parts = [];
+  const company = await readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => "");
+  if (company) parts.push(company);
+  const content = path.join(root, "src", "content");
+  const insights = path.relative(content, path.join(root, INSIGHTS_DIR));
+  const rules = path.relative(content, path.join(root, RULES_DIR));
+  const files = (await markdownFiles(content, true)).filter((f) => {
+    const file = f.replace(/\\/g, "/");
+    return !file.startsWith(`${insights}/`) && !file.startsWith(`${rules}/`);
+  });
+  for (const file of files) {
+    parts.push(await readFile(path.join(content, file), "utf8").catch(() => ""));
+    if (parts.join("").length > MAX_KNOWLEDGE_CHARS) break;
+  }
+  return parts.join("\n").slice(0, MAX_KNOWLEDGE_CHARS);
+}
+async function readCreativeRecords(root) {
+  const dir = path.join(root, "src", "creatives");
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
+    const raw = await readFile(path.join(dir, entry.name, "_definition.md"), "utf8").catch(() => null);
+    if (raw === null) continue;
+    const fm = frontmatterOf(raw) ?? {};
+    const pick = (key) => typeof fm[key] === "string" && fm[key] ? { [key]: fm[key] } : {};
+    records.push({
+      slug: entry.name,
+      ...pick("status"),
+      ...pick("idea"),
+      ...pick("awareness"),
+      ...pick("angle"),
+      ...pick("kind")
+    });
+  }
+  return records;
+}
+var SHOWN_STATUSES = /* @__PURE__ */ new Set(["rendered", "published"]);
+function coverageOf(ideas, creatives) {
+  const live = ideas.filter((i) => i.status === "built" || i.status === "testing" || i.status === "winner");
+  const awareness = new Set(live.map((i) => i.awareness));
+  for (const creative of creatives) {
+    if (creative.awareness && SHOWN_STATUSES.has(creative.status ?? "")) awareness.add(creative.awareness);
+  }
+  return { coveredAwareness: [...awareness].sort(), closersLive: live.filter((i) => i.job === "closer").length };
+}
+
+export {
+  sameMessageRead,
+  IDEAS_DIR,
+  workspaceIdeasJudge,
+  readInsights,
+  readIdeas,
+  readPersonaIds,
+  readKnowledgeCorpus,
+  readCreativeRecords,
+  coverageOf
+};
+//# sourceMappingURL=chunk-EOY6BK4C.js.map

package/dist/chunk-FA4YZFRV.js

@@ -0,0 +1,392 @@
+import {
+  mappingRowProblem,
+  mentionOf
+} from "./chunk-EDLZGTGN.js";
+import {
+  CONDITION_LOGICS,
+  HUBSPOT_DEAL_CONTACTS,
+  HUBSPOT_OBJECTS,
+  HUBSPOT_PROPERTY_KINDS,
+  REJECTION_MESSAGES,
+  TRIGGER_CONDITIONS_MAX,
+  onlyCondition,
+  triggerProblem,
+  validateEventName
+} from "./chunk-66QHX566.js";
+
+// ../api/src/event-sources/hubspot.ts
+var HUBSPOT_CONTACT_ID_VARIABLE = "id";
+var HUBSPOT_CONTACT_PREFIX = "contact.";
+function contactPath(property) {
+  return `${HUBSPOT_CONTACT_PREFIX}${property}`;
+}
+var HUBSPOT_DEFAULT_PROPERTIES = {
+  email: "email",
+  phone: "phone",
+  external_id: HUBSPOT_CONTACT_ID_VARIABLE,
+  first_name: "firstname",
+  last_name: "lastname",
+  city: "city",
+  postal_code: "zip",
+  country: "country",
+  gclid: "hs_google_click_id",
+  fbclid: "hs_facebook_click_id"
+};
+var throughContact = Object.fromEntries(
+  Object.entries(HUBSPOT_DEFAULT_PROPERTIES).map(([field, property]) => [field, contactPath(property)])
+);
+var HUBSPOT_DEAL_DEFAULT_PROPERTIES = {
+  ...throughContact,
+  value: "amount",
+  currency: "deal_currency_code"
+};
+var HUBSPOT_LEAD_DEFAULT_PROPERTIES = throughContact;
+var DEFAULTS = {
+  contact: HUBSPOT_DEFAULT_PROPERTIES,
+  deal: HUBSPOT_DEAL_DEFAULT_PROPERTIES,
+  lead: HUBSPOT_LEAD_DEFAULT_PROPERTIES
+};
+function hubspotDefaultMapping(sourceName, object = "contact") {
+  const mapping = { event_name: sourceName };
+  for (const [field, property] of Object.entries(DEFAULTS[object])) {
+    mapping[field] = mentionOf(property);
+  }
+  return mapping;
+}
+
+// ../api/src/event-sources/wire.ts
+import { z as z2 } from "zod";
+
+// ../api/src/event-sources/activecampaign.ts
+import { z } from "zod";
+var ACTIVECAMPAIGN_WEBHOOK_EVENTS = {
+  subscribe: "A contact subscribes to a list",
+  unsubscribe: "A contact unsubscribes",
+  update: "A contact's details change",
+  contact_tag_added: "A tag is added to a contact",
+  contact_tag_removed: "A tag is removed from a contact",
+  subscriber_note: "A note is added to a contact",
+  contact_task_add: "A task is added to a contact",
+  sent: "A campaign starts sending",
+  open: "A contact opens a campaign",
+  click: "A contact clicks a link in a campaign",
+  reply: "A contact replies to a campaign",
+  forward: "A contact forwards a campaign",
+  share: "A contact shares a campaign",
+  bounce: "A campaign email bounces",
+  list_add: "A list is created",
+  deal_add: "A deal is created",
+  deal_update: "A deal changes",
+  deal_note_add: "A note is added to a deal",
+  deal_task_add: "A task is added to a deal",
+  deal_task_complete: "A deal task is completed",
+  deal_pipeline_add: "A pipeline is created",
+  deal_stage_add: "A deal stage is created",
+  deal_tasktype_add: "A deal task type is created",
+  account_add: "An account is created",
+  account_update: "An account changes",
+  account_contact_add: "A contact is added to an account",
+  account_contact_update: "A contact on an account changes"
+};
+var ACTIVECAMPAIGN_WEBHOOK_EVENT_TYPES = Object.keys(
+  ACTIVECAMPAIGN_WEBHOOK_EVENTS
+);
+var EVENT_PREFIX = "activecampaign.";
+function activeCampaignEventOf(eventName) {
+  if (!eventName.startsWith(EVENT_PREFIX)) return null;
+  const type = eventName.slice(EVENT_PREFIX.length);
+  return type in ACTIVECAMPAIGN_WEBHOOK_EVENTS ? type : null;
+}
+var activeCampaignEventsSchema = z.array(z.string().trim().min(1)).min(1, "Pick at least one ActiveCampaign event to listen to.").max(ACTIVECAMPAIGN_WEBHOOK_EVENT_TYPES.length).transform((raw, ctx) => {
+  const picked = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const type = activeCampaignEventOf(item) ?? (item in ACTIVECAMPAIGN_WEBHOOK_EVENTS ? item : null);
+    if (type === null) {
+      ctx.addIssue({
+        code: "custom",
+        message: `"${item}" is not an ActiveCampaign event. Pick from: ${ACTIVECAMPAIGN_WEBHOOK_EVENT_TYPES.join(", ")}.`
+      });
+      return z.NEVER;
+    }
+    picked.add(type);
+  }
+  return ACTIVECAMPAIGN_WEBHOOK_EVENT_TYPES.filter((type) => picked.has(type));
+});
+var ACTIVECAMPAIGN_WEBHOOK_STATES = ["listening", "not_configured", "failed"];
+
+// ../api/src/event-sources/wire.ts
+var SOURCE_KINDS = ["webhook", "hubspot", "activecampaign"];
+var SOURCE_STATUSES = ["learning", "counting", "paused"];
+var SOURCE_NAME_MAX = 80;
+var sourceNameSchema = z2.string().trim().min(1).max(SOURCE_NAME_MAX).refine((name) => validateEventName(name) === null, REJECTION_MESSAGES.invalid_name);
+var sourceIdSchema = z2.string().min(1);
+var sourceMappingSchema = z2.record(z2.string(), z2.string().min(1)).superRefine((mapping, ctx) => {
+  for (const row of Object.keys(mapping)) {
+    const problem = mappingRowProblem(row);
+    if (problem !== null) ctx.addIssue({ code: "custom", message: problem, path: [row] });
+  }
+});
+var currencyCodeSchema = z2.string().trim().toUpperCase().regex(/^[A-Z]{3}$/, "A currency is a three-letter code, like EUR or USD.");
+var hubspotObjectSchema = z2.enum(HUBSPOT_OBJECTS);
+var hubspotDealContactsSchema = z2.enum(HUBSPOT_DEAL_CONTACTS);
+var hubspotConditionInputSchema = z2.strictObject({
+  property: z2.string().trim().min(1),
+  /** One of the property's kind's operators (`baker hubspot contacts properties` lists them); `is` when unsaid. */
+  operator: z2.string().trim().min(1).default("is"),
+  /** As HubSpot spells them: an option's internal value, a number, a `YYYY-MM-DD`, `true`/`false`. None for an empty check, two for a between, several for a list. */
+  values: z2.array(z2.string().trim().min(1)).max(50).default([])
+});
+var conditionLogicSchema = z2.enum(CONDITION_LOGICS);
+var conditionGroupInputSchema = z2.strictObject({
+  logic: conditionLogicSchema,
+  conditions: z2.array(hubspotConditionInputSchema).min(1).max(TRIGGER_CONDITIONS_MAX)
+});
+var combinedInputSchema = z2.strictObject({
+  /** How the rows combine: `And` (every one) or `Or` (any one) — a Form's filter's "Match AND / OR". */
+  logic: conditionLogicSchema.default("And"),
+  /** Conditions, and groups of conditions with their own logic, one level deep. */
+  conditions: z2.array(z2.union([hubspotConditionInputSchema, conditionGroupInputSchema])).min(1).max(TRIGGER_CONDITIONS_MAX)
+}).superRefine((trigger, context) => {
+  const problem = triggerProblem(trigger);
+  if (problem !== null) context.addIssue({ code: "custom", message: problem });
+});
+var hubspotTriggerInputSchema = z2.union([combinedInputSchema, hubspotConditionInputSchema]).transform((input) => "conditions" in input ? input : onlyCondition(input));
+var hubspotConditionSchema = hubspotConditionInputSchema.extend({
+  propertyLabel: z2.string(),
+  kind: z2.enum(HUBSPOT_PROPERTY_KINDS),
+  /** A select that holds several values at once (`a;b`); decides what HubSpot may filter on. */
+  multiple: z2.boolean().optional(),
+  valueLabels: z2.array(z2.string())
+});
+var hubspotTriggerFields = {
+  logic: conditionLogicSchema,
+  conditions: z2.array(
+    z2.union([
+      hubspotConditionSchema,
+      z2.strictObject({ logic: conditionLogicSchema, conditions: z2.array(hubspotConditionSchema) })
+    ])
+  )
+};
+var hubspotWatchSchema = z2.strictObject({
+  ...hubspotTriggerFields,
+  object: hubspotObjectSchema,
+  contacts: hubspotDealContactsSchema.optional()
+});
+var sampleRecordSchema = z2.strictObject({ id: z2.string(), properties: z2.record(z2.string(), z2.string()) });
+var hubspotPreviewRequestSchema = z2.strictObject({
+  object: hubspotObjectSchema.default("contact"),
+  trigger: hubspotTriggerInputSchema,
+  /** Property names to read off the sample; `id` is always there. On a deal or a lead, `contact.<name>` reads its first contact. */
+  properties: z2.array(z2.string().trim().min(1)).max(60).optional(),
+  /** The record to draw the preview from — an id, or text to search (an email or a name for a contact, a deal's or a lead's name). The one most recently at the trigger when unsaid. */
+  contact: z2.string().trim().min(1).max(200).optional()
+});
+var hubspotPreviewSchema = z2.strictObject({
+  /** Records satisfying the trigger today — the ones that will NOT be counted. */
+  total: z2.number(),
+  /** False when the trigger has more combinations than HubSpot's search takes, so `total` is only near. */
+  exact: z2.boolean().optional(),
+  /**
+   * The sample record the trigger is on, with the properties asked for and
+   * the contacts behind it, first first; none when nothing fits.
+   *
+   * One field rather than one per object: a contact source's record *is* the
+   * person and its `contacts` is empty, while a deal's and a lead's carry the
+   * people the event is about. Three parallel nullable fields, exactly one of
+   * them ever set, would say the same thing and let a caller read the wrong one.
+   */
+  record: sampleRecordSchema.extend({ contacts: z2.array(sampleRecordSchema) }).nullable()
+});
+var sourcesRequestSchema = z2.strictObject({
+  /** The company's own server door: made once, `counting` from the start, the same address for ever after. */
+  server: z2.strictObject({}).optional(),
+  create: z2.strictObject({ name: sourceNameSchema }).optional(),
+  /** A HubSpot event: read every five minutes, counting from now. The labels are looked up server-side. */
+  createHubspot: z2.strictObject({
+    name: sourceNameSchema.optional(),
+    /** A contact, a deal or a lead. A deal's and a lead's event is about its contact, read through `contact.<property>` rows. */
+    object: hubspotObjectSchema.default("contact"),
+    trigger: hubspotTriggerInputSchema,
+    /** On a deal: the deal's first contact (the default), or every contact on it, each its own event. */
+    contacts: hubspotDealContactsSchema.optional(),
+    /** Rows to read off the record, over the defaults; the same table `map` writes. */
+    mapping: sourceMappingSchema.optional(),
+    /** A number property on the record to read as the amount; needs `currency` beside it. Sugar over the mapping's `value` and `currency` rows. */
+    amountProperty: z2.string().trim().min(1).optional(),
+    currency: currencyCodeSchema.optional()
+  }).optional(),
+  /**
+   * An ActiveCampaign source: ActiveCampaign's own webhook, made on the
+   * account when this is applied, sending the events picked here. Each raises
+   * `activecampaign.<type>` and counts from then on.
+   */
+  createActiveCampaign: z2.strictObject({
+    name: sourceNameSchema.optional(),
+    /** ActiveCampaign's event names (`subscribe`, `deal_update`, …); the lead and deal moments when unsaid. */
+    events: activeCampaignEventsSchema.optional(),
+    /** Which connection, when the company has more than one. */
+    account: z2.string().trim().min(1).optional()
+  }).optional(),
+  /** Change what a HubSpot event watches. It counts from now on under the new trigger; the rows stay. The object cannot change: the rows read it. */
+  setTrigger: z2.strictObject({
+    sourceId: sourceIdSchema,
+    trigger: hubspotTriggerInputSchema,
+    contacts: hubspotDealContactsSchema.optional()
+  }).optional(),
+  /** Ask HubSpot what a trigger would count today, and read one real record, without making anything. */
+  preview: hubspotPreviewRequestSchema.optional(),
+  /** Change where a HubSpot-read source takes its amount from; no `amountProperty` clears it. Sugar over `map`. */
+  setAmount: z2.strictObject({
+    sourceId: sourceIdSchema,
+    amountProperty: z2.string().trim().min(1).optional(),
+    currency: currencyCodeSchema.optional()
+  }).optional(),
+  /**
+   * Count a HubSpot event's history: every moment its trigger came to hold
+   * since `since`, read out of HubSpot's own property history.
+   *
+   * Not the thing a source deliberately refuses to do. A source never
+   * backfills the **present state** — somebody who already satisfies a
+   * condition is not an event today — and this reports only moments HubSpot
+   * has a timestamp for, so nothing is invented. Dry unless `write`.
+   */
+  backfill: z2.strictObject({
+    sourceId: sourceIdSchema,
+    /** ISO instant, or Unix milliseconds. Bounded by the 400 days the store keeps. */
+    since: z2.union([z2.string().trim().min(1), z2.number()]),
+    /**
+     * Where a capped run carries on from: only records last changed at or
+     * before this instant are read.
+     *
+     * The **read** is what it bounds, never the history. Records are chosen
+     * most-recently-changed first, so a run that reaches its cap has covered
+     * the newest of them and the rest are the ones nearest `since` — which
+     * no shorter window can reach, because shortening one only drops
+     * candidates from the old end and hands back the same newest records
+     * again. `reachedBack` is the value to pass here, and the moments each
+     * record is then judged on are still the whole of `since` to now.
+     */
+    before: z2.union([z2.string().trim().min(1), z2.number()]).optional(),
+    /** Without it, nothing is counted and the answer says what would be. */
+    write: z2.boolean().optional()
+  }).optional(),
+  map: z2.strictObject({ sourceId: sourceIdSchema, mapping: sourceMappingSchema }).optional(),
+  pause: z2.strictObject({ sourceId: sourceIdSchema }).optional(),
+  resume: z2.strictObject({ sourceId: sourceIdSchema }).optional(),
+  remove: z2.strictObject({ sourceId: sourceIdSchema }).optional()
+});
+var sourceRefusalSchema = z2.strictObject({
+  at: z2.number(),
+  count: z2.number(),
+  code: z2.string(),
+  reason: z2.string()
+});
+var detectedFieldSchema = z2.strictObject({
+  path: z2.string(),
+  confidence: z2.enum(["key", "value"])
+});
+var HUBSPOT_LISTENING_STATES = ["listening", "not_configured", "failed"];
+var sourceViewSchema = z2.strictObject({
+  id: z2.string(),
+  kind: z2.enum(SOURCE_KINDS),
+  name: z2.string(),
+  status: z2.enum(SOURCE_STATUSES),
+  /** The address a tool posts to. A HubSpot source has none: Baker calls HubSpot. */
+  url: z2.string().optional(),
+  /** What a HubSpot source watches, and on which object. */
+  hubspot: hubspotWatchSchema.optional(),
+  /**
+   * What an ActiveCampaign source listens to, and whether ActiveCampaign has
+   * the webhook that sends it: `listening` once it is made, `not_configured`
+   * until then, `failed` when ActiveCampaign refused it — `detail` says why.
+   */
+  activecampaign: z2.strictObject({
+    events: z2.array(z2.string()),
+    webhook: z2.strictObject({ state: z2.enum(ACTIVECAMPAIGN_WEBHOOK_STATES), detail: z2.string().optional() })
+  }).optional(),
+  /** A HubSpot source counts changes from here on; one HubSpot reports from before it is dropped. Moves when the trigger changes. */
+  countingSince: z2.number().optional(),
+  /**
+   * Whether HubSpot is keeping this source's changes for Baker, as last
+   * checked: `listening` when the app's journal subscription on the account
+   * names the property; `not_configured` when the app has not been told yet
+   * (or cannot be, with no credentials); `failed` when HubSpot refused the
+   * subscription. `detail` says what to do.
+   */
+  listening: z2.strictObject({ state: z2.enum(HUBSPOT_LISTENING_STATES), detail: z2.string().optional() }).optional(),
+  /** Why the last delivery could not be counted, in product words; absent when the last one was. */
+  lastError: z2.string().optional(),
+  lastArrivalAt: z2.number().optional(),
+  /**
+   * What its last delivery **refused, event by event** — which `lastError` is
+   * not and `lastArrivalAt` cannot be. A source refusing everything it
+   * receives has no arrival and no read failure, so without this it reads as
+   * one nobody has sent anything to. `refusalWords` turns it into the
+   * sentence a person is shown. Cleared by the next delivery that counts.
+   */
+  lastRefusal: sourceRefusalSchema.optional(),
+  /** The first send, masked, while learning. Kept once confirmed. */
+  sample: z2.strictObject({ receivedAt: z2.number(), body: z2.string() }).optional(),
+  /** Field → template; empty means the guess (an address) or the defaults (a HubSpot read). */
+  mapping: z2.record(z2.string(), z2.string()),
+  /** The guess over the sample, for the sheet to prefill and the CLI to suggest. */
+  detected: z2.record(z2.string(), detectedFieldSchema).optional(),
+  /** Every path the sample's first item holds, with its masked value — what the picker offers. */
+  paths: z2.array(z2.strictObject({ path: z2.string(), value: z2.string() })).optional(),
+  /** `baker` when the sample already parses as the `POST /v1/events` contract and needs no mapping. */
+  format: z2.enum(["baker", "foreign"]).optional()
+});
+var stagedSourceOpSchema = z2.strictObject({
+  kind: z2.enum(["create", "setTrigger", "map", "status", "remove"]),
+  ref: z2.string(),
+  name: z2.string(),
+  summary: z2.string(),
+  /** On a create: what the source will watch and read. */
+  hubspot: hubspotWatchSchema.optional(),
+  /** On an ActiveCampaign create: the events its webhook will send. */
+  activecampaign: z2.strictObject({ events: z2.array(z2.string()) }).optional(),
+  mapping: z2.record(z2.string(), z2.string()).optional(),
+  status: z2.enum(["paused", "counting"]).optional()
+});
+var backfillResultSchema = z2.strictObject({
+  sourceId: z2.string(),
+  name: z2.string(),
+  since: z2.number(),
+  /** Records whose history was read. */
+  examined: z2.number(),
+  /** Moments the trigger came to hold, across them. */
+  entries: z2.number(),
+  /** Of those, already counted — the journal got there first, or a previous run did. */
+  alreadyCounted: z2.number(),
+  /** What a `write` run would hand over, or did. */
+  pending: z2.number(),
+  /** Whether the read stopped at its cap; {@link BackfillResult.reachedBack} is where to carry on from. */
+  capped: z2.boolean(),
+  /**
+   * How far back the read got: the instant the oldest record it examined was
+   * last changed. Only on a capped run, and it is the next run's `before`.
+   */
+  reachedBack: z2.number().optional(),
+  counted: z2.number().optional(),
+  refused: z2.number().optional(),
+  refusedReason: z2.string().optional()
+});
+var sourcesResponseSchema = z2.strictObject({
+  ok: z2.literal(true),
+  data: z2.strictObject({
+    sources: z2.array(sourceViewSchema),
+    /** Only when the request carried `preview`. */
+    preview: hubspotPreviewSchema.optional(),
+    /** Only when the request carried `backfill`. */
+    backfill: backfillResultSchema.optional(),
+    /** What this chat has staged, when one is attached: applied at Publish, dropped with a discard. */
+    staged: z2.array(stagedSourceOpSchema).optional()
+  }),
+  hints: z2.array(z2.string()).optional()
+});
+
+export {
+  hubspotDefaultMapping,
+  hubspotTriggerInputSchema
+};
+//# sourceMappingURL=chunk-FA4YZFRV.js.map