@koda-sl/baker-cli 0.469.0-dev.42f26270e → 0.470.0

package/dist/chunk-MGWBII65.js

@@ -1,333 +0,0 @@
-import {
-  captureProxyCredentials,
-  isChallengeBody,
-  isPrivateAddress,
-  isProxyFailure,
-  nextPlannedRoute,
-  plannedRoutes,
-  refuseNonPublicUrl,
-  shouldEscalate
-} from "./chunk-MSCFMNJP.js";
-
-// ../proxy/src/fetch.ts
-import { lookup as dnsLookup } from "dns";
-import { Agent, ProxyAgent, Response, fetch as undiciFetch } from "undici";
-
-// ../proxy/src/fetchDecision.ts
-function classifyFetchOutcome(signal) {
-  if (isProxyFailure(signal)) return "proxy_unavailable";
-  if (shouldEscalate(signal)) return "blocked";
-  if (signal.status != null && signal.status >= 200 && signal.status < 400 && !signal.challenge) return "ok";
-  return "failed";
-}
-function shouldTryNextRoute(outcome) {
-  return outcome === "blocked" || outcome === "proxy_unavailable";
-}
-var TIMEOUT_CODES = /* @__PURE__ */ new Set([
-  "UND_ERR_CONNECT_TIMEOUT",
-  "UND_ERR_HEADERS_TIMEOUT",
-  "UND_ERR_BODY_TIMEOUT",
-  "ETIMEDOUT"
-]);
-var RESET_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "UND_ERR_SOCKET", "EPIPE"]);
-var PROXY_RESPONSE = /Proxy response \((\d+)\)/;
-function errorCode(error) {
-  if (typeof error !== "object" || error === null) return null;
-  const code = error.code;
-  if (typeof code === "string") return code;
-  const name = error.name;
-  return typeof name === "string" ? name : null;
-}
-function errorMessage(error) {
-  if (typeof error === "object" && error !== null) {
-    const message = error.message;
-    if (typeof message === "string") return message;
-  }
-  return String(error);
-}
-function errorBlockSignal(error, proxied) {
-  const proxyResponse = PROXY_RESPONSE.exec(errorMessage(error));
-  if (proxyResponse) {
-    const status = Number(proxyResponse[1]);
-    return status === 407 ? { status: 407 } : { netError: "ERR_TUNNEL_CONNECTION_FAILED" };
-  }
-  const code = errorCode(error);
-  if (code !== null && TIMEOUT_CODES.has(code)) return { timedOut: true };
-  if (code === "AbortError" || code === "TimeoutError") return { timedOut: true };
-  if (proxied) {
-    return { netError: "ERR_PROXY_CONNECTION_FAILED" };
-  }
-  if (code !== null && RESET_CODES.has(code)) return { netError: "ERR_CONNECTION_RESET" };
-  return { netError: code ?? "ERR_FAILED" };
-}
-function shouldSniffChallenge(contentType, contentLength, maxSniffBytes) {
-  if (contentLength !== null && contentLength > maxSniffBytes) return false;
-  if (contentType === null || contentType.trim() === "") return true;
-  const type = contentType.toLowerCase();
-  if (type.startsWith("image/") || type.startsWith("video/") || type.startsWith("audio/")) return false;
-  return type.includes("text/") || type.includes("html") || type.includes("json") || type.includes("xml");
-}
-
-// ../proxy/src/fetch.ts
-var DEFAULT_TIMEOUT_MS = 6e4;
-var MAX_SNIFF_BYTES = 64 * 1024;
-function tierOf(route) {
-  return route.kind === "proxy" ? route.tier : "direct";
-}
-function agentFor(route) {
-  if (route.kind !== "proxy") return directAgent();
-  const token = Buffer.from(`${route.username}:${route.password}`).toString("base64");
-  return new ProxyAgent({ uri: route.server, token: `Basic ${token}` });
-}
-function directAgent() {
-  return new Agent({
-    connect: {
-      lookup: (hostname, options, callback) => {
-        dnsLookup(hostname, options, (error, address, family) => {
-          if (error) {
-            callback(error, address, family);
-            return;
-          }
-          const found = Array.isArray(address) ? address.map((entry) => entry.address) : [address];
-          const blocked = found.find((entry) => isPrivateAddress(entry));
-          if (blocked !== void 0) {
-            callback(new Error(`${PRIVATE_ADDRESS_CODE}: ${hostname} resolves to ${blocked}`), "", 4);
-            return;
-          }
-          callback(null, address, family);
-        });
-      }
-    }
-  });
-}
-var PRIVATE_ADDRESS_CODE = "EPRIVATEADDR";
-var MAX_REDIRECTS = 20;
-var REDIRECT_STATUS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-function originOf(url) {
-  try {
-    return new URL(url).origin;
-  } catch {
-    return null;
-  }
-}
-function refuseRedirect(entry, to) {
-  if (refuseNonPublicUrl(to) === null) return false;
-  const destination = originOf(to);
-  return destination === null || destination !== originOf(entry);
-}
-async function followRedirects(url, init) {
-  let current = url;
-  let request = { ...init, redirect: "manual" };
-  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
-    const response = await undiciFetch(current, request);
-    const location = response.headers.get("location");
-    if (!REDIRECT_STATUS.has(response.status) || location === null) return response;
-    await response.body?.cancel();
-    const next = new URL(location, current).toString();
-    if (refuseRedirect(url, next)) {
-      throw new Error(`${PRIVATE_ADDRESS_CODE}: redirected to ${next}`);
-    }
-    const method = (request.method ?? "GET").toUpperCase();
-    const downgrade = response.status === 303 || (response.status === 301 || response.status === 302) && method === "POST";
-    request = downgrade ? { ...request, method: "GET", body: void 0 } : request;
-    current = next;
-  }
-  throw new Error(`too many redirects following ${url}`);
-}
-var NULL_BODY_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
-function rebuild(response, body) {
-  if (response.status < 200 || response.status > 599 || NULL_BODY_STATUS.has(response.status)) {
-    return new Response(null, { status: response.status, headers: response.headers });
-  }
-  return new Response(body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-function declaredLength(response) {
-  const raw = response.headers.get("content-length");
-  if (raw === null) return null;
-  const value = Number(raw);
-  return Number.isFinite(value) ? value : null;
-}
-async function readOnce(response, sniff, maxBytes) {
-  const declared = declaredLength(response);
-  if (maxBytes !== void 0 && declared !== null && declared > maxBytes) {
-    await response.body?.cancel();
-    return { response: rebuild(response, new ArrayBuffer(0)), challenge: false };
-  }
-  const body = await response.arrayBuffer();
-  const wantsSniff = sniff && shouldSniffChallenge(response.headers.get("content-type"), body.byteLength, MAX_SNIFF_BYTES);
-  const challenge = wantsSniff ? isChallengeBody(new TextDecoder().decode(body)) : false;
-  return { response: rebuild(response, body), challenge };
-}
-async function attemptRoute(url, init, route, options) {
-  const tier = tierOf(route);
-  const agent = agentFor(route);
-  const startedAt = Date.now();
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const signal = init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
-  try {
-    const raw = await followRedirects(url, { ...init, dispatcher: agent ?? void 0, signal });
-    const read = await readOnce(raw, options.sniffChallenge ?? true, options.maxBytes);
-    const outcome = classifyFetchOutcome({ status: raw.status, challenge: read.challenge });
-    return {
-      attempt: { tier, status: raw.status, ms: Date.now() - startedAt, outcome },
-      response: outcome === "proxy_unavailable" ? null : read.response
-    };
-  } catch (error) {
-    const blockSignal = errorBlockSignal(error, route.kind === "proxy");
-    return {
-      attempt: {
-        tier,
-        status: blockSignal.status ?? void 0,
-        ms: Date.now() - startedAt,
-        outcome: classifyFetchOutcome(blockSignal)
-      },
-      response: null,
-      error
-    };
-  } finally {
-    await agent?.close();
-  }
-}
-async function fetchWithEscalation(url, init, options) {
-  const attempts = [];
-  let originResponse = null;
-  let originTier = "direct";
-  let lastError;
-  const routes = plannedRoutes(url, options.credentials, options.routeOptions);
-  const tried = [];
-  for (let route = routes[0] ?? null; route !== null; route = nextPlannedRoute(routes, tried)) {
-    const rung = await attemptRoute(url, init, route, options);
-    attempts.push(rung.attempt);
-    tried.push({ tier: rung.attempt.tier, proxyFailure: rung.attempt.outcome === "proxy_unavailable" });
-    if (rung.response !== null) {
-      originResponse = rung.response;
-      originTier = rung.attempt.tier;
-    }
-    if (rung.error !== void 0) lastError = rung.error;
-    if (!shouldTryNextRoute(rung.attempt.outcome)) break;
-  }
-  return {
-    response: originResponse,
-    attempts,
-    finalTier: originResponse !== null ? originTier : lastAttempt(attempts)?.tier ?? "direct",
-    ...originResponse === null && lastError !== void 0 ? { error: lastError } : {}
-  };
-}
-function lastAttempt(attempts) {
-  return attempts[attempts.length - 1];
-}
-function describeLadder(result) {
-  const rungs = result.attempts.map((a) => `${a.tier}:${a.outcome}${a.status ? `(${a.status})` : ""}@${a.ms}ms`);
-  return `${rungs.join(" \u2192 ")} | final=${result.finalTier}`;
-}
-function rescued(result) {
-  return result.attempts.some((attempt) => attempt.outcome === "ok");
-}
-function endedBlocked(result) {
-  if (rescued(result)) return false;
-  return result.attempts.some((attempt) => attempt.outcome === "blocked");
-}
-function endedProxyUnavailable(result) {
-  if (rescued(result) || endedBlocked(result)) return false;
-  return result.attempts.some((attempt) => attempt.outcome === "proxy_unavailable");
-}
-function endedPrivateAddress(result) {
-  if (rescued(result)) return false;
-  for (let error = result.error, depth = 0; error instanceof Error && depth < 5; depth++) {
-    if (error.message.includes(PRIVATE_ADDRESS_CODE)) return true;
-    error = error.cause;
-  }
-  return false;
-}
-
-// src/lib/externalFetch.ts
-var BROWSER_HEADERS = {
-  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
-  Accept: "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
-  "Accept-Language": "en-US,en;q=0.9"
-};
-var NOT_PUBLIC_MESSAGE = "That address is not reachable from the public web, so there is nothing to read.";
-var MAX_REMOTE_IMAGE_BYTES = 25e6;
-var ExternalFetchError = class extends Error {
-  /** True when the fault was ours — a route we could not open, not a dead host. */
-  ourFault;
-  constructor(message, ourFault) {
-    super(message);
-    this.name = "ExternalFetchError";
-    this.ourFault = ourFault;
-  }
-};
-async function fetchExternal(url, options = {}) {
-  if (refuseNonPublicUrl(url) !== null) {
-    throw new ExternalFetchError(NOT_PUBLIC_MESSAGE, false);
-  }
-  const result = await fetchWithEscalation(
-    url,
-    { headers: { ...BROWSER_HEADERS, ...options.headers } },
-    {
-      credentials: captureProxyCredentials(),
-      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
-      ...options.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes },
-      ...options.sniffChallenge === void 0 ? {} : { sniffChallenge: options.sniffChallenge }
-    }
-  );
-  if (result.attempts.length > 1) {
-    process.stderr.write(`fetch ladder ${url} \u2014 ${describeLadder(result)}
-`);
-  }
-  if (result.response === null) {
-    if (endedPrivateAddress(result)) {
-      throw new ExternalFetchError(NOT_PUBLIC_MESSAGE, false);
-    }
-    const ourFault = endedProxyUnavailable(result);
-    throw new ExternalFetchError(
-      ourFault ? "Could not open a route to that address." : "That address did not answer.",
-      ourFault
-    );
-  }
-  return { response: result.response, blocked: endedBlocked(result) };
-}
-function refuseOversize(bytes, maxBytes) {
-  if (bytes === null || bytes <= maxBytes) return null;
-  return `That file is ${humanBytes(bytes)} \u2014 the limit is ${humanBytes(maxBytes)}.`;
-}
-function humanBytes(n) {
-  if (n >= 1024 ** 3) return `${(n / 1024 ** 3).toFixed(1)} GB`;
-  if (n >= 1024 ** 2) return `${(n / 1024 ** 2).toFixed(1)} MB`;
-  return `${Math.max(1, Math.round(n / 1024))} KB`;
-}
-function declaredBytes(response) {
-  const raw = response.headers.get("content-length");
-  if (raw === null) return null;
-  const value = Number(raw);
-  return Number.isFinite(value) ? value : null;
-}
-async function fetchExternalBytes(url, options) {
-  const { response, blocked } = await fetchExternal(url, options);
-  if (!response.ok) {
-    throw new ExternalFetchError(`${response.status} ${response.statusText}`, false);
-  }
-  if (blocked) {
-    throw new ExternalFetchError("That host served a security check instead of the file.", false);
-  }
-  const declared = refuseOversize(declaredBytes(response), options.maxBytes);
-  if (declared !== null) {
-    throw new ExternalFetchError(declared, false);
-  }
-  const buffer = Buffer.from(await response.arrayBuffer());
-  const actual = refuseOversize(buffer.byteLength, options.maxBytes);
-  if (actual !== null) {
-    throw new ExternalFetchError(actual, false);
-  }
-  return { buffer, contentType: response.headers.get("content-type") };
-}
-
-export {
-  MAX_REMOTE_IMAGE_BYTES,
-  fetchExternalBytes
-};
-//# sourceMappingURL=chunk-MGWBII65.js.map

package/dist/chunk-MH74GWNI.js

@@ -1,310 +0,0 @@
-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-RPJYEJDQ.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 } from "zod";
-var SOURCE_KINDS = ["webhook", "hubspot"];
-var SOURCE_STATUSES = ["learning", "counting", "paused"];
-var SOURCE_NAME_MAX = 80;
-var sourceNameSchema = z.string().trim().min(1).max(SOURCE_NAME_MAX).refine((name) => validateEventName(name) === null, REJECTION_MESSAGES.invalid_name);
-var sourceIdSchema = z.string().min(1);
-var sourceMappingSchema = z.record(z.string(), z.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 = z.string().trim().toUpperCase().regex(/^[A-Z]{3}$/, "A currency is a three-letter code, like EUR or USD.");
-var hubspotObjectSchema = z.enum(HUBSPOT_OBJECTS);
-var hubspotDealContactsSchema = z.enum(HUBSPOT_DEAL_CONTACTS);
-var hubspotConditionInputSchema = z.strictObject({
-  property: z.string().trim().min(1),
-  /** One of the property's kind's operators (`baker hubspot contacts properties` lists them); `is` when unsaid. */
-  operator: z.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: z.array(z.string().trim().min(1)).max(50).default([])
-});
-var conditionLogicSchema = z.enum(CONDITION_LOGICS);
-var conditionGroupInputSchema = z.strictObject({
-  logic: conditionLogicSchema,
-  conditions: z.array(hubspotConditionInputSchema).min(1).max(TRIGGER_CONDITIONS_MAX)
-});
-var combinedInputSchema = z.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: z.array(z.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 = z.union([combinedInputSchema, hubspotConditionInputSchema]).transform((input) => "conditions" in input ? input : onlyCondition(input));
-var hubspotConditionSchema = hubspotConditionInputSchema.extend({
-  propertyLabel: z.string(),
-  kind: z.enum(HUBSPOT_PROPERTY_KINDS),
-  /** A select that holds several values at once (`a;b`); decides what HubSpot may filter on. */
-  multiple: z.boolean().optional(),
-  valueLabels: z.array(z.string())
-});
-var hubspotTriggerFields = {
-  logic: conditionLogicSchema,
-  conditions: z.array(
-    z.union([
-      hubspotConditionSchema,
-      z.strictObject({ logic: conditionLogicSchema, conditions: z.array(hubspotConditionSchema) })
-    ])
-  )
-};
-var hubspotWatchSchema = z.strictObject({
-  ...hubspotTriggerFields,
-  object: hubspotObjectSchema,
-  contacts: hubspotDealContactsSchema.optional()
-});
-var sampleRecordSchema = z.strictObject({ id: z.string(), properties: z.record(z.string(), z.string()) });
-var hubspotPreviewRequestSchema = z.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: z.array(z.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: z.string().trim().min(1).max(200).optional()
-});
-var hubspotPreviewSchema = z.strictObject({
-  /** Records satisfying the trigger today — the ones that will NOT be counted. */
-  total: z.number(),
-  /** False when the trigger has more combinations than HubSpot's search takes, so `total` is only near. */
-  exact: z.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: z.array(sampleRecordSchema) }).nullable()
-});
-var sourcesRequestSchema = z.strictObject({
-  /** The company's own server door: made once, `counting` from the start, the same address for ever after. */
-  server: z.strictObject({}).optional(),
-  create: z.strictObject({ name: sourceNameSchema }).optional(),
-  /** A HubSpot event: read every five minutes, counting from now. The labels are looked up server-side. */
-  createHubspot: z.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: z.string().trim().min(1).optional(),
-    currency: currencyCodeSchema.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: z.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: z.strictObject({
-    sourceId: sourceIdSchema,
-    amountProperty: z.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: z.strictObject({
-    sourceId: sourceIdSchema,
-    /** ISO instant, or Unix milliseconds. Bounded by the 400 days the store keeps. */
-    since: z.union([z.string().trim().min(1), z.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: z.union([z.string().trim().min(1), z.number()]).optional(),
-    /** Without it, nothing is counted and the answer says what would be. */
-    write: z.boolean().optional()
-  }).optional(),
-  map: z.strictObject({ sourceId: sourceIdSchema, mapping: sourceMappingSchema }).optional(),
-  pause: z.strictObject({ sourceId: sourceIdSchema }).optional(),
-  resume: z.strictObject({ sourceId: sourceIdSchema }).optional(),
-  remove: z.strictObject({ sourceId: sourceIdSchema }).optional()
-});
-var sourceRefusalSchema = z.strictObject({
-  at: z.number(),
-  count: z.number(),
-  code: z.string(),
-  reason: z.string()
-});
-var detectedFieldSchema = z.strictObject({
-  path: z.string(),
-  confidence: z.enum(["key", "value"])
-});
-var HUBSPOT_LISTENING_STATES = ["listening", "not_configured", "failed"];
-var sourceViewSchema = z.strictObject({
-  id: z.string(),
-  kind: z.enum(SOURCE_KINDS),
-  name: z.string(),
-  status: z.enum(SOURCE_STATUSES),
-  /** The address a tool posts to. A HubSpot source has none: Baker calls HubSpot. */
-  url: z.string().optional(),
-  /** What a HubSpot source watches, and on which object. */
-  hubspot: hubspotWatchSchema.optional(),
-  /** A HubSpot source counts changes from here on; one HubSpot reports from before it is dropped. Moves when the trigger changes. */
-  countingSince: z.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: z.strictObject({ state: z.enum(HUBSPOT_LISTENING_STATES), detail: z.string().optional() }).optional(),
-  /** Why the last delivery could not be counted, in product words; absent when the last one was. */
-  lastError: z.string().optional(),
-  lastArrivalAt: z.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: z.strictObject({ receivedAt: z.number(), body: z.string() }).optional(),
-  /** Field → template; empty means the guess (an address) or the defaults (a HubSpot read). */
-  mapping: z.record(z.string(), z.string()),
-  /** The guess over the sample, for the sheet to prefill and the CLI to suggest. */
-  detected: z.record(z.string(), detectedFieldSchema).optional(),
-  /** Every path the sample's first item holds, with its masked value — what the picker offers. */
-  paths: z.array(z.strictObject({ path: z.string(), value: z.string() })).optional(),
-  /** `baker` when the sample already parses as the `POST /v1/events` contract and needs no mapping. */
-  format: z.enum(["baker", "foreign"]).optional()
-});
-var stagedSourceOpSchema = z.strictObject({
-  kind: z.enum(["create", "setTrigger", "map", "status", "remove"]),
-  ref: z.string(),
-  name: z.string(),
-  summary: z.string(),
-  /** On a create: what the source will watch and read. */
-  hubspot: hubspotWatchSchema.optional(),
-  mapping: z.record(z.string(), z.string()).optional(),
-  status: z.enum(["paused", "counting"]).optional()
-});
-var backfillResultSchema = z.strictObject({
-  sourceId: z.string(),
-  name: z.string(),
-  since: z.number(),
-  /** Records whose history was read. */
-  examined: z.number(),
-  /** Moments the trigger came to hold, across them. */
-  entries: z.number(),
-  /** Of those, already counted — the journal got there first, or a previous run did. */
-  alreadyCounted: z.number(),
-  /** What a `write` run would hand over, or did. */
-  pending: z.number(),
-  /** Whether the read stopped at its cap; {@link BackfillResult.reachedBack} is where to carry on from. */
-  capped: z.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: z.number().optional(),
-  counted: z.number().optional(),
-  refused: z.number().optional(),
-  refusedReason: z.string().optional()
-});
-var sourcesResponseSchema = z.strictObject({
-  ok: z.literal(true),
-  data: z.strictObject({
-    sources: z.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: z.array(stagedSourceOpSchema).optional()
-  }),
-  hints: z.array(z.string()).optional()
-});
-
-export {
-  hubspotDefaultMapping,
-  hubspotTriggerInputSchema
-};
-//# sourceMappingURL=chunk-MH74GWNI.js.map