@neat.is/core 0.7.9 → 0.7.10

package/dist/{chunk-N5TPODCX.js → chunk-6T7ZHODF.js}

@@ -963,6 +963,7 @@ import { parse as parseYaml } from "yaml";
 import { extractedEdgeId } from "@neat.is/types";
 var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rb", ".php"]);
 var CONFIG_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var JSON_CONFIG_FILENAMES = /* @__PURE__ */ new Set(["app.json", "app.config.json", "eas.json"]);
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -1002,6 +1003,7 @@ async function isPythonVenvDir(dir) {
 function isConfigFile(name) {
   const ext = path3.extname(name);
   if (CONFIG_FILE_EXTENSIONS.has(ext)) return { match: true, fileType: ext.slice(1) };
+  if (JSON_CONFIG_FILENAMES.has(name)) return { match: true, fileType: "json" };
   if (name === ".env" || name.startsWith(".env.")) {
     if (isEnvTemplateFile(name)) return { match: false, fileType: "" };
     if (isNeatAuthoredEnvFile(name)) return { match: false, fileType: "" };
@@ -4127,6 +4129,21 @@ async function appendErrorEvent(ctx, ev) {
   await fs7.mkdir(path8.dirname(ctx.errorsPath), { recursive: true });
   await fs7.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
+async function appendConnectorIncident(errorsPath, input) {
+  const ev = {
+    id: input.id,
+    timestamp: input.timestamp,
+    service: input.service,
+    traceId: input.id,
+    spanId: input.id,
+    errorType: input.errorType,
+    errorMessage: input.errorMessage,
+    ...input.attributes && Object.keys(input.attributes).length > 0 ? { attributes: input.attributes } : {},
+    affectedNode: input.affectedNode
+  };
+  await fs7.mkdir(path8.dirname(errorsPath), { recursive: true });
+  await fs7.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+}
 function incidentAffectedNode(span, graph, scanPath) {
   const sid = graph ? resolveFusedServiceId(graph, span.service, span.env) : serviceId(span.service, span.env);
   const serviceNode = graph && graph.hasNode(sid) ? graph.getNodeAttributes(sid) : void 0;
@@ -10488,8 +10505,41 @@ import path45 from "path";
 import Parser14 from "tree-sitter";
 import Go3 from "tree-sitter-go";
 import { infraId as infraId15 } from "@neat.is/types";
-var SQL_METHODS = /* @__PURE__ */ new Set(["Exec", "ExecContext", "Query", "QueryContext", "QueryRow", "QueryRowContext"]);
 var PARSE_CHUNK10 = 16384;
+var DATABASE_SQL_METHODS = /* @__PURE__ */ new Set([
+  "Query",
+  "QueryContext",
+  "QueryRow",
+  "QueryRowContext",
+  "Exec",
+  "ExecContext",
+  "Prepare",
+  "PrepareContext"
+]);
+var SQLX_METHODS = /* @__PURE__ */ new Set([
+  "Get",
+  "Select",
+  "Queryx",
+  "QueryRowx",
+  "NamedExec",
+  "NamedQuery",
+  "MustExec",
+  "Preparex",
+  "GetContext",
+  "SelectContext"
+]);
+var DATABASE_SQL_IMPORT = "database/sql";
+var SQLX_IMPORT = "github.com/jmoiron/sqlx";
+function makeGoParser3() {
+  const p = new Parser14();
+  p.setLanguage(Go3);
+  return p;
+}
+function parseSource10(parser, source) {
+  return parser.parse(
+    (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK10)
+  );
+}
 function walk7(node, visit) {
   visit(node);
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -10497,25 +10547,54 @@ function walk7(node, visit) {
     if (child) walk7(child, visit);
   }
 }
+function goStringLiteralValue(node) {
+  if (!node) return null;
+  if (node.type === "interpreted_string_literal" || node.type === "raw_string_literal") {
+    const t = node.text;
+    return t.length >= 2 ? t.slice(1, -1) : "";
+  }
+  return null;
+}
+function goImportsAny(root, names) {
+  let found = false;
+  walk7(root, (node) => {
+    if (found || node.type !== "import_spec") return;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const value = goStringLiteralValue(node.namedChild(i));
+      if (value !== null && names.has(value)) found = true;
+    }
+  });
+  return found;
+}
+function firstStringLiteralArg(argsNode) {
+  if (!argsNode) return null;
+  for (let i = 0; i < argsNode.namedChildCount; i++) {
+    const value = goStringLiteralValue(argsNode.namedChild(i));
+    if (value !== null) return value;
+  }
+  return null;
+}
 function goSqlEndpointsFromFile(file, serviceDir) {
   if (path45.extname(file.path) !== ".go") return [];
-  const parser = new Parser14();
-  parser.setLanguage(Go3);
-  const tree = parser.parse(
-    (index) => index >= file.content.length ? "" : file.content.slice(index, index + PARSE_CHUNK10)
-  );
+  if (!file.content.includes(DATABASE_SQL_IMPORT) && !file.content.includes(SQLX_IMPORT)) return [];
+  const tree = parseSource10(makeGoParser3(), file.content);
+  const importsDatabaseSql = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([DATABASE_SQL_IMPORT]));
+  const importsSqlx = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([SQLX_IMPORT]));
+  if (!importsDatabaseSql && !importsSqlx) return [];
   const out = [];
   walk7(tree.rootNode, (node) => {
     if (node.type !== "call_expression") return;
     const fn = node.childForFieldName("function");
     if (fn?.type !== "selector_expression") return;
     const method = fn.childForFieldName("field")?.text;
-    if (!method || !SQL_METHODS.has(method)) return;
-    const arg = node.childForFieldName("arguments")?.namedChild(0);
-    if (!arg || arg.type !== "interpreted_string_literal" && arg.type !== "raw_string_literal") return;
-    const sql = arg.text.slice(1, -1);
+    if (!method) return;
+    const recognized = DATABASE_SQL_METHODS.has(method) || importsSqlx && SQLX_METHODS.has(method);
+    if (!recognized) return;
+    const sql = firstStringLiteralArg(node.childForFieldName("arguments"));
+    if (sql === null) return;
     const table = tableFromSqlStatement(sql);
     if (!table) return;
+    const columns = columnsFromSqlStatement(sql);
     const line = node.startPosition.row + 1;
     out.push({
       infraId: infraId15("sql-table", table),
@@ -10523,7 +10602,12 @@ function goSqlEndpointsFromFile(file, serviceDir) {
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
-      evidence: { file: toPosix(path45.relative(serviceDir, file.path)), line, snippet: snippet(file.content, line) }
+      ...columns.length > 0 ? { columns } : {},
+      evidence: {
+        file: toPosix(path45.relative(serviceDir, file.path)),
+        line,
+        snippet: snippet(file.content, line)
+      }
     });
   });
   return out;
@@ -10536,12 +10620,12 @@ import Go4 from "tree-sitter-go";
 import { infraId as infraId16 } from "@neat.is/types";
 var GORM_IMPORT_RE = /gorm\.io\/gorm/;
 var PARSE_CHUNK11 = 16384;
-function makeGoParser3() {
+function makeGoParser4() {
   const p = new Parser15();
   p.setLanguage(Go4);
   return p;
 }
-function parseSource10(parser, source) {
+function parseSource11(parser, source) {
   return parser.parse(
     (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK11)
   );
@@ -10965,7 +11049,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
 function gormEndpointsFromFile(file, serviceDir) {
   if (path46.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource10(makeGoParser3(), file.content);
+  const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
   const out = [];
   const seenTables = /* @__PURE__ */ new Set();
@@ -10996,7 +11080,7 @@ function gormEndpointsFromFile(file, serviceDir) {
 function gormForeignKeys(file, serviceDir) {
   if (path46.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource10(makeGoParser3(), file.content);
+  const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -14420,6 +14504,23 @@ async function runConnectorPoll(connector, ctx, graph, resolveTarget) {
       unresolved++;
       continue;
     }
+    if (signal.incident) {
+      ensureServiceNode(graph, resolved.serviceName, NO_ENV);
+      if (!ctx.errorsPath || !graph.hasNode(resolved.targetNodeId)) {
+        unresolved++;
+        continue;
+      }
+      await appendConnectorIncident(ctx.errorsPath, {
+        id: signal.incident.id,
+        timestamp: signal.incident.timestamp,
+        service: signal.incident.service,
+        errorType: signal.incident.errorType,
+        errorMessage: signal.incident.errorMessage,
+        ...signal.incident.attributes ? { attributes: signal.incident.attributes } : {},
+        affectedNode: resolved.targetNodeId
+      });
+      continue;
+    }
     if (resolved.ensureInfraNode) {
       const { kind, name, provider } = resolved.ensureInfraNode;
       ensureInfraNode(graph, kind, name, provider);
@@ -16587,6 +16688,329 @@ function createPlanetscaleConnector(graph, config, deps = {}) {
   };
 }
 
+// src/connectors/eas/types.ts
+function readEasCredentials(raw) {
+  const token = raw["token"];
+  if (typeof token !== "string" || token.length === 0) {
+    throw new Error("eas connector: credentials.token (EXPO_TOKEN) must be a non-empty string");
+  }
+  return { token };
+}
+var EAS_STATUS_ERRORED = "ERRORED";
+var TRANSIENT_BUILD_PHASES = /* @__PURE__ */ new Set([
+  "SPIN_UP_BUILDER",
+  "PREPARE_CREDENTIALS",
+  "RESTORE_CACHE",
+  "UPLOAD_APPLICATION_ARCHIVE"
+]);
+var INTERNAL_ERROR_CODE = /INTERNAL_SERVER_ERROR|EAS_BUILD_.*INTERNAL|_INTERNAL_ERROR|UNKNOWN_ERROR/i;
+function isTransientFailure(err) {
+  if (!err) return false;
+  const phase = typeof err.buildPhase === "string" ? err.buildPhase : void 0;
+  if (phase) {
+    if (TRANSIENT_BUILD_PHASES.has(phase)) return true;
+    if (/^SPIN_UP|_CREDENTIALS$|^RESTORE_CACHE/i.test(phase)) return true;
+  }
+  const code = typeof err.errorCode === "string" ? err.errorCode : void 0;
+  if (code && INTERNAL_ERROR_CODE.test(code)) return true;
+  return false;
+}
+var FIELD_SEP3 = "\0";
+var EAS_TARGET_KIND = "eas-build";
+function packEasTargetName(identity) {
+  return [identity.serviceName, identity.phase].join(FIELD_SEP3);
+}
+function parseEasTargetName(targetName) {
+  const sep = targetName.indexOf(FIELD_SEP3);
+  if (sep === -1) return null;
+  const serviceName = targetName.slice(0, sep);
+  const phase = targetName.slice(sep + 1);
+  if (!serviceName) return null;
+  return { serviceName, phase };
+}
+
+// src/connectors/eas/client.ts
+var DEFAULT_EAS_API_URL = "https://api.expo.dev/graphql";
+var DEFAULT_PAGE_SIZE = 50;
+var DEFAULT_MAX_PAGES = 10;
+var DEFAULT_MAX_LOG_BYTES = 16 * 1024;
+var DEFAULT_MAX_LOOKBACK_MS6 = 7 * 24 * 60 * 60 * 1e3;
+var BUILDS_QUERY = `
+  query NeatEasErroredBuilds($appId: String!, $offset: Int!, $limit: Int!) {
+    app {
+      byId(appId: $appId) {
+        builds(offset: $offset, limit: $limit, filter: { status: ERRORED }) {
+          id
+          status
+          platform
+          buildProfile
+          gitCommitHash
+          gitCommitMessage
+          gitRef
+          isGitWorkingTreeDirty
+          createdAt
+          completedAt
+          error {
+            buildPhase
+            errorCode
+            message
+            docsUrl
+          }
+          logFileUrls
+        }
+      }
+    }
+  }
+`;
+async function easGraphQL(apiUrl, token, query, variables, accountKey, fetchImpl) {
+  const res = await junctionFetch(
+    apiUrl,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...bearerAuthHeader(token)
+      },
+      body: JSON.stringify({ query, variables })
+    },
+    // accountKey: the Expo app id — the per-(provider, accountKey) rate-limit
+    // bucket (ADR-131), the closest thing this connector carries to "one account".
+    { provider: "eas", accountKey, ...fetchImpl ? { fetchImpl } : {} }
+  );
+  if (!res.ok) {
+    throw new Error(`Expo GraphQL request failed: ${res.status} ${res.statusText}`);
+  }
+  const body = await res.json();
+  if (body.errors && body.errors.length > 0) {
+    throw new Error(`Expo GraphQL errors: ${body.errors.map((e) => e.message).join("; ")}`);
+  }
+  if (!body.data) throw new Error("Expo GraphQL response carried no data");
+  return body.data;
+}
+async function fetchErroredBuilds(token, config, fetchImpl) {
+  const apiUrl = config.apiUrl ?? DEFAULT_EAS_API_URL;
+  const pageSize = config.pageSize ?? DEFAULT_PAGE_SIZE;
+  const maxPages = config.maxPages ?? DEFAULT_MAX_PAGES;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let page = 0; page < maxPages; page++) {
+    const data = await easGraphQL(
+      apiUrl,
+      token,
+      BUILDS_QUERY,
+      { appId: config.appId, offset: page * pageSize, limit: pageSize },
+      config.appId,
+      fetchImpl
+    );
+    const builds = data.app?.byId?.builds;
+    if (!Array.isArray(builds)) break;
+    let added = 0;
+    for (const b of builds) {
+      if (!b || typeof b.id !== "string" || b.id.length === 0) continue;
+      if (b.status !== EAS_STATUS_ERRORED) continue;
+      if (seen.has(b.id)) continue;
+      seen.add(b.id);
+      out.push(b);
+      added++;
+    }
+    if (builds.length < pageSize) break;
+    if (added === 0) break;
+  }
+  return out;
+}
+async function fetchBuildLogs(logFileUrls, maxBytes = DEFAULT_MAX_LOG_BYTES, fetchImpl) {
+  if (!Array.isArray(logFileUrls) || logFileUrls.length === 0) return "";
+  const doFetch = fetchImpl ?? fetch;
+  const chunks = [];
+  for (const url of logFileUrls) {
+    if (typeof url !== "string" || url.length === 0) continue;
+    try {
+      const res = await doFetch(url);
+      if (!res.ok) continue;
+      chunks.push(await res.text());
+    } catch {
+    }
+  }
+  const joined = chunks.join("\n");
+  return joined.length > maxBytes ? joined.slice(joined.length - maxBytes) : joined;
+}
+
+// src/connectors/eas/map.ts
+function buildEventTime(build) {
+  if (typeof build.completedAt === "string" && build.completedAt.length > 0) return build.completedAt;
+  if (typeof build.createdAt === "string" && build.createdAt.length > 0) return build.createdAt;
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function incidentMessage2(build) {
+  const err = build.error ?? {};
+  const phase = typeof err.buildPhase === "string" && err.buildPhase.length > 0 ? ` at ${err.buildPhase}` : "";
+  const detail = typeof err.message === "string" && err.message.trim().length > 0 && err.message.trim() || typeof err.errorCode === "string" && err.errorCode.length > 0 && err.errorCode || "no error detail reported";
+  let msg = `EAS build failed${phase}: ${detail}`;
+  if (build.isGitWorkingTreeDirty === true) {
+    msg += " (built from a dirty working tree \u2014 the commit may not represent what built)";
+  }
+  return msg;
+}
+function incidentAttributes(build) {
+  const attrs = {};
+  const err = build.error ?? {};
+  const put = (k, v) => {
+    if (typeof v === "string" && v.length === 0) return;
+    if (v !== void 0 && v !== null) attrs[k] = v;
+  };
+  put("eas.buildId", build.id);
+  put("eas.platform", build.platform ?? void 0);
+  put("eas.buildProfile", build.buildProfile ?? void 0);
+  put("eas.buildPhase", err.buildPhase ?? void 0);
+  put("eas.errorCode", err.errorCode ?? void 0);
+  put("eas.docsUrl", err.docsUrl ?? void 0);
+  put("eas.gitCommitHash", build.gitCommitHash ?? void 0);
+  put("eas.gitRef", build.gitRef ?? void 0);
+  put("eas.gitCommitMessage", build.gitCommitMessage ?? void 0);
+  if (typeof build.isGitWorkingTreeDirty === "boolean") {
+    attrs["eas.gitWorkingTreeDirty"] = build.isGitWorkingTreeDirty;
+    if (build.isGitWorkingTreeDirty) attrs["eas.confidence"] = "low";
+  }
+  put("eas.createdAt", build.createdAt ?? void 0);
+  put("eas.completedAt", build.completedAt ?? void 0);
+  if (typeof build.logsText === "string" && build.logsText.length > 0) {
+    attrs["eas.logs"] = build.logsText;
+  }
+  return attrs;
+}
+function mapBuildToSignal(build, serviceName) {
+  if (!build || typeof build !== "object") return null;
+  if (build.status !== EAS_STATUS_ERRORED) return null;
+  if (!build.error) return null;
+  if (isTransientFailure(build.error)) return null;
+  const timestamp = buildEventTime(build);
+  const phase = typeof build.error.buildPhase === "string" ? build.error.buildPhase : "";
+  return {
+    targetKind: EAS_TARGET_KIND,
+    targetName: packEasTargetName({ serviceName, phase }),
+    // Incident-only — no edge, so no call/error count to replay.
+    callCount: 0,
+    errorCount: 0,
+    lastObservedIso: timestamp,
+    incident: {
+      id: `eas:build:${build.id}`,
+      timestamp,
+      service: serviceName,
+      errorType: "eas-build-failure",
+      errorMessage: incidentMessage2(build),
+      attributes: incidentAttributes(build)
+    }
+  };
+}
+function mapBuildsToSignals(builds, serviceName) {
+  const out = [];
+  for (const build of builds) {
+    const signal = mapBuildToSignal(build, serviceName);
+    if (signal) out.push(signal);
+  }
+  return out;
+}
+
+// src/connectors/eas/resolve.ts
+import { EdgeType as EdgeType34, NodeType as NodeType32, parseFileId as parseFileId3 } from "@neat.is/types";
+var NO_ENV2 = "unknown";
+var EAS_JSON_PHASES = /* @__PURE__ */ new Set(["READ_EAS_JSON"]);
+var APP_CONFIG_PHASES = /* @__PURE__ */ new Set([
+  "READ_APP_CONFIG",
+  "CONFIGURE_EXPO_UPDATES",
+  "CALCULATE_EXPO_UPDATES_RUNTIME_VERSION"
+]);
+function configBasenamesForPhase(phase) {
+  if (EAS_JSON_PHASES.has(phase)) return ["eas.json"];
+  if (APP_CONFIG_PHASES.has(phase)) return ["app.json", "app.config.json"];
+  return [];
+}
+function configNodeService(graph, configNodeId) {
+  for (const edgeId of graph.inboundEdges(configNodeId)) {
+    const edge = graph.getEdgeAttributes(edgeId);
+    if (edge.type !== EdgeType34.CONFIGURED_BY) continue;
+    const parsed = parseFileId3(edge.source);
+    if (parsed) return parsed.service;
+  }
+  return null;
+}
+function findConfigNode(graph, basenames, serviceName) {
+  let scoped = null;
+  let anyMatch = null;
+  graph.forEachNode((id, attrs) => {
+    if (scoped) return;
+    const node = attrs;
+    if (node.type !== NodeType32.ConfigNode) return;
+    if (typeof node.name !== "string" || !basenames.includes(node.name)) return;
+    if (anyMatch === null) anyMatch = id;
+    if (configNodeService(graph, id) === serviceName) scoped = id;
+  });
+  return scoped ?? anyMatch;
+}
+function createEasResolveTarget(graph) {
+  return (signal) => {
+    if (signal.targetKind !== EAS_TARGET_KIND) return null;
+    const identity = parseEasTargetName(signal.targetName);
+    if (!identity) return null;
+    const { serviceName, phase } = identity;
+    const basenames = configBasenamesForPhase(phase);
+    if (basenames.length > 0) {
+      const configNodeId = findConfigNode(graph, basenames, serviceName);
+      if (configNodeId) {
+        return { targetNodeId: configNodeId, serviceName, edgeType: EdgeType34.CALLS };
+      }
+    }
+    return {
+      targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
+      serviceName,
+      edgeType: EdgeType34.CALLS
+    };
+  };
+}
+
+// src/connectors/eas/index.ts
+function isBuildSince(build, sinceIso) {
+  const t = Date.parse(buildEventTime(build));
+  const s = Date.parse(sinceIso);
+  if (Number.isNaN(t) || Number.isNaN(s)) return true;
+  return t > s;
+}
+function boundedSinceIso2(since, now, maxLookbackMs) {
+  const floor = new Date(now.getTime() - maxLookbackMs);
+  if (!since) return floor.toISOString();
+  const sinceMs = new Date(since).getTime();
+  if (Number.isNaN(sinceMs)) return floor.toISOString();
+  return sinceMs < floor.getTime() ? floor.toISOString() : new Date(sinceMs).toISOString();
+}
+var EasConnector = class {
+  constructor(config, fetchImpl) {
+    this.config = config;
+    this.fetchImpl = fetchImpl;
+  }
+  config;
+  fetchImpl;
+  provider = "eas";
+  async poll(ctx) {
+    const creds = readEasCredentials(ctx.credentials);
+    const serviceName = this.config.serviceName ?? this.config.appId;
+    const maxLookbackMs = this.config.maxLookbackMs ?? DEFAULT_MAX_LOOKBACK_MS6;
+    const sinceIso = boundedSinceIso2(ctx.since, /* @__PURE__ */ new Date(), maxLookbackMs);
+    const builds = await fetchErroredBuilds(creds.token, this.config, this.fetchImpl);
+    const fresh = builds.filter((b) => isBuildSince(b, sinceIso));
+    const maxLogBytes = this.config.maxLogBytes ?? DEFAULT_MAX_LOG_BYTES;
+    for (const build of fresh) {
+      build.logsText = await fetchBuildLogs(build.logFileUrls, maxLogBytes, this.fetchImpl);
+    }
+    return mapBuildsToSignals(fresh, serviceName);
+  }
+};
+function createEasConnector(graph, config, fetchImpl) {
+  return {
+    connector: new EasConnector(config, fetchImpl),
+    resolveTarget: createEasResolveTarget(graph)
+  };
+}
+
 // src/connectors/registry.ts
 var CLOUDFLARE_API_BASE_URL = "https://api.cloudflare.com/client/v4";
 async function authProbe(input) {
@@ -16874,6 +17298,41 @@ var PROVIDER_DISPATCH = {
         ...fetchImpl ? { fetchImpl } : {}
       });
     }
+  },
+  eas: {
+    provider: "eas",
+    // The secret is a single robot-user EXPO_TOKEN; a single-string credential
+    // maps to `token`. `appId` is non-secret config (connector-config.md §7.1).
+    primaryCredentialKey: "token",
+    requiredCredentialFields: ["token"],
+    requiredOptionFields: ["appId"],
+    build(graph, options) {
+      return createEasConnector(graph, options);
+    },
+    // Runs the connector's real `builds` query at limit 1 — the exact read poll()
+    // performs, minus the pages — so the probe checks both that the EXPO_TOKEN
+    // authenticates and that this app id is reachable, the same probe-the-real-
+    // query discipline Railway and Cloud Run use over a trivial `{ __typename }`.
+    // A bad or wrong-scoped token comes back as an Expo GraphQL error, which
+    // `fetchErroredBuilds` throws on, so it fails honestly here rather than
+    // silently at the first poll.
+    async validate({ credentials, options, fetchImpl }) {
+      const cfg = options;
+      const appId = String(cfg.appId ?? "");
+      if (!appId) return { ok: false, reason: "eas: appId is required to validate" };
+      const probeConfig = {
+        appId,
+        pageSize: 1,
+        maxPages: 1,
+        ...cfg.apiUrl ? { apiUrl: cfg.apiUrl } : {}
+      };
+      try {
+        await fetchErroredBuilds(String(credentials.token ?? ""), probeConfig, fetchImpl);
+        return { ok: true };
+      } catch (err) {
+        return { ok: false, reason: `eas auth check failed: ${err.message}` };
+      }
+    }
   }
 };
 function vercelCredsFrom(credentials) {
@@ -17086,7 +17545,11 @@ async function startConnectorPolling(input) {
   const stopFns = all.map(
     (registration) => startConnectorPollLoop(
       registration.connector,
-      { projectDir: input.projectDir, credentials: registration.credentials },
+      {
+        projectDir: input.projectDir,
+        credentials: registration.credentials,
+        ...input.errorsPath ? { errorsPath: input.errorsPath } : {}
+      },
       input.graph,
       registration.resolveTarget,
       { intervalMs: registration.intervalMs, connectorId: registration.id }
@@ -17415,10 +17878,15 @@ function registerRoutes(scope, ctx) {
       }
       const reg = built.registration;
       const at = (/* @__PURE__ */ new Date()).toISOString();
+      const incidentsPath = errorsPathFor(proj);
       try {
         const result = await ctx.runPoll(
           reg.connector,
-          { projectDir: proj.scanPath ?? "", credentials: reg.credentials },
+          {
+            projectDir: proj.scanPath ?? "",
+            credentials: reg.credentials,
+            ...incidentsPath ? { errorsPath: incidentsPath } : {}
+          },
           proj.graph,
           reg.resolveTarget
         );
@@ -18056,4 +18524,4 @@ export {
   deprovisionConnector,
   buildApi
 };
-//# sourceMappingURL=chunk-N5TPODCX.js.map
+//# sourceMappingURL=chunk-6T7ZHODF.js.map