@enricai/barnacle 1.12.8 → 1.12.10

package/dist/scripts/recon-generate.js

@@ -506,14 +506,14 @@ const IGNORE_REQUEST_HEADERS = new Set([
  */
 function deriveRequestHeaders(captures, replays, baseUrl, submitPatterns = null) {
     const successfulUrls = new Set(replays.filter((r) => r.success).map((r) => endpointKey(r.url)));
-    // Prefer ACTION captures (non-GET 2xx to baseUrl host, non-telemetry) as
-    // the authoritative header source. Replay-matched static-asset GETs lack
-    // the API-specific headers that REST endpoints require, so falling back
-    // to those produces a degenerate baseline-only header set. When action
-    // captures exist (multi-step submission flows), use them. For sites
-    // where the flow is a single REST call (no detectable action sequence),
-    // fall back to the replay-matched captures.
-    const actionCaptures = extractActionSequence(captures, baseUrl, submitPatterns).map((a) => a.capture);
+    // Prefer ACTION captures (non-GET 2xx, non-noise) as the authoritative
+    // header source. Replay-matched static-asset GETs lack the API-specific
+    // headers that REST endpoints require, so falling back to those produces
+    // a degenerate baseline-only header set. When action captures exist
+    // (multi-step submission flows), use them. For sites where the flow is a
+    // single REST call (no detectable action sequence), fall back to the
+    // replay-matched captures.
+    const actionCaptures = extractActionSequence(captures, submitPatterns).map((a) => a.capture);
     const replayMatchedCaptures = captures.filter((c) => successfulUrls.has(endpointKey(c.url)));
     const relevantCaptures = actionCaptures.length > 0 ? actionCaptures : replayMatchedCaptures;
     const counts = new Map();
@@ -707,26 +707,23 @@ function resolveManifestActionSequence(runRoot, captures) {
 }
 /**
  * Extracts the ordered sequence of meaningful POSTs that represent the
- * transactional flow: same-host 2xx POSTs, minus telemetry and error-reporting
- * sinks. Assets need no filter of their own — they arrive as GETs.
+ * transactional flow: non-noise 2xx POSTs, minus telemetry and error-reporting
+ * sinks. Assets need no filter of their own — they arrive as GETs. Host is
+ * NOT a filter criterion — a multi-step submission routinely bounces to a
+ * different host mid-flow (an account-creation redirect, a tenant API
+ * subdomain distinct from the landing page's host), so `isNoiseUrl` alone
+ * decides what counts as site traffic vs. third-party noise.
  *
  * When the flow declares submit patterns, only POSTs matching them survive —
  * this isolates the submission from same-origin page chrome (bootstrap, chatbot,
  * JWT refresh, reference-lookup) that a browser fires incidentally. Absent
- * patterns preserve the host/noise heuristic exactly.
+ * patterns preserve the noise heuristic exactly.
  *
  * Exported for tests: this predicate decides what a generated plugin will POST
  * at a live site, and it is the only gate between a browser's incidental
  * chatter and the emitted hot path.
  */
-function extractActionSequence(captures, baseUrl, submitPatterns = null) {
-    let host;
-    try {
-        host = new URL(baseUrl).host;
-    }
-    catch {
-        host = "";
-    }
+function extractActionSequence(captures, submitPatterns = null) {
     const matchesSubmit = compileSubmitMatcher(submitPatterns);
     return captures
         .map((capture, index) => ({ capture, index }))
@@ -735,15 +732,6 @@ function extractActionSequence(captures, baseUrl, submitPatterns = null) {
             return false;
         if (capture.status < 200 || capture.status >= 300)
             return false;
-        let captureHost;
-        try {
-            captureHost = new URL(capture.url).host;
-        }
-        catch {
-            return false;
-        }
-        if (captureHost !== host)
-            return false;
         if ((0, capture_filters_1.isNoiseUrl)(capture.url))
             return false;
         if (!matchesSubmit(capture))
@@ -759,19 +747,13 @@ function extractActionSequence(captures, baseUrl, submitPatterns = null) {
  * make up a transactional flow (`UpsertSavedApplication`, `SubmitForm`, ...)
  * — and drops `query` operations, which are read/bootstrap calls (e.g. a
  * page-load `ListForms`) that carry no state-threading value and are exactly
- * what let a chronologically-first fallback pick an unrelated query.
+ * what let a chronologically-first fallback pick an unrelated query. Host is
+ * NOT a filter criterion, matching {@link extractActionSequence}.
  *
  * Exported for tests: this predicate decides what a generated GraphQL plugin
  * will send at a live site.
  */
-function extractGraphQLActionSequence(captures, baseUrl, submitPatterns = null) {
-    let host;
-    try {
-        host = new URL(baseUrl).host;
-    }
-    catch {
-        host = "";
-    }
+function extractGraphQLActionSequence(captures, submitPatterns = null) {
     const matchesSubmit = compileSubmitMatcher(submitPatterns);
     return captures
         .map((capture, index) => ({ capture, index }))
@@ -780,15 +762,6 @@ function extractGraphQLActionSequence(captures, baseUrl, submitPatterns = null)
             return false;
         if (capture.status < 200 || capture.status >= 300)
             return false;
-        let captureHost;
-        try {
-            captureHost = new URL(capture.url).host;
-        }
-        catch {
-            return false;
-        }
-        if (captureHost !== host)
-            return false;
         if ((0, capture_filters_1.isNoiseUrl)(capture.url))
             return false;
         if (!matchesSubmit(capture))
@@ -3298,20 +3271,18 @@ function emitContractTs(opts) {
     // invocation, so heterogeneous per-call shapes are each checked against
     // their own inferred schema regardless of what this client-level schema is.
     //
-    // For multi-step flows this stays z.unknown(), not an unfinished schema: a
-    // submission flow's terminal shape is the plugin's OWN contract with its
-    // caller (e.g. { verified: boolean }), a field that appears in zero
-    // captured responses. Inferring a schema from the captures would emit the
-    // wrong shape with false confidence. z.unknown() plus the generated
-    // `[ ] Narrow ResponseSchema` checklist item is the intended hand-off to
-    // the plugin author, who alone knows that contract — narrowing it only
-    // changes what executeHttp promises its caller, and is now safe to do
-    // without affecting per-call validation. Single-endpoint plugins keep the
-    // inferred schema, since there both roles (client default and sole call)
-    // coincide.
-    // Browser-flow-only plugins have no HTTP call to infer a shape from either
-    // — same z.unknown() treatment as the multi-step case, for the same reason.
-    const responseSchemaExpr = multiStepBody || omitExecuteHttp ? `z.unknown()` : inferZodSchema(responseBody);
+    // For multi-step flows, `responseBody` here is already
+    // `selectEffectiveResponseBody`'s pick — the SAME call `selectReturnAction`
+    // returns from `executeHttp` (`return { data: r9 }` below, r9 being that
+    // call's own already-validated result). Inferring the client-level schema
+    // from it is therefore not a guess about a field the captures never showed:
+    // it's the literal shape of the value the client hands back, captured by
+    // its own success response (e.g. a `valid`/`errors`-shaped terminal body).
+    // Single-endpoint plugins keep the same inferred-schema treatment, since
+    // there both roles (client default and sole call) coincide.
+    // Browser-flow-only plugins have no HTTP call to infer a shape from —
+    // z.unknown() there is the honest gap, not a narrowing shortcut.
+    const responseSchemaExpr = omitExecuteHttp ? `z.unknown()` : inferZodSchema(responseBody);
     // Multi-step flows that include a multipart upload need the binary asset
     // on the payload. ApplicantContactSchema (via ApplicantResumeSchema) already
     // declares Resume/ResumeContentType/ResumeFilename, so submission flows
@@ -4178,9 +4149,7 @@ async function main() {
     // Hoisted so both the primary-operation gate below and rawActionCaptures
     // (further down) read the same computed sequence instead of calling the
     // extractor twice.
-    const graphqlActionSequence = gql
-        ? extractGraphQLActionSequence(captures, baseUrl, submitPatterns)
-        : [];
+    const graphqlActionSequence = gql ? extractGraphQLActionSequence(captures, submitPatterns) : [];
     const isReadOnlyFlow = !flowSteps.some((step) => typeof step !== "string" && step.submitStep === true);
     const primaryGraphQLOperation = gql && isReadOnlyFlow && graphqlActionSequence.length === 0
         ? selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary)
@@ -4201,7 +4170,7 @@ async function main() {
     // heuristic extraction finds.
     const patternedHeuristicActionCaptures = gql
         ? graphqlActionSequence
-        : collapseRedundantPatches(extractActionSequence(captures, baseUrl, submitPatterns));
+        : collapseRedundantPatches(extractActionSequence(captures, submitPatterns));
     // The same undercount hazard applies one layer below the manifest: a
     // flow-declared submitEndpointPattern that matches only one section's URL
     // (the natural way to describe "the button that finishes the wizard")
@@ -4214,8 +4183,8 @@ async function main() {
     const unfilteredHeuristicActionCaptures = submitPatterns.endpoint === null && submitPatterns.body === null
         ? patternedHeuristicActionCaptures
         : gql
-            ? extractGraphQLActionSequence(captures, baseUrl, null)
-            : collapseRedundantPatches(extractActionSequence(captures, baseUrl, null));
+            ? extractGraphQLActionSequence(captures, null)
+            : collapseRedundantPatches(extractActionSequence(captures, null));
     const patternUndercounts = patternedHeuristicActionCaptures.length < unfilteredHeuristicActionCaptures.length;
     if (patternUndercounts) {
         logger.info(`submission selection: ignoring submitEndpointPattern/submitBodyPattern (${patternedHeuristicActionCaptures.length} capture(s)) as an undercount of the unfiltered heuristic action sequence (${unfilteredHeuristicActionCaptures.length} capture(s))`);
@@ -4238,16 +4207,16 @@ async function main() {
     // The declared submitEndpointPattern's own under-match: unlike manifestUndercounts
     // (which compares an authoritative submit-manifest.json against the heuristic
     // sequence), this compares the pattern-filtered heuristic sequence against the SAME
-    // captures with no submitPatterns filter at all — the true raw same-host non-GET 2xx
+    // captures with no submitPatterns filter at all — the true raw non-GET 2xx non-noise
     // action set. A pattern that matches conspicuously fewer calls than that raw set is a
     // detection failure (the pattern is too narrow), not evidence the flow is read-only,
     // and per the no-silent-fallback rule must not be allowed to quietly collapse into the
     // generic single-endpoint {query} template below.
-    const rawSameHostActionCaptures = submitEndpointPattern === null
+    const rawUnfilteredActionCaptures = submitEndpointPattern === null
         ? null
         : gql
-            ? extractGraphQLActionSequence(captures, baseUrl, null)
-            : collapseRedundantPatches(extractActionSequence(captures, baseUrl, null));
+            ? extractGraphQLActionSequence(captures, null)
+            : collapseRedundantPatches(extractActionSequence(captures, null));
     // Form-schema detection runs BEFORE state-indexing so the field-id/option-id
     // UUIDs can be shielded from indexing — those UUIDs are stable schema
     // anchors that T2/T3 substitution depends on remaining literal in body
@@ -4307,10 +4276,10 @@ async function main() {
     // excluded real action captures the unfiltered raw set still has, emitting the generic
     // {query} template would misrepresent a genuine multi-call flow as read-only. Exit
     // rather than degrade quietly, per the no-defensive/no-silent-fallback rule.
-    if (rawSameHostActionCaptures !== null &&
+    if (rawUnfilteredActionCaptures !== null &&
         !isSubmissionFlow &&
-        rawSameHostActionCaptures.length > heuristicActionCaptures.length) {
-        logger.error(`ERROR declared submitEndpointPattern ${JSON.stringify(submitEndpointPattern)} matched only ${heuristicActionCaptures.length} of ${rawSameHostActionCaptures.length} raw same-host non-GET 2xx action capture(s) — this under-match looks like a detection failure, not a read-only flow; refusing to fall back to the generic single-endpoint {query} template. Fix submitEndpointPattern in recon-flow.json to cover the real submission calls.`);
+        rawUnfilteredActionCaptures.length > heuristicActionCaptures.length) {
+        logger.error(`ERROR declared submitEndpointPattern ${JSON.stringify(submitEndpointPattern)} matched only ${heuristicActionCaptures.length} of ${rawUnfilteredActionCaptures.length} raw non-GET 2xx non-noise action capture(s) — this under-match looks like a detection failure, not a read-only flow; refusing to fall back to the generic single-endpoint {query} template. Fix submitEndpointPattern in recon-flow.json to cover the real submission calls.`);
         process.exit(1);
     }
     // Diagnostic for the FAILURE-3 shape (a flowless recon capture): a "submission flow"