sparkforensics-server 0.5.0 → 0.5.2

package/vendor-core/stage-identity.js

@@ -0,0 +1,112 @@
+import { cyrb53 } from './string-hash.js';
+import { planNodesOfStage } from './stage-plan-nodes.js';
+                                                  
+                                                             
+
+// The stage-identity recipe, parameterized by the detail normalizer. `stageIdentity` (the frozen
+// exact key, run-comparison.ts) runs it with `normalizeDetail`; the aligner's `comparisonIdentity`
+// runs it with the comparison normalizer. One recipe, so the two keys can differ only in how a
+// detail string is normalized.
+
+                                                          
+
+// Replace run-varying tokens (digit runs, long hex ids) with a stable marker so
+// the same logical stage across two runs normalizes to one identity.
+export function normalizeStageName(name        )         {
+  return String(name)
+    .toLowerCase()
+    .replace(/\b[0-9a-f]{8,}\b/g, '#') // hex ids/uuids first (they contain digits)
+    .replace(/\d+/g, '#')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+// Bottom-up, order-independent structural identity of a resolved plan tree:
+// each node folds its normalized name/detail with its children's digests
+// (children sorted, so AQE picking a different broadcast side still matches),
+// so two plans collide only when their whole shape and every node's detail
+// agree. `normalizeDetail` strips the run-to-run noise (expr ids, `plan_id=`,
+// codegen numbers, AQE build-side choice, commutative-operand order). Each
+// node folds to a fixed-length cyrb53 digest (JSON.stringify-encoded, so
+// detail text containing `<`/`>`/`{`/`,` can't collide two different plans)
+// instead of embedding full child identity strings, which would re-escape
+// every level below and blow identity size up to ~2^depth on the 20-60+
+// operator-deep plans real Spark produces.
+function planTreeIdentity(root                             , normalizeDetail                  )                {
+  if (!root) return null;
+  function visit(node          )         {
+    const childDigests = (node.children ?? []).map(visit).sort();
+    return cyrb53(JSON.stringify([normalizeStageName(node.name ?? ''), normalizeDetail(node.detail ?? ''), childDigests]));
+  }
+  return visit(root);
+}
+
+// Plan identity for the stage's SQL execution, scoped to only the plan nodes
+// this stage actually ran (`node.stageIds`), not the whole tree: two stages
+// sharing one SQL execution (e.g. a self-join's two Exchange stages) otherwise
+// collapse onto one identity regardless of which part of the plan each ran.
+// Falls back to the coarser whole-tree identity when the stage has no
+// attributed nodes (hand-built snapshots without `stageIds`, or unmatched
+// accumulables).
+function sqlNodeIdentity(
+  stage       , snapshot                              , normalizeDetail                  , nodes             ,
+)         {
+  const execId = stage.sqlExecutionId;
+  if (execId == null) return '';
+  const root = snapshot.sql.get(execId)?.planTree ?? null;
+  if (!root) return '';
+  const fingerprints = (nodes ?? planNodesOfStage(stage, snapshot.sql))
+    .map((node) => JSON.stringify([normalizeStageName(node.name ?? ''), normalizeDetail(node.detail ?? '')]));
+  if (fingerprints.length === 0) return planTreeIdentity(root, normalizeDetail) ?? '';
+  return cyrb53(JSON.stringify(fingerprints.sort()));
+}
+
+/** `nodes`: the stage's attributed plan nodes when the caller already has them (`planNodesOfStage`),
+ * so one walk of the plan serves several readers. */
+export function stageIdentityWith(
+  stage       , snapshot                              , normalizeDetail                  , nodes             ,
+)         {
+  return normalizeStageName(stage.name ?? '') + '§' + sqlNodeIdentity(stage, snapshot, normalizeDetail, nodes);
+}
+
+export function identityIndexWith(
+  snapshot                 , identityOf                                      , only                          = () => true,
+)                        {
+  const byIdentity = new Map                  ();
+  for (const [id, stage] of snapshot.stages) {
+    if (!only(id)) continue;
+    const key = identityOf(stage, id);
+    const ids = byIdentity.get(key);
+    if (ids) ids.push(id);
+    else byIdentity.set(key, [id]);
+  }
+  return byIdentity;
+}
+
+/** Pairs the stages of two identity indexes. An identity colliding equally on both sides has no
+ * genuine ambiguity about *count*, so its stages pair off positionally by sorted id rather than
+ * being dropped. This is exact when the identity actually distinguishes stages (e.g.
+ * self-comparing a run: every stage matches itself). It's a best-effort guess when the identity is
+ * coarse (no SQL/attribution) and the two sides are genuinely different runs -- two unrelated
+ * same-named stages could get cross-paired. Accepted tradeoff: dropping them instead would also
+ * sacrifice the exact-self-comparison case, which matters more. An identity with different counts
+ * per side pairs nothing. Deterministic and symmetric: identities visit in sorted order. */
+export function pairEqualCounts(
+  baseIdx                       , candIdx                       ,
+)                                                                                                         {
+  const pairs                                                              = [];
+  const matchedIdentities = new Set        ();
+  for (const identity of [...baseIdx.keys()].sort()) {
+    const candIds = candIdx.get(identity);
+    if (!candIds) continue;
+    const baseIds = baseIdx.get(identity) ;
+    if (baseIds.length !== candIds.length) continue;
+    const sortedBaseIds = [...baseIds].sort((a, b) => a - b);
+    const sortedCandIds = [...candIds].sort((a, b) => a - b);
+    for (let i = 0; i < sortedBaseIds.length; i++) {
+      pairs.push({ identity, baseId: sortedBaseIds[i], candId: sortedCandIds[i] });
+    }
+    matchedIdentities.add(identity);
+  }
+  return { pairs, matchedIdentities };
+}

package/vendor-core/stage-quantiles.js

@@ -1,4 +1,5 @@
                                                             
+import { medianOfSorted } from './median.js';
                                                                              
 
 // Single source of truth for the packed per-task numeric array: FIELDS (offset
@@ -304,6 +305,7 @@ function listScheduleEndMs(
   return endMs;
 }
 
+// p50 is the textbook median (the mean of the two middle values on an even count); p95 is nearest-rank.
 export function computeFieldQuantiles(arr              , fieldIndex        )                                            {
   const taskCount = arr.length / FIELDS.STRIDE;
   if (taskCount === 0) return { p50: 0, p95: 0, max: 0 };
@@ -313,7 +315,7 @@ export function computeFieldQuantiles(arr              , fieldIndex        )
   values.sort();
 
   return {
-    p50: values[Math.ceil(taskCount * 0.50) - 1],
+    p50: medianOfSorted(values),
     p95: values[Math.ceil(taskCount * 0.95) - 1],
     max: values[taskCount - 1],
   };

package/vendor-core/stage-structure.js

@@ -0,0 +1,83 @@
+// What the stage aligner compares beyond the exact comparison key: a stage's structural key (operator
+// tree shape, node names and sorted attribute names, with literals, paths, file counts and ids
+// removed) and the token sets its similarity scores read. Pure.
+
+import { cyrb53 } from './string-hash.js';
+import { normalizeStageName,                       } from './stage-identity.js';
+                                           
+
+// Plumbing nodes: codegen boundaries and input adapters change with how Spark fuses a stage, not with
+// the query, so the structural key and the similarity tokens skip them.
+const PLUMBING_NODE = /^(WholeStageCodegen|InputAdapter|ColumnarToRow|RowToColumnar)\b/;
+
+const isPlumbing = (node          )          => PLUMBING_NODE.test(node.name ?? '');
+
+/** The attribute names a plan node's text mentions (`amount#12` gives `amount`), without ids, each
+ * once, sorted. Sorting makes the key insensitive to the nondeterministic order in which Spark lists
+ * grouping and projection columns; reading only `name#id` references leaves literals out. */
+export function attributeNames(detail        )           {
+  const names = new Set        ();
+  for (const m of detail.matchAll(/([A-Za-z_][\w$.]*)#\d+L?/g)) names.add(m[1]);
+  return [...names].sort();
+}
+
+/** The structural key of a stage from the plan nodes attributed to it, or null when nothing but
+ * plumbing is attributed. The nodes form a forest (a node's parent is its nearest attributed
+ * ancestor); the key folds each node's normalized name, its sorted attribute names and its
+ * children's digests (sorted, so a join's side order does not matter). Only structure goes in: no
+ * node detail, so a literal, a path or a file count never splits two stages. */
+export function structuralKey(nodes                     )                {
+  const attributed = new Set(nodes.filter((n) => !isPlumbing(n)));
+  if (attributed.size === 0) return null;
+  const digests = new Map                  ();
+  const nested = new Set          ();
+  // Digests of the nearest attributed descendants of `node`'s children.
+  const below = (node          )           => {
+    const out           = [];
+    for (const child of node.children ?? []) {
+      if (attributed.has(child)) { out.push(digestOf(child)); nested.add(child); }
+      else out.push(...below(child));
+    }
+    return out;
+  };
+  const digestOf = (node          )         => {
+    let d = digests.get(node);
+    if (d === undefined) {
+      d = cyrb53(JSON.stringify([normalizeStageName(node.name ?? ''), attributeNames(node.detail ?? ''), below(node).sort()]));
+      digests.set(node, d);
+    }
+    return d;
+  };
+  for (const node of attributed) digestOf(node);
+  const roots = [...attributed].filter((n) => !nested.has(n)).map(digestOf).sort();
+  return cyrb53(JSON.stringify(roots));
+}
+
+const TOKEN_SPLIT = /[^A-Za-z0-9_.$]+/;
+
+/** Sorted distinct tokens of a stage's attributed nodes (name and normalized detail) and its name.
+ * Two stages whose text differs in one literal share nearly every token. */
+export function detailTokens(stageName                    , nodes                     , normalize                  )           {
+  const tokens = new Set        ();
+  const add = (text        ) => { for (const t of text.split(TOKEN_SPLIT)) if (t) tokens.add(t); };
+  add(normalizeStageName(stageName ?? ''));
+  for (const node of nodes) {
+    if (isPlumbing(node)) continue;
+    add(normalizeStageName(node.name ?? ''));
+    add(normalize(node.detail ?? ''));
+  }
+  return [...tokens].sort();
+}
+
+/** Jaccard similarity of two sorted arrays; 1 when both are empty. An element repeated in both counts
+ * as often as it repeats in the shorter side (multiset Jaccard), so distinct arrays give the plain one. */
+export function jaccard(a                            , b                            )         {
+  if (a.length === 0 && b.length === 0) return 1;
+  let i = 0, j = 0, both = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) { both++; i++; j++; }
+    else if (a[i] < b[j]) i++;
+    else j++;
+  }
+  return both / (a.length + b.length - both);
+}

package/vendor-core/types.js

@@ -156,6 +156,11 @@
                                
              
                              
+                       
+                     
+                           
+                                                                                                        
+                            
                          
  
                                     

package/vendor-core/write-target-args.js

@@ -0,0 +1,48 @@
+// Argument and identifier helpers shared by the write-target parsers (write-targets.ts) and the
+// Delta command resolver (delta-targets.ts).
+const IDENT_PART = String.raw`(?:\`(?:[^\`]|\`\`)*\`|[A-Za-z0-9_$]+)`;
+const IDENTIFIER = new RegExp(`^${IDENT_PART}(?:\\.${IDENT_PART})*$`);
+export const IDENT_PARTS = new RegExp(IDENT_PART, 'g');
+const TRUNCATION_MARKER = /\.\.\.(?:\s*\d+ more fields)?/;
+
+                                                          
+
+// Splits at top-level commas, ignoring commas inside (), [], {} and backticks. `terminated` is
+// true when a comma follows the arg: the last arg of a cut-off string is never terminated.
+export function splitArgs(args        )        {
+  const out        = [];
+  let depth = 0;
+  let quoted = false;
+  let start = 0;
+  for (let i = 0; i < args.length; i++) {
+    const c = args[i];
+    if (c === '`') quoted = !quoted;
+    else if (quoted) continue;
+    else if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') depth--;
+    else if (c === ',' && depth === 0) {
+      out.push({ text: args.slice(start, i).trim(), terminated: true });
+      start = i + 1;
+    }
+  }
+  out.push({ text: args.slice(start).trim(), terminated: false });
+  return out;
+}
+
+export function isCut(text        )          {
+  return text === '' || TRUNCATION_MARKER.test(text);
+}
+
+// `db`.`t` or db.t -> db.t. A part that itself contains a dot or backtick keeps its quoting.
+export function tableName(ident        )                {
+  if (!IDENTIFIER.test(ident)) return null;
+  const parts = (ident.match(IDENT_PARTS) ?? []).map((p) => {
+    if (!p.startsWith('`')) return p;
+    const inner = p.slice(1, -1).replace(/``/g, '`');
+    return /[.`]/.test(inner) ? p : inner;
+  });
+  return parts.join('.');
+}
+
+/** A write target found without parsing the node's simpleString. */
+                                                                       

package/vendor-core/write-targets.js

@@ -6,10 +6,15 @@
 //   - a target Spark cut short (no delimiter after it, or a "..." marker in it) is unparseable;
 //   - a write-like node outside the known list is reported as an unrecognized write;
 //   - an execution whose plan is not in the model (or whose start event could not be read) is
-//     listed, never skipped, and the count of unreadable log lines is reported.
+//     listed, never skipped, and the count of unreadable log lines is reported;
+//   - a Delta target is set only when exactly one table or path is named (delta-targets.ts,
+//     api-merge-writes.ts).
 // Targets are verbatim from the simpleString: nothing is resolved (relative paths, ${var}
 // placeholders, catalog-relative table names all pass through as the log states them).
 import { walkPlanTree } from './plan-tree-walk.js';
+import { apiMergeWrites } from './api-merge-writes.js';
+import { indexByRoot, isStagedDeltaWrite, parseDeltaTableV2, resolveDeltaCommandTarget,                       } from './delta-targets.js';
+import { IDENT_PARTS, isCut, splitArgs, tableName,          } from './write-target-args.js';
                                                          
 
                               
@@ -67,11 +72,6 @@ const NOT_WRITES = new Set([
   'UpdateEventTimeWatermarkColumn',
 ]);
 
-const IDENT_PART = String.raw`(?:\`(?:[^\`]|\`\`)*\`|[A-Za-z0-9_$]+)`;
-const IDENTIFIER = new RegExp(`^${IDENT_PART}(?:\\.${IDENT_PART})*$`);
-const IDENT_PARTS = new RegExp(IDENT_PART, 'g');
-const TRUNCATION_MARKER = /\.\.\.(?:\s*\d+ more fields)?/;
-
 function commandOf(nodeName        )         {
   return nodeName.replace(/^Execute\s+/, '').trim().replace(/Exec$/, '');
 }
@@ -86,30 +86,6 @@ function isWriteLike(command        )          {
   return (operator.match(/[A-Z][a-z0-9]*/g) ?? []).some((word) => WRITE_WORDS.has(word));
 }
 
-                                                   
-
-// Splits at top-level commas, ignoring commas inside (), [], {} and backticks. `terminated` is
-// true when a comma follows the arg: the last arg of a cut-off string is never terminated.
-function splitArgs(args        )        {
-  const out        = [];
-  let depth = 0;
-  let quoted = false;
-  let start = 0;
-  for (let i = 0; i < args.length; i++) {
-    const c = args[i];
-    if (c === '`') quoted = !quoted;
-    else if (quoted) continue;
-    else if (c === '(' || c === '[' || c === '{') depth++;
-    else if (c === ')' || c === ']' || c === '}') depth--;
-    else if (c === ',' && depth === 0) {
-      out.push({ text: args.slice(start, i).trim(), terminated: true });
-      start = i + 1;
-    }
-  }
-  out.push({ text: args.slice(start).trim(), terminated: false });
-  return out;
-}
-
 // Text after the command name in the simpleString. Empty when the simpleString does not start
 // with the command (so nothing after it can be trusted).
 function argsOf(detail        , command        )         {
@@ -118,21 +94,6 @@ function argsOf(detail        , command        )         {
   return m[2];
 }
 
-function isCut(text        )          {
-  return text === '' || TRUNCATION_MARKER.test(text);
-}
-
-// `db`.`t` or db.t -> db.t. A part that itself contains a dot or backtick keeps its quoting.
-function tableName(ident        )                {
-  if (!IDENTIFIER.test(ident)) return null;
-  const parts = (ident.match(IDENT_PARTS) ?? []).map((p) => {
-    if (!p.startsWith('`')) return p;
-    const inner = p.slice(1, -1).replace(/``/g, '`');
-    return /[.`]/.test(inner) ? p : inner;
-  });
-  return parts.join('.');
-}
-
 // First arg of a path-writing command. The next arg must be the boolean that follows it in
 // InsertIntoHadoopFsRelationCommand, or the static-partition map (INSERT OVERWRITE ... PARTITION
 // (dt='x')) that precedes that boolean, which Spark prints as `[dt=x]` (or `Map(dt -> x)`); this also rejects a path Spark printed with ", " inside.
@@ -259,9 +220,10 @@ function isKnownWrite(command        )          {
 function parseWrite(command        , detail        )                           {
   const argParser = ARG_PARSERS[command];
   if (argParser) return [true, argParser(splitArgs(argsOf(detail, command)))];
-  if (V2_WRITES.has(command)) return [true, parseV2Write(detail)];
+  if (V2_WRITES.has(command)) return [true, parseDeltaTableV2(detail) ?? parseV2Write(detail)];
   if (V2_TABLE_AS_SELECT.has(command)) return [true, parseV2TableAsSelect(splitArgs(argsOf(detail, command)))];
   // A MERGE prints its source relation too, so a delta. path in it may be the source, not the target.
+  // Its target comes from resolveDeltaCommandTarget alone.
   if (command === 'MergeIntoCommand') return [true, null];
   if (DELTA_COMMANDS.has(command)) return [true, parseDeltaPath(splitArgs(argsOf(detail, command)))];
   return [false, null];
@@ -272,14 +234,16 @@ function outputRowsOf(node          )                {
   return metric !== undefined && Number.isFinite(metric.value) ? metric.value : null;
 }
 
-function collectWrites(executionId        , root          , out               )       {
+function collectWrites(exec              , root          , byRoot                  , out               )       {
   walkPlanTree(root, (node) => {
     const command = commandOf(node.name);
     if (!isWriteLike(command)) return;
     const detail = node.detail ?? '';
-    const [recognized, parsed] = parseWrite(command, detail);
+    const [recognized, parsedFromDetail] = parseWrite(command, detail);
+    // A Delta command's simpleString is bare on real logs: its target is found elsewhere.
+    const parsed = parsedFromDetail ?? resolveDeltaCommandTarget(command, exec, node, byRoot);
     out.push({
-      sqlExecutionId: executionId,
+      sqlExecutionId: exec.id,
       nodeId: node.id ?? null,
       command,
       recognized,
@@ -291,6 +255,20 @@ function collectWrites(executionId        , root          , out               )
   }, { dedupe: true });
 }
 
+// A staged Delta write writes the table its root's CTAS/RTAS node names, when it has exactly one.
+function attributeStagedWrites(writes               , sql                           )       {
+  for (const write of writes) {
+    if (write.target !== null || !isStagedDeltaWrite(write)) continue;
+    const root = sql.get(write.sqlExecutionId)?.rootExecutionId;
+    if (root === undefined || root === write.sqlExecutionId) continue;
+    const parents = writes.filter((w) => w.sqlExecutionId === root && V2_TABLE_AS_SELECT.has(w.command));
+    if (parents.length === 1 && parents[0].target !== null) {
+      write.kind = parents[0].kind;
+      write.target = parents[0].target;
+    }
+  }
+}
+
                                     
                                                                                    
                                      
@@ -301,11 +279,16 @@ export function extractWriteTargets(sql                           , input
   const writes                = [];
   const withoutPlan = new Map                                        ();
   for (const id of input.unreadableSqlExecutions ?? []) if (!sql.get(id)?.planTree) withoutPlan.set(id, 'unreadableStart');
+  const byRoot = indexByRoot(sql);
   for (const id of [...sql.keys()].sort((a, b) => a - b)) {
-    const planTree = sql.get(id) .planTree;
-    if (!planTree) withoutPlan.set(id, withoutPlan.get(id) ?? 'noPlan');
-    else collectWrites(id, planTree, writes);
+    const exec = sql.get(id) ;
+    if (!exec.planTree) withoutPlan.set(id, withoutPlan.get(id) ?? 'noPlan');
+    else collectWrites(exec, exec.planTree, byRoot, writes);
   }
+  // DeltaTable API merges run no command node: they are found by their executions' descriptions.
+  attributeStagedWrites(writes, sql);
+  writes.push(...apiMergeWrites(sql));
+  writes.sort((a, b) => a.sqlExecutionId - b.sqlExecutionId);
   const executionsWithoutPlan = [...withoutPlan].sort((a, b) => a[0] - b[0])
     .map(([sqlExecutionId, reason]) => ({ sqlExecutionId, reason }));
   return { writes, executionsWithoutPlan, skippedLines: input.skippedLines ?? null };

package/public/assets/CachingOpportunity-Cfw3wAFa.js

@@ -1 +0,0 @@
-import{r as e}from"./rolldown-runtime-hePW80VL.js";import{M as t}from"./charts-vendor-0VMaLVLN.js";import{E as n,Y as r,_t as i,d as a,p as o}from"./DisclosureContext-Ds0hcZFn.js";import{p as s}from"./plan-graph-vendor-B0sEms9Z.js";import{h as c,m as l}from"./useRecentFiles-Bb4-ukVz.js";import{C as u,F as d,I as f,L as p,M as m,N as h,O as g,R as _}from"./index-DaC8A2FS.js";import{o as v,r as y,t as b}from"./Dashboard-CC_BXrNy.js";import{n as x}from"./finding-anchor-Dl8mIHiU.js";import{t as S}from"./usePagedRows-Bo-aSztx.js";var C={name:`git-merge`,size:24,node:[[`circle`,{cx:`18`,cy:`18`,r:`3`,key:`1xkwt0`}],[`circle`,{cx:`6`,cy:`6`,r:`3`,key:`1lh9wr`}],[`path`,{d:`M6 21V9a9 9 0 0 0 9 9`,key:`7kw0sc`}]]};C.node;var w=i(C),T=e(t(),1),E=s();function D({relations:e,operator:t}){let n=t===`union`?`union`:`join`;return(0,E.jsx)(`span`,{className:`inline-flex flex-wrap items-baseline`,children:e.map((e,t)=>(0,E.jsxs)(`span`,{children:[t>0?(0,E.jsxs)(E.Fragment,{children:[` `,(0,E.jsx)(`span`,{className:`mx-1 font-semibold uppercase text-xs tracking-wide text-primary`,children:n}),` `]}):null,e.relation]},e.relation))})}function O({finding:e}){let t=x([e]),i=e.variant===`composite`;return(0,E.jsxs)(_,{ref:t.ref,tabIndex:t.tabIndex,"data-flashed":t.dataFlashed,className:`transition-colors ${t.flashClassName}`,children:[(0,E.jsx)(d,{children:(0,E.jsxs)(`span`,{className:`inline-flex items-center gap-2`,children:[i?(0,E.jsx)(w,{className:`size-3.5 text-muted-foreground`,"aria-hidden":`true`}):null,i&&e.relations&&e.relations.length>0?(0,E.jsx)(D,{relations:e.relations,operator:e.operator}):(0,E.jsx)(`span`,{children:e.relation}),i?(0,E.jsx)(n,{variant:`outline`,className:`text-xs uppercase border-dashed`,children:e.operator?.toUpperCase()}):(0,E.jsx)(n,{variant:`secondary`,className:`text-xs uppercase`,children:e.format})]})}),(0,E.jsxs)(d,{children:[e.value,` queries`]}),(0,E.jsx)(d,{className:`text-right`,children:r(e.totalReadBytes)}),(0,E.jsxs)(d,{children:[(0,E.jsx)(b,{finding:e}),(0,E.jsx)(o,{children:(0,E.jsx)(c,{confidence:e.confidence,validationRequired:e.validationRequired})})]})]})}var k=(0,T.memo)(function({catalog:e,defaultCollapsed:t=!0}){let[n,r]=(0,T.useState)(0),i=(0,T.useMemo)(()=>l(e,`cachingOpportunity`).sort((e,t)=>t.totalReadBytes-e.totalReadBytes||(t.value??0)-(e.value??0)),[e]),s=g(),c=s?i.findIndex(e=>e===s.finding):null,{totalPages:d,effectivePage:b,visible:x}=S(i,n,r,c);if(i.length===0)return null;let C=i[0];return(0,E.jsx)(u,{title:`Caching Opportunities`,fixFor:i,impactBand:`info`,badges:(0,E.jsx)(a,{type:`cachingOpportunity`,impactBand:`info`}),defaultCollapsed:t,summary:(0,E.jsx)(v,{value:`${C.value}×`,context:`read by ${C.value} queries: ${C.relation}`}),children:(0,E.jsxs)(`div`,{className:`space-y-3`,children:[(0,E.jsxs)(m,{children:[(0,E.jsx)(p,{children:(0,E.jsxs)(_,{children:[(0,E.jsx)(f,{children:`Relation`}),(0,E.jsx)(f,{children:`Read by`}),(0,E.jsx)(f,{className:`text-right`,children:`Data read`}),(0,E.jsx)(f,{children:`Estimate`})]})}),(0,E.jsx)(h,{children:x.map((e,t)=>(0,E.jsx)(O,{finding:e},`${e.format}:${e.relation}:${(e.executionIds??[]).join(`,`)}:${t}`))})]}),(0,E.jsx)(o,{children:(0,E.jsx)(`p`,{className:`text-xs text-muted-foreground`,children:`Reuse is inferred from plan structure, not confirmed by execution. Verify before caching.`})}),(0,E.jsx)(y,{page:b,totalPages:d,onPrev:()=>r(e=>e-1),onNext:()=>r(e=>e+1)})]})})});export{k as CachingOpportunity};

package/public/assets/CoreUsageArea-BObEeenE.js

@@ -1 +0,0 @@
-import{r as e}from"./rolldown-runtime-hePW80VL.js";import{M as t,T as n,f as r,n as i,o as a,s as o,u as s,v as c}from"./charts-vendor-0VMaLVLN.js";import{B as l,S as u,X as d,b as f,d as p,p as m,u as h}from"./DisclosureContext-Ds0hcZFn.js";import{p as g}from"./plan-graph-vendor-B0sEms9Z.js";import{_,b as v,h as y,y as b}from"./useRecentFiles-Bb4-ukVz.js";import{C as x}from"./index-DaC8A2FS.js";import{c as S,f as C,o as w,p as T,r as E,t as D}from"./Dashboard-CC_BXrNy.js";import{t as O}from"./usePagedRows-Bo-aSztx.js";var k=e(t(),1),A=g(),j=240,M={PROCESS_LOCAL:`Process-local`,NODE_LOCAL:`Node-local`,RACK_LOCAL:`Rack-local`,NO_PREF:`No preference`,ANY:`Any`,OTHER:`Other`,idle:`Idle`},N={PROCESS_LOCAL:_.clean,NODE_LOCAL:_.accent,RACK_LOCAL:_.warning,NO_PREF:_.muted,ANY:_.critical,OTHER:_.muted,idle:_.muted},P=`Core Usage by Locality`,F=(0,k.memo)(function({catalog:e,defaultCollapsed:t=!0}){let[g,F]=(0,k.useState)(0),I=f()?.data.coreLocality,L=(0,k.useMemo)(()=>{let e=I?.chart??{hasActivity:!1};return e.hasActivity?{...e,sampled:S(e.points)}:e},[I]),R=I?.ratio.topStages??[],z=e.find(e=>e.type===`coreLocality`),B=e.some(e=>e.type===`memoryUtilization`&&e.variant===`idleCores`),V=R.filter(e=>e.nonLocalTasks>0),{totalPages:H,effectivePage:U,visible:W}=O(V,g,F);if(!L.hasActivity)return(0,A.jsx)(x,{title:P,summary:(0,A.jsx)(`span`,{className:`text-muted-foreground text-xs`,children:`No stage activity to plot.`}),children:(0,A.jsx)(C,{tone:`neutral`,icon:T,title:`No stage activity to plot.`})});let{order:G,points:K,sampled:q,peakCores:J}=L;return(0,A.jsx)(x,{title:P,impactBand:z?.impactBand,badges:z?(0,A.jsx)(p,{type:`coreLocality`,impactBand:z.impactBand}):null,defaultCollapsed:t,summary:(0,A.jsx)(w,{value:`${d(J)} cores`,context:`busy at the peak`}),children:(0,A.jsxs)(`div`,{className:`space-y-2`,children:[(0,A.jsx)(m,{children:(0,A.jsxs)(`p`,{className:`text-muted-foreground text-xs`,children:[`approximate: stage-level attribution`,z?null:(0,A.jsxs)(A.Fragment,{children:[`, see `,(0,A.jsx)(u,{anchor:`#bottleneck-utilization`,children:`how utilization is measured`})]})]})}),z?(0,A.jsxs)(`p`,{className:`flex flex-wrap items-start gap-2 text-sm`,children:[(0,A.jsx)(h,{impactBand:z.impactBand,className:`mt-1.5`}),(0,A.jsxs)(`span`,{children:[(0,A.jsxs)(`strong`,{children:[z.value,`% non-local`]}),`. `,l(z)]})]}):null,z?(0,A.jsx)(D,{finding:z}):null,(0,A.jsx)(m,{children:z?(0,A.jsx)(y,{confidence:z.confidence,validationRequired:z.validationRequired}):null}),(0,A.jsx)(v,{ariaLabel:`Approximate concurrent core usage over time, stacked by task locality tier, with idle capacity shown. See the legend for tier colors.`,height:j,table:{caption:`Concurrent core usage over time by locality tier`,columns:[`Time (s)`,...G.map(e=>M[e]??e)],rows:K.map(e=>[e.t,...G.map(t=>Math.round(e[t]))]),align:Array.from({length:G.length+1},()=>`right`)},children:(0,A.jsxs)(i,{data:q,children:[(0,A.jsx)(r,{vertical:!1,stroke:_.muted,strokeOpacity:.2}),(0,A.jsx)(o,{dataKey:`t`,tick:{fontSize:10},label:{value:`seconds from app start`,position:`insideBottom`,offset:-2,fontSize:10}}),(0,A.jsx)(a,{tick:{fontSize:10},width:36,label:{value:`avg concurrent cores`,angle:-90,position:`insideLeft`,fontSize:10}}),(0,A.jsx)(c,{...b}),(0,A.jsx)(n,{wrapperStyle:{fontSize:10}}),G.map(e=>(0,A.jsx)(s,{type:`monotone`,dataKey:e,name:M[e]??e,stackId:`cores`,stroke:N[e]??_.muted,fill:N[e]??_.muted,fillOpacity:e===`idle`?.15:.8,isAnimationActive:!1},e))]})}),(0,A.jsx)(m,{children:W.length>0?(0,A.jsxs)(A.Fragment,{children:[(0,A.jsx)(`ul`,{className:`space-y-1 text-xs text-muted-foreground`,children:W.map(e=>(0,A.jsxs)(`li`,{children:[`Stage `,e.stageId,`: `,Math.round(e.ratio*100),`% non-local (`,e.nonLocalTasks,`/`,e.taskCount,` tasks)`]},e.stageId))}),(0,A.jsx)(E,{page:U,totalPages:H,onPrev:()=>F(e=>e-1),onNext:()=>F(e=>e+1)})]}):null}),(0,A.jsx)(m,{children:B?(0,A.jsx)(`p`,{className:`text-xs text-muted-foreground`,children:`Idle cores also flagged → see Memory Utilization widget`}):null})]})})});export{F as CoreUsageArea};