@koda-sl/baker-cli 0.503.0 → 0.505.0-dev.eb0521917

package/dist/rules-add-P7GNB6P7.js

@@ -0,0 +1,463 @@
+import {
+  rulesView
+} from "./chunk-QVQKCVP7.js";
+import {
+  fetchRunRecord
+} from "./chunk-HI5Y3S45.js";
+import {
+  loadCandidate
+} from "./chunk-SKNQRX56.js";
+import {
+  readAllRules
+} from "./chunk-F4SEK6U4.js";
+import {
+  RULES_DIR,
+  RULE_APPLIES,
+  RULE_KINDS,
+  RULE_STRENGTHS,
+  parseRuleFile
+} from "./chunk-MKUA54QE.js";
+import "./chunk-6ZFSDYWV.js";
+import {
+  holdWorkspaceSpend
+} from "./chunk-E44NXCTL.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-EJGAJHLB.js";
+import {
+  reviewAgainstRules
+} from "./chunk-AVYUFJQQ.js";
+import {
+  reviewedRules
+} from "./chunk-FJZYOVSW.js";
+import "./chunk-F3CZFUXZ.js";
+import {
+  askJev
+} from "./chunk-LNNTHEL7.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-OR7PFL2W.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-HNNCAJNF.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/rules-add.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+import sharp from "sharp";
+
+// src/engine/creative-rules/admission.ts
+async function breaks(rule, version, review) {
+  const found = await review(version, [rule]).catch(() => null);
+  return found === null ? null : found.filter((f) => f.kind?.rule === rule.id && f.severity === "blocking");
+}
+async function admissionTest(rule, origin, approved, review) {
+  const untested = { origin: "untested", approved: { checked: 0, blocked: [] } };
+  const tested = { ...rule, strength: rule.strength === "prefer" ? "must" : rule.strength };
+  if (reviewedRules([tested]).length === 0) return untested;
+  const own = origin ? await breaks(tested, origin, review) : null;
+  const results = await Promise.all(
+    approved.map(async (v) => ({ runId: v.runId, found: await breaks(tested, v, review) }))
+  );
+  const looked = results.filter((r) => r.found !== null);
+  return {
+    origin: own === null ? "untested" : own.length > 0 ? "caught" : "missed",
+    approved: {
+      checked: looked.length,
+      blocked: looked.flatMap(
+        (r) => r.found?.[0] ? [{ runId: r.runId, what: r.found[0].what.replace(/^.*?\): /, "") }] : []
+      )
+    }
+  };
+}
+function admissionRefusal(rule, admission) {
+  if (admission.origin === "missed") {
+    return {
+      code: "RULE_MISSES_ITS_AD",
+      message: `Not saved: "${rule.text}" does not catch the version it came from (${rule.source.runId ?? "the rejected one"}), so it is worded for something else.`,
+      fix: "Reword it to name exactly what was wrong on that version, in the person's words, and add it again; or ask the person what the rule is."
+    };
+  }
+  const blocked = admission.approved.blocked;
+  if (blocked.length > 0) {
+    return {
+      code: "RULE_BLOCKS_APPROVED",
+      message: `Not saved: "${rule.text}" would block ${blocked.length} version${blocked.length === 1 ? "" : "s"} the person approved: ${blocked.map((b) => `${b.runId} (${b.what})`).join("; ")}.`,
+      fix: "Ask the person whether those approved ads break it. If they do not, reword the rule so it names only what they reject, and add it again."
+    };
+  }
+  return null;
+}
+
+// src/engine/creative-rules/compare.ts
+var SAME = "Do rules `a` and `b` ask the same thing of an ad, in any words or language, so that an ad keeping one keeps the other?";
+var CONFLICT = "Do rules `a` and `b` contradict each other, so that no ad could keep both: following one breaks the other?";
+var SAME_BAND = 0.6;
+var CONFLICT_BAND = 0.6;
+var BATCH = 40;
+function jevPairs(onSpend) {
+  return async (pairs) => {
+    const answers = [];
+    for (let i = 0; i < pairs.length; i += BATCH) {
+      const batch = pairs.slice(i, i + BATCH);
+      const got = await askJev(
+        batch.map((p) => ({ instructions: { a: p.a, b: p.b, question: p.question === "same" ? SAME : CONFLICT } })),
+        onSpend
+      );
+      if (!got) return null;
+      answers.push(...got);
+    }
+    return answers;
+  };
+}
+async function compareRule(candidate, existing, ask) {
+  const active = existing.filter((r) => r.status === "active" && r.id !== candidate.id);
+  if (active.length === 0) return { same: [], conflicts: [], judged: true };
+  const pairs = active.flatMap((r) => [
+    { a: candidate.text, b: r.text, question: "same" },
+    { a: candidate.text, b: r.text, question: "conflict" }
+  ]);
+  const answers = await ask(pairs).catch(() => null);
+  if (!answers || answers.length !== pairs.length) return { same: [], conflicts: [], judged: false };
+  return {
+    same: active.filter((_, i) => (answers[2 * i] ?? 0) >= SAME_BAND),
+    conflicts: active.filter((_, i) => (answers[2 * i + 1] ?? 0) >= CONFLICT_BAND),
+    judged: true
+  };
+}
+
+// src/engine/creative-rules/write.ts
+import { stringify as stringifyYaml } from "yaml";
+function ruleFileText(rule) {
+  const frontmatter = {
+    strength: rule.strength,
+    applies: rule.applies,
+    ...Object.keys(rule.scope).length > 0 ? { scope: rule.scope } : {},
+    ...rule.check && Object.keys(rule.check).length > 0 ? { check: rule.check } : {},
+    source: rule.source,
+    status: rule.status,
+    ...rule.retiredBy ? { retiredBy: rule.retiredBy } : {}
+  };
+  const yaml = stringifyYaml(frontmatter, { defaultStringType: "QUOTE_DOUBLE", defaultKeyType: "PLAIN", lineWidth: 0 });
+  return `---
+${yaml}---
+${rule.text.trim()}
+${rule.why ? `
+Why: ${rule.why.trim()}
+` : ""}`;
+}
+var SLUG_WORDS = 8;
+function ruleSlug(text2, taken) {
+  const base = text2.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).slice(0, SLUG_WORDS).join("-") || "rule";
+  if (!taken.includes(base)) return base;
+  let n = 2;
+  while (taken.includes(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+
+// src/commands/creatives/rules-add.ts
+var oneOf = (values, value) => value && values.includes(value) ? value : void 0;
+var defined = (value) => Object.fromEntries(
+  Object.entries(value).filter(([, v]) => v !== void 0 && !(Array.isArray(v) && v.length === 0))
+);
+function scopeOf(f, c) {
+  return defined({
+    kinds: (f.kinds ?? c?.kinds)?.flatMap((k) => oneOf(RULE_KINDS, k) ?? []),
+    products: f.products,
+    platforms: f.platforms ?? c?.platforms,
+    language: f.language ?? c?.language
+  });
+}
+function checkOf(f, c) {
+  const realPeople = f.people === void 0 ? c?.people === "real" : f.people === "real";
+  return defined({
+    forbid: f.forbid ?? c?.forbid,
+    require: f.require ?? c?.require,
+    allow: f.allow ?? c?.allow,
+    people: realPeople ? "real" : void 0
+  });
+}
+function ruleFromInputs(inputs, at) {
+  const c = inputs.candidate;
+  const f = inputs.flags ?? {};
+  const text2 = (f.text ?? c?.text)?.trim();
+  if (!text2) return { error: "--text: the rule, in the person's words (or --candidate <id> from `feedback record`)." };
+  const check = checkOf(f, c);
+  const source = defined({
+    kind: c ? "feedback" : "user",
+    slug: f.slug ?? c?.source.slug,
+    runId: f.run ?? c?.source.runId,
+    quote: f.quote ?? c?.source.quote,
+    date: at.today
+  });
+  return {
+    id: ruleSlug(f.id ?? text2, at.taken),
+    origin: "learned",
+    strength: oneOf(RULE_STRENGTHS, f.strength) ?? c?.strength ?? "must",
+    applies: oneOf(RULE_APPLIES, f.applies) ?? c?.applies ?? "any",
+    scope: scopeOf(f, c),
+    ...Object.keys(check).length > 0 ? { check } : {},
+    text: text2,
+    ...f.why ? { why: f.why } : {},
+    source,
+    status: "active"
+  };
+}
+async function versionOf(runId) {
+  const record = await fetchRunRecord(runId).catch(() => null);
+  const images = (record?.finalOutputs ?? []).filter((o) => o.kind === "image" && o.url);
+  const stills = await Promise.all(
+    images.map(async (o) => {
+      const response = await fetch(o.url).catch(() => null);
+      if (!response?.ok) return null;
+      const bytes = Buffer.from(await response.arrayBuffer());
+      return (await sharp(bytes).resize({ width: 1024 }).jpeg({ quality: 85 }).toBuffer()).toString("base64");
+    })
+  );
+  const kept = images.flatMap(
+    (o, i) => stills[i] ? [{ still: stills[i], format: o.label ?? "image" }] : []
+  );
+  return kept.length > 0 ? { runId, stills: kept.map((k) => k.still), formats: kept.map((k) => k.format) } : null;
+}
+var APPROVED_VERSIONS = 3;
+async function approvedVersions(except, slug) {
+  const feedback = await apiPost("/api/creatives/feedback", { full: true }).catch(
+    () => null
+  );
+  const approved = (feedback?.data.recent ?? []).filter((e) => e.verdict === "approved" && e.runId !== except);
+  const ordered = [...approved.filter((e) => e.creative !== slug), ...approved.filter((e) => e.creative === slug)];
+  const runIds = [...new Set(ordered.map((e) => e.runId))];
+  const versions = [];
+  for (const runId of runIds) {
+    if (versions.length === APPROVED_VERSIONS) break;
+    const version = await versionOf(runId);
+    if (version) versions.push(version);
+  }
+  return versions;
+}
+async function admit(rule) {
+  const spent = [];
+  const review = (version, rules) => reviewAgainstRules({ ...version, rules, onSpend: (u) => spent.push(u) });
+  const [origin, approved] = await Promise.all([
+    rule.source.runId ? versionOf(rule.source.runId) : Promise.resolve(null),
+    approvedVersions(rule.source.runId, rule.source.slug)
+  ]);
+  const admission = await admissionTest(rule, origin, approved, review);
+  await holdWorkspaceSpend(spent);
+  return admission;
+}
+async function compareHoldingSpend(rule, existing) {
+  const spent = [];
+  try {
+    return await compareRule(
+      rule,
+      existing,
+      jevPairs((u) => spent.push(u))
+    );
+  } finally {
+    await holdWorkspaceSpend(spent);
+  }
+}
+async function retireFile(root, id, by) {
+  const file = path.join(root, RULES_DIR, `${id}.md`);
+  const rule = parseRuleFile(id, await readFile(file, "utf8").catch(() => ""));
+  if (!rule) return null;
+  const retired = { ...rule, status: "retired", ...by ? { retiredBy: by } : {} };
+  await writeFile(file, ruleFileText(retired), "utf8");
+  return retired;
+}
+function fail(code, message, fix, extra = {}) {
+  writeJson({ ok: false, error: { code, message, ...fix ? { fix } : {}, ...extra } });
+  process.exit(1);
+}
+var list = (value) => typeof value === "string" && value.trim() ? value.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+var text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+var ADD_DESCRIPTION = `Save a rule the person agreed to, for every ad from now on: one file in src/content/creative-rules/, published with the Session. Only after they said yes to "make this a rule for every ad?".
+Start here: baker creatives rules add --candidate rc-1a2b3c4d          # a rule \`feedback record\` drafted from their words
+  baker creatives rules add --text "No AI-generated people." --strength never --applies cast --people real --quote "<their words>" --slug <ad> --run <r_\u2026>
+It is refused when the company already has it (DUPLICATE_RULE), when it contradicts one (RULE_CONFLICT: ask which wins, then --replaces <id>), when it does not catch the version it came from (RULE_MISSES_ITS_AD), or would block versions the person approved (RULE_BLOCKS_APPROVED): ask the person, never save it anyway.`;
+var ADD_ARGS = {
+  candidate: {
+    type: "string",
+    description: "A rule `feedback record` drafted (rc-\u2026): the flags below override its parts",
+    required: false
+  },
+  text: {
+    type: "string",
+    description: "The rule, one sentence, in the person's own language and words",
+    required: false
+  },
+  strength: {
+    type: "string",
+    description: `${RULE_STRENGTHS.join(" | ")}: never and must are checked and block; prefer is a note`,
+    required: false
+  },
+  applies: { type: "string", description: `What of the ad it is about: ${RULE_APPLIES.join(", ")}`, required: false },
+  forbid: {
+    type: "string",
+    description: 'Words it bans, comma-separated, only when a word decides it ("online")',
+    required: false
+  },
+  allow: { type: "string", description: 'The right phrase that holds a banned word ("100 % online")', required: false },
+  require: { type: "string", description: "Words every ad must say, comma-separated (rare)", required: false },
+  people: {
+    type: "string",
+    description: "real: only real people appear (a real person's Avatar, a customer, footage or nobody)",
+    required: false
+  },
+  kinds: { type: "string", description: "static,video: only ads of these kinds", required: false },
+  products: { type: "string", description: "Product slugs (a business unit): only ads of these", required: false },
+  platforms: { type: "string", description: "meta,linkedin,\u2026: only ads for these", required: false },
+  language: {
+    type: "string",
+    description: "The language its words are in (es): its banned words are checked only in ads in it",
+    required: false
+  },
+  quote: { type: "string", description: "The person's own words it came from, verbatim", required: false },
+  slug: { type: "string", description: "The creative they said it about", required: false },
+  run: { type: "string", description: "The version they said it about (r_\u2026): the rule must catch it", required: false },
+  why: { type: "string", description: "Why, in a sentence, when the person said", required: false },
+  id: { type: "string", description: "The rule's id (its file name); default: from its words", required: false },
+  replaces: {
+    type: "string",
+    description: "A rule of the person's it contradicts and wins over: retired, never deleted",
+    required: false
+  }
+};
+registerSchema({ command: "creatives.rules.add", description: ADD_DESCRIPTION, args: ADD_ARGS });
+function brandMdHint(declared, relation) {
+  return relation === "same" ? `BRAND.md states this too ("${declared.text}"): now the person confirmed it, every finished ad is checked against it.` : `BRAND.md says otherwise ("${declared.text}"): tell the person, and change only that line of BRAND.md (/brand-build) so it no longer says otherwise; never write the rule itself into BRAND.md, or retiring it would leave it in force.`;
+}
+var rulesAddCommand = defineCommand({
+  meta: { name: "add", description: ADD_DESCRIPTION },
+  args: ADD_ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const cacheDir = path.join(root, "canvas", ".cache");
+    const candidateId = text(args.candidate);
+    const candidate = candidateId ? await loadCandidate(cacheDir, candidateId) : void 0;
+    if (candidateId && !candidate) {
+      fail(
+        "VALIDATION_ERROR",
+        `No drafted rule ${candidateId} here.`,
+        "Use the id `feedback record` printed in this chat, or pass --text."
+      );
+    }
+    const all = await readAllRules(root);
+    const rule = ruleFromInputs(
+      {
+        ...candidate ? { candidate } : {},
+        flags: {
+          text: text(args.text),
+          strength: text(args.strength),
+          applies: text(args.applies),
+          forbid: list(args.forbid),
+          allow: list(args.allow),
+          require: list(args.require),
+          people: text(args.people),
+          kinds: list(args.kinds),
+          products: list(args.products),
+          platforms: list(args.platforms),
+          language: text(args.language),
+          quote: text(args.quote),
+          slug: text(args.slug),
+          run: text(args.run),
+          why: text(args.why),
+          id: text(args.id)
+        }
+      },
+      { today: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), taken: all.map((r) => r.id) }
+    );
+    if ("error" in rule) fail("VALIDATION_ERROR", rule.error);
+    const replaces = text(args.replaces);
+    const compared = await compareHoldingSpend(rule, all);
+    const sameTaught = compared.same.filter((r) => r.origin === "learned");
+    if (sameTaught.length > 0) {
+      fail(
+        "DUPLICATE_RULE",
+        `The company already has this rule: ${sameTaught.map((r) => `${r.id} ("${r.text}")`).join("; ")}.`,
+        "Nothing to add. If the person wants it worded otherwise, retire that one and add this."
+      );
+    }
+    const conflicts = compared.conflicts.filter((r) => r.origin === "learned" && r.id !== replaces);
+    if (conflicts.length > 0) {
+      fail(
+        "RULE_CONFLICT",
+        `It contradicts ${conflicts.map((r) => `${r.id} ("${r.text}")`).join("; ")}.`,
+        "Ask the person which one wins. This one: add it again with --replaces <id> (that rule is retired, never deleted). The other: do not add this one."
+      );
+    }
+    const admission = await admit(rule);
+    const refusal = admissionRefusal(rule, admission);
+    if (refusal) fail(refusal.code, refusal.message, refusal.fix, { admission });
+    await mkdir(path.join(root, RULES_DIR), { recursive: true });
+    const file = path.join(RULES_DIR, `${rule.id}.md`);
+    await writeFile(path.join(root, file), ruleFileText(rule), "utf8");
+    const retired = replaces ? await retireFile(root, replaces, rule.id) : null;
+    const declared = [...compared.same, ...compared.conflicts].filter((r) => r.origin === "declared");
+    writeJson({
+      ok: true,
+      data: {
+        rule: rulesView([rule], { full: true })[0],
+        file,
+        admission,
+        ...retired ? { retired: retired.id } : {}
+      },
+      hints: [
+        `Saved for every ad from now on${admission.origin === "untested" ? " (not tested on a version: nothing a picture shows decides it, or the version had no picture)" : ""}. Tell the person in one line, then run \`baker creatives check\`: which ads already made break it.`,
+        ...compared.judged ? [] : [
+          "Whether it repeats or contradicts another rule could not be read (the decision model did not answer): look at `baker creatives rules list`."
+        ],
+        ...declared.map((r) => brandMdHint(r, compared.same.includes(r) ? "same" : "conflict"))
+      ]
+    });
+  }
+});
+var RETIRE_DESCRIPTION = `Retire a rule a person taught, when they say it no longer holds or another replaces it: it stays in its file as retired, never deleted, and no ad is held to it.
+Start here: baker creatives rules retire cien-por-cien-online [--by <rule id>|BRAND.md]
+A rule of BRAND.md is changed in BRAND.md (/brand-build).`;
+var RETIRE_ARGS = {
+  id: { type: "positional", description: "The rule's id (`baker creatives rules list`)", required: true },
+  by: { type: "string", description: "What replaces it: another rule's id, or BRAND.md", required: false }
+};
+registerSchema({ command: "creatives.rules.retire", description: RETIRE_DESCRIPTION, args: RETIRE_ARGS });
+var rulesRetireCommand = defineCommand({
+  meta: { name: "retire", description: RETIRE_DESCRIPTION },
+  args: RETIRE_ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const id = String(args.id);
+    if (/^brand-[0-9a-f]{8}$/.test(id)) {
+      fail("VALIDATION_ERROR", `${id} is a rule of BRAND.md.`, "Change it in BRAND.md with /brand-build.");
+    }
+    const retired = await retireFile(root, id, text(args.by));
+    if (!retired) fail("NOT_FOUND", `No rule ${id} in ${RULES_DIR}.`, "See `baker creatives rules list --all`.");
+    writeJson({
+      ok: true,
+      data: { rule: rulesView([retired], { full: true })[0] },
+      hints: ["Retired: no ad is held to it from now on."]
+    });
+  }
+});
+export {
+  brandMdHint,
+  compareHoldingSpend,
+  ruleFromInputs,
+  rulesAddCommand,
+  rulesRetireCommand
+};
+//# sourceMappingURL=rules-add-P7GNB6P7.js.map

package/dist/run-CJFQHZNM.js

@@ -0,0 +1,67 @@
+import {
+  failApi,
+  failValidation,
+  isTempScheduledAgentId
+} from "./chunk-WY3JUU5K.js";
+import "./chunk-ASRS37QE.js";
+import "./chunk-OR7PFL2W.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-HNNCAJNF.js";
+import {
+  apiPost,
+  validateConvexId
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/scheduled-agents/run.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "scheduled-agents.run",
+  description: "Run a published scheduled agent now, whatever its trigger says. Opens a Session immediately and returns its chatId. Does not need BAKER_CHAT_ID, and refuses a temp_agent_* id \u2014 a staged item has to be published before it can run.",
+  args: {
+    id: { type: "string", description: "Published scheduled agent ID", required: true }
+  }
+});
+var runCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: "Run a published scheduled agent now. Example: baker scheduled-agents run <id>"
+  },
+  args: {
+    id: { type: "positional", description: "Published scheduled agent ID", required: false },
+    "scheduled-agent-id": {
+      type: "string",
+      description: "Scheduled agent ID (alternative to positional)",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id || args["scheduled-agent-id"];
+      if (!id) {
+        failValidation("Scheduled agent ID is required.");
+      }
+      if (isTempScheduledAgentId(id)) {
+        failValidation("run needs a published scheduled agent ID, not temp_agent_*. Publish this chat first.");
+      }
+      validateConvexId(id);
+      const response = await apiPost("/api/scheduled-agents/run", { id });
+      writeJson(response);
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  runCommand
+};
+//# sourceMappingURL=run-CJFQHZNM.js.map

package/dist/run-TRSBHVIS.js

@@ -0,0 +1,68 @@
+import {
+  buildBackendClient,
+  executeCanvasRun,
+  runCommand,
+  stopBeforeKinds
+} from "./chunk-2OL4I4YD.js";
+import "./chunk-KXGV5DJK.js";
+import "./chunk-XOGQJYXH.js";
+import "./chunk-WN4KX7GE.js";
+import "./chunk-JCRCI7Q3.js";
+import "./chunk-IVIJJXXT.js";
+import "./chunk-ESQX7SRQ.js";
+import "./chunk-KKJ4KJCW.js";
+import "./chunk-Q6ULQMWG.js";
+import "./chunk-3ACMDRSE.js";
+import "./chunk-X4NTIBX7.js";
+import "./chunk-4IHWT7PH.js";
+import "./chunk-MOEWCMHR.js";
+import "./chunk-3V5XP2CA.js";
+import "./chunk-HI5Y3S45.js";
+import "./chunk-L4P53TUT.js";
+import "./chunk-UEIP4ZMH.js";
+import "./chunk-CCYNBDNE.js";
+import "./chunk-WHBFXR6F.js";
+import "./chunk-DQVI7GCX.js";
+import "./chunk-EKX37C3T.js";
+import "./chunk-KTZCLJ2D.js";
+import "./chunk-F4SEK6U4.js";
+import "./chunk-MKUA54QE.js";
+import "./chunk-POIE6T5R.js";
+import "./chunk-RBLX4JHD.js";
+import "./chunk-6ZFSDYWV.js";
+import "./chunk-G6XKD7QE.js";
+import "./chunk-QPESDKZC.js";
+import "./chunk-E44NXCTL.js";
+import "./chunk-EJGAJHLB.js";
+import "./chunk-KPCHWDJM.js";
+import "./chunk-AULSX5ZA.js";
+import "./chunk-UMIX2BMM.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-AVYUFJQQ.js";
+import "./chunk-QHZE62GP.js";
+import "./chunk-FJZYOVSW.js";
+import "./chunk-F3CZFUXZ.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-LNNTHEL7.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-OR7PFL2W.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-HNNCAJNF.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  buildBackendClient,
+  executeCanvasRun,
+  runCommand,
+  stopBeforeKinds
+};
+//# sourceMappingURL=run-TRSBHVIS.js.map