@shipfox/client-logs 0.2.0

package/dist/components/system-markers.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Icon } from '@shipfox/react-ui/icon';
+import { LogContent, LogRow } from '@shipfox/react-ui/log';
+import { cn, formatBytes, formatDuration } from '@shipfox/react-ui/utils';
+const toneText = {
+    default: 'text-foreground-neutral-muted',
+    warning: 'text-orange-600 dark:text-orange-400',
+    error: 'text-red-600 dark:text-red-400'
+};
+/**
+ * Shared timeline-marker row: a non-numbered line with a leading icon, a bold label, an
+ * optional plain-language detail clause, a dashed divider, and optional right-aligned
+ * monospace figures. The detail explains the consequence to the operator (the label
+ * names the event, the icon/tone carry severity), so the copy reads helpfully rather
+ * than mechanically.
+ */ function LogMarkerRow({ icon, tone, timestamp = null, detail, meta, terminalFailure = false, children }) {
+    return /*#__PURE__*/ _jsx(LogRow, {
+        lineNumber: null,
+        timestamp: timestamp,
+        tone: tone,
+        "data-log-terminal-failure": terminalFailure ? 'true' : undefined,
+        children: /*#__PURE__*/ _jsx(LogContent, {
+            className: cn('block', toneText[tone]),
+            children: /*#__PURE__*/ _jsxs("span", {
+                className: "inline-flex w-full items-center gap-8",
+                children: [
+                    /*#__PURE__*/ _jsx(Icon, {
+                        name: icon,
+                        className: "size-14 flex-none",
+                        "aria-hidden": "true"
+                    }),
+                    /*#__PURE__*/ _jsxs("span", {
+                        className: "min-w-0",
+                        children: [
+                            /*#__PURE__*/ _jsx("span", {
+                                className: "font-medium",
+                                children: children
+                            }),
+                            detail != null && /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    ' · ',
+                                    /*#__PURE__*/ _jsx("span", {
+                                        className: "font-normal opacity-80",
+                                        children: detail
+                                    })
+                                ]
+                            }),
+                            meta != null && /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    ' · ',
+                                    /*#__PURE__*/ _jsx("span", {
+                                        className: "font-code tabular-nums opacity-80",
+                                        children: meta
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        "aria-hidden": "true",
+                        className: "h-px flex-1 border-t border-dashed border-current opacity-30"
+                    })
+                ]
+            })
+        })
+    });
+}
+/** Clean end of the log: line count + output bytes (+ overall duration). `total_bytes` is payload bytes. */ export function EndMarker({ record, lineCount, durationMs = null }) {
+    const meta = [
+        `${lineCount} ${lineCount === 1 ? 'line' : 'lines'}`,
+        formatBytes(record.total_bytes),
+        ...durationMs != null ? [
+            formatDuration(durationMs)
+        ] : []
+    ].join(' · ');
+    return /*#__PURE__*/ _jsx(LogMarkerRow, {
+        icon: "flagLine",
+        tone: "default",
+        timestamp: new Date(record.ts),
+        meta: meta,
+        children: "End of log"
+    });
+}
+/** The runner's local backlog shed bytes before upload, so some output never arrived. A warning. */ export function GapMarker({ record }) {
+    return /*#__PURE__*/ _jsx(LogMarkerRow, {
+        icon: "errorWarningLine",
+        tone: "warning",
+        timestamp: new Date(record.ts),
+        detail: `the runner fell behind and dropped ${formatBytes(record.dropped_bytes)}`,
+        children: "Output missing"
+    });
+}
+/** The job hit its shared log size limit; logging stopped but the step kept running. A warning. */ export function CappedMarker({ record }) {
+    return /*#__PURE__*/ _jsx(LogMarkerRow, {
+        icon: "forbidLine",
+        tone: "warning",
+        timestamp: new Date(record.ts),
+        detail: "later output isn't shown; the step kept running",
+        children: "Log size limit reached"
+    });
+}
+/** The runner disappeared and the stream was force-closed. A terminal failure (status taxonomy §9). */ export function RunnerLostMarker({ record }) {
+    return /*#__PURE__*/ _jsx(LogMarkerRow, {
+        icon: "closeCircleLine",
+        tone: "error",
+        timestamp: new Date(record.ts),
+        detail: "the log ends here and may be incomplete",
+        terminalFailure: true,
+        children: "Runner disconnected"
+    });
+}
+
+//# sourceMappingURL=system-markers.js.map

package/dist/components/system-markers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/components/system-markers.tsx"],"sourcesContent":["import {Icon, type IconName} from '@shipfox/react-ui/icon';\nimport {LogContent, LogRow} from '@shipfox/react-ui/log';\nimport {cn, formatBytes, formatDuration} from '@shipfox/react-ui/utils';\nimport type {\n  CappedLogRecord,\n  EndLogRecord,\n  GapLogRecord,\n  RunnerLostLogRecord,\n} from '#core/log-tree.js';\n\ntype MarkerTone = 'default' | 'warning' | 'error';\n\nconst toneText: Record<MarkerTone, string> = {\n  default: 'text-foreground-neutral-muted',\n  warning: 'text-orange-600 dark:text-orange-400',\n  error: 'text-red-600 dark:text-red-400',\n};\n\ninterface LogMarkerRowProps {\n  icon: IconName;\n  tone: MarkerTone;\n  timestamp?: Date | null;\n  /** Plain-language clause after the label: what it means / what to do. */\n  detail?: string;\n  /** Right-aligned `font-code` figures (bytes, line count, duration). */\n  meta?: string;\n  terminalFailure?: boolean;\n  children: string;\n}\n\n/**\n * Shared timeline-marker row: a non-numbered line with a leading icon, a bold label, an\n * optional plain-language detail clause, a dashed divider, and optional right-aligned\n * monospace figures. The detail explains the consequence to the operator (the label\n * names the event, the icon/tone carry severity), so the copy reads helpfully rather\n * than mechanically.\n */\nfunction LogMarkerRow({\n  icon,\n  tone,\n  timestamp = null,\n  detail,\n  meta,\n  terminalFailure = false,\n  children,\n}: LogMarkerRowProps) {\n  return (\n    <LogRow\n      lineNumber={null}\n      timestamp={timestamp}\n      tone={tone}\n      data-log-terminal-failure={terminalFailure ? 'true' : undefined}\n    >\n      <LogContent className={cn('block', toneText[tone])}>\n        <span className=\"inline-flex w-full items-center gap-8\">\n          <Icon name={icon} className=\"size-14 flex-none\" aria-hidden=\"true\" />\n          {/* Label, detail, and figures share one text cluster joined by a literal\n              \" · \". Flex `gap` is visual only and would copy with no separator, so the\n              separators are real inline text. The dashed rule trails after the text\n              (an aria-hidden flex filler) and contributes nothing to a selection. */}\n          <span className=\"min-w-0\">\n            <span className=\"font-medium\">{children}</span>\n            {detail != null && (\n              <>\n                {' · '}\n                <span className=\"font-normal opacity-80\">{detail}</span>\n              </>\n            )}\n            {meta != null && (\n              <>\n                {' · '}\n                <span className=\"font-code tabular-nums opacity-80\">{meta}</span>\n              </>\n            )}\n          </span>\n          <span\n            aria-hidden=\"true\"\n            className=\"h-px flex-1 border-t border-dashed border-current opacity-30\"\n          />\n        </span>\n      </LogContent>\n    </LogRow>\n  );\n}\n\nexport interface EndMarkerProps {\n  record: EndLogRecord;\n  lineCount: number;\n  durationMs?: number | null;\n}\n\n/** Clean end of the log: line count + output bytes (+ overall duration). `total_bytes` is payload bytes. */\nexport function EndMarker({record, lineCount, durationMs = null}: EndMarkerProps) {\n  const meta = [\n    `${lineCount} ${lineCount === 1 ? 'line' : 'lines'}`,\n    formatBytes(record.total_bytes),\n    ...(durationMs != null ? [formatDuration(durationMs)] : []),\n  ].join(' · ');\n\n  return (\n    <LogMarkerRow icon=\"flagLine\" tone=\"default\" timestamp={new Date(record.ts)} meta={meta}>\n      End of log\n    </LogMarkerRow>\n  );\n}\n\n/** The runner's local backlog shed bytes before upload, so some output never arrived. A warning. */\nexport function GapMarker({record}: {record: GapLogRecord}) {\n  return (\n    <LogMarkerRow\n      icon=\"errorWarningLine\"\n      tone=\"warning\"\n      timestamp={new Date(record.ts)}\n      detail={`the runner fell behind and dropped ${formatBytes(record.dropped_bytes)}`}\n    >\n      Output missing\n    </LogMarkerRow>\n  );\n}\n\n/** The job hit its shared log size limit; logging stopped but the step kept running. A warning. */\nexport function CappedMarker({record}: {record: CappedLogRecord}) {\n  return (\n    <LogMarkerRow\n      icon=\"forbidLine\"\n      tone=\"warning\"\n      timestamp={new Date(record.ts)}\n      detail=\"later output isn't shown; the step kept running\"\n    >\n      Log size limit reached\n    </LogMarkerRow>\n  );\n}\n\n/** The runner disappeared and the stream was force-closed. A terminal failure (status taxonomy §9). */\nexport function RunnerLostMarker({record}: {record: RunnerLostLogRecord}) {\n  return (\n    <LogMarkerRow\n      icon=\"closeCircleLine\"\n      tone=\"error\"\n      timestamp={new Date(record.ts)}\n      detail=\"the log ends here and may be incomplete\"\n      terminalFailure\n    >\n      Runner disconnected\n    </LogMarkerRow>\n  );\n}\n"],"names":["Icon","LogContent","LogRow","cn","formatBytes","formatDuration","toneText","default","warning","error","LogMarkerRow","icon","tone","timestamp","detail","meta","terminalFailure","children","lineNumber","data-log-terminal-failure","undefined","className","span","name","aria-hidden","EndMarker","record","lineCount","durationMs","total_bytes","join","Date","ts","GapMarker","dropped_bytes","CappedMarker","RunnerLostMarker"],"mappings":";AAAA,SAAQA,IAAI,QAAsB,yBAAyB;AAC3D,SAAQC,UAAU,EAAEC,MAAM,QAAO,wBAAwB;AACzD,SAAQC,EAAE,EAAEC,WAAW,EAAEC,cAAc,QAAO,0BAA0B;AAUxE,MAAMC,WAAuC;IAC3CC,SAAS;IACTC,SAAS;IACTC,OAAO;AACT;AAcA;;;;;;CAMC,GACD,SAASC,aAAa,EACpBC,IAAI,EACJC,IAAI,EACJC,YAAY,IAAI,EAChBC,MAAM,EACNC,IAAI,EACJC,kBAAkB,KAAK,EACvBC,QAAQ,EACU;IAClB,qBACE,KAACf;QACCgB,YAAY;QACZL,WAAWA;QACXD,MAAMA;QACNO,6BAA2BH,kBAAkB,SAASI;kBAEtD,cAAA,KAACnB;YAAWoB,WAAWlB,GAAG,SAASG,QAAQ,CAACM,KAAK;sBAC/C,cAAA,MAACU;gBAAKD,WAAU;;kCACd,KAACrB;wBAAKuB,MAAMZ;wBAAMU,WAAU;wBAAoBG,eAAY;;kCAK5D,MAACF;wBAAKD,WAAU;;0CACd,KAACC;gCAAKD,WAAU;0CAAeJ;;4BAC9BH,UAAU,sBACT;;oCACG;kDACD,KAACQ;wCAAKD,WAAU;kDAA0BP;;;;4BAG7CC,QAAQ,sBACP;;oCACG;kDACD,KAACO;wCAAKD,WAAU;kDAAqCN;;;;;;kCAI3D,KAACO;wBACCE,eAAY;wBACZH,WAAU;;;;;;AAMtB;AAQA,0GAA0G,GAC1G,OAAO,SAASI,UAAU,EAACC,MAAM,EAAEC,SAAS,EAAEC,aAAa,IAAI,EAAiB;IAC9E,MAAMb,OAAO;QACX,GAAGY,UAAU,CAAC,EAAEA,cAAc,IAAI,SAAS,SAAS;QACpDvB,YAAYsB,OAAOG,WAAW;WAC1BD,cAAc,OAAO;YAACvB,eAAeuB;SAAY,GAAG,EAAE;KAC3D,CAACE,IAAI,CAAC;IAEP,qBACE,KAACpB;QAAaC,MAAK;QAAWC,MAAK;QAAUC,WAAW,IAAIkB,KAAKL,OAAOM,EAAE;QAAGjB,MAAMA;kBAAM;;AAI7F;AAEA,kGAAkG,GAClG,OAAO,SAASkB,UAAU,EAACP,MAAM,EAAyB;IACxD,qBACE,KAAChB;QACCC,MAAK;QACLC,MAAK;QACLC,WAAW,IAAIkB,KAAKL,OAAOM,EAAE;QAC7BlB,QAAQ,CAAC,mCAAmC,EAAEV,YAAYsB,OAAOQ,aAAa,GAAG;kBAClF;;AAIL;AAEA,iGAAiG,GACjG,OAAO,SAASC,aAAa,EAACT,MAAM,EAA4B;IAC9D,qBACE,KAAChB;QACCC,MAAK;QACLC,MAAK;QACLC,WAAW,IAAIkB,KAAKL,OAAOM,EAAE;QAC7BlB,QAAO;kBACR;;AAIL;AAEA,qGAAqG,GACrG,OAAO,SAASsB,iBAAiB,EAACV,MAAM,EAAgC;IACtE,qBACE,KAAChB;QACCC,MAAK;QACLC,MAAK;QACLC,WAAW,IAAIkB,KAAKL,OAAOM,EAAE;QAC7BlB,QAAO;QACPE,eAAe;kBAChB;;AAIL"}

package/dist/core/log-read.d.ts

@@ -0,0 +1,33 @@
+import { type LogRecord, type ReadLogsResponseDto } from '@shipfox/api-logs-dto';
+export declare const STEP_LOG_DRAIN_REFETCH_MS = 250;
+export declare const STEP_LOG_LIVE_REFETCH_MS = 2000;
+type InlineReadLogsResponse = Extract<ReadLogsResponseDto, {
+    mode: 'inline';
+}>;
+type PresignedReadLogsResponse = Extract<ReadLogsResponseDto, {
+    mode: 'presigned';
+}>;
+export interface StepLogSnapshot {
+    records: LogRecord[];
+    nextCursor: number;
+    source: 'inline' | 'presigned';
+    state: 'open' | 'closed' | 'compacted';
+    complete: boolean;
+    hasMore: boolean;
+    truncated: boolean;
+    totalBytes: number | null;
+    expiresAt: string | null;
+}
+export type ResolvedStepLogRead = {
+    mode: 'inline';
+    response: InlineReadLogsResponse;
+} | {
+    mode: 'presigned';
+    response: PresignedReadLogsResponse;
+    ndjson: string;
+};
+export declare function parseLogNdjson(ndjson: string): LogRecord[];
+export declare function mergeLogRead(previous: StepLogSnapshot | undefined, read: ResolvedStepLogRead): StepLogSnapshot;
+export declare function stepLogRefetchInterval(snapshot: StepLogSnapshot | undefined, lastFetchErrored?: boolean): number | false;
+export {};
+//# sourceMappingURL=log-read.d.ts.map

package/dist/core/log-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-read.d.ts","sourceRoot":"","sources":["../../src/core/log-read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,SAAS,EAAsB,KAAK,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAEnG,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAI9C,KAAK,sBAAsB,GAAG,OAAO,CAAC,mBAAmB,EAAE;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAC,CAAC,CAAC;AAC7E,KAAK,yBAAyB,GAAG,OAAO,CAAC,mBAAmB,EAAE;IAAC,IAAI,EAAE,WAAW,CAAA;CAAC,CAAC,CAAC;AAEnF,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC/B,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,sBAAsB,CAAA;CAAC,GAClD;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,yBAAyB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC;AAE7E,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,CAK1D;AAED,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,IAAI,EAAE,mBAAmB,GACxB,eAAe,CA6BjB;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,gBAAgB,UAAQ,GACvB,MAAM,GAAG,KAAK,CAQhB"}

package/dist/core/log-read.js

@@ -0,0 +1,49 @@
+import { parseLogRecordLine } from '@shipfox/api-logs-dto';
+export const STEP_LOG_DRAIN_REFETCH_MS = 250;
+export const STEP_LOG_LIVE_REFETCH_MS = 2_000;
+const NDJSON_LINE_BREAK = /\r?\n/;
+export function parseLogNdjson(ndjson) {
+    return ndjson.split(NDJSON_LINE_BREAK).filter((line)=>line.length > 0).map(parseLogRecordLine);
+}
+export function mergeLogRead(previous, read) {
+    if (read.mode === 'presigned') {
+        return {
+            records: parseLogNdjson(read.ndjson),
+            nextCursor: 0,
+            source: 'presigned',
+            state: 'compacted',
+            complete: true,
+            hasMore: false,
+            truncated: read.response.truncated,
+            totalBytes: read.response.total_bytes,
+            expiresAt: read.response.expires_at
+        };
+    }
+    const records = parseLogNdjson(read.response.ndjson);
+    const complete = read.response.state === 'closed' && !read.response.has_more;
+    return {
+        records: [
+            ...previous?.records ?? [],
+            ...records
+        ],
+        nextCursor: read.response.next_cursor,
+        source: 'inline',
+        state: read.response.state,
+        complete,
+        hasMore: read.response.has_more,
+        truncated: read.response.truncated,
+        totalBytes: null,
+        expiresAt: null
+    };
+}
+export function stepLogRefetchInterval(snapshot, lastFetchErrored = false) {
+    // A persistent failure (deleted step, 5xx, an unparseable record line) never advances
+    // the cursor, so without this guard the interval re-polls the same dead cursor forever.
+    // Stop once a fetch errors out (React Query's own retry absorbs transient blips first);
+    // refetchOnWindowFocus/Reconnect (gated on !complete) resume it.
+    if (lastFetchErrored) return false;
+    if (!snapshot || snapshot.complete) return false;
+    return snapshot.hasMore ? STEP_LOG_DRAIN_REFETCH_MS : STEP_LOG_LIVE_REFETCH_MS;
+}
+
+//# sourceMappingURL=log-read.js.map

package/dist/core/log-read.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/log-read.ts"],"sourcesContent":["import {type LogRecord, parseLogRecordLine, type ReadLogsResponseDto} from '@shipfox/api-logs-dto';\n\nexport const STEP_LOG_DRAIN_REFETCH_MS = 250;\nexport const STEP_LOG_LIVE_REFETCH_MS = 2_000;\n\nconst NDJSON_LINE_BREAK = /\\r?\\n/;\n\ntype InlineReadLogsResponse = Extract<ReadLogsResponseDto, {mode: 'inline'}>;\ntype PresignedReadLogsResponse = Extract<ReadLogsResponseDto, {mode: 'presigned'}>;\n\nexport interface StepLogSnapshot {\n  records: LogRecord[];\n  nextCursor: number;\n  source: 'inline' | 'presigned';\n  state: 'open' | 'closed' | 'compacted';\n  complete: boolean;\n  hasMore: boolean;\n  truncated: boolean;\n  totalBytes: number | null;\n  expiresAt: string | null;\n}\n\nexport type ResolvedStepLogRead =\n  | {mode: 'inline'; response: InlineReadLogsResponse}\n  | {mode: 'presigned'; response: PresignedReadLogsResponse; ndjson: string};\n\nexport function parseLogNdjson(ndjson: string): LogRecord[] {\n  return ndjson\n    .split(NDJSON_LINE_BREAK)\n    .filter((line) => line.length > 0)\n    .map(parseLogRecordLine);\n}\n\nexport function mergeLogRead(\n  previous: StepLogSnapshot | undefined,\n  read: ResolvedStepLogRead,\n): StepLogSnapshot {\n  if (read.mode === 'presigned') {\n    return {\n      records: parseLogNdjson(read.ndjson),\n      nextCursor: 0,\n      source: 'presigned',\n      state: 'compacted',\n      complete: true,\n      hasMore: false,\n      truncated: read.response.truncated,\n      totalBytes: read.response.total_bytes,\n      expiresAt: read.response.expires_at,\n    };\n  }\n\n  const records = parseLogNdjson(read.response.ndjson);\n  const complete = read.response.state === 'closed' && !read.response.has_more;\n\n  return {\n    records: [...(previous?.records ?? []), ...records],\n    nextCursor: read.response.next_cursor,\n    source: 'inline',\n    state: read.response.state,\n    complete,\n    hasMore: read.response.has_more,\n    truncated: read.response.truncated,\n    totalBytes: null,\n    expiresAt: null,\n  };\n}\n\nexport function stepLogRefetchInterval(\n  snapshot: StepLogSnapshot | undefined,\n  lastFetchErrored = false,\n): number | false {\n  // A persistent failure (deleted step, 5xx, an unparseable record line) never advances\n  // the cursor, so without this guard the interval re-polls the same dead cursor forever.\n  // Stop once a fetch errors out (React Query's own retry absorbs transient blips first);\n  // refetchOnWindowFocus/Reconnect (gated on !complete) resume it.\n  if (lastFetchErrored) return false;\n  if (!snapshot || snapshot.complete) return false;\n  return snapshot.hasMore ? STEP_LOG_DRAIN_REFETCH_MS : STEP_LOG_LIVE_REFETCH_MS;\n}\n"],"names":["parseLogRecordLine","STEP_LOG_DRAIN_REFETCH_MS","STEP_LOG_LIVE_REFETCH_MS","NDJSON_LINE_BREAK","parseLogNdjson","ndjson","split","filter","line","length","map","mergeLogRead","previous","read","mode","records","nextCursor","source","state","complete","hasMore","truncated","response","totalBytes","total_bytes","expiresAt","expires_at","has_more","next_cursor","stepLogRefetchInterval","snapshot","lastFetchErrored"],"mappings":"AAAA,SAAwBA,kBAAkB,QAAiC,wBAAwB;AAEnG,OAAO,MAAMC,4BAA4B,IAAI;AAC7C,OAAO,MAAMC,2BAA2B,MAAM;AAE9C,MAAMC,oBAAoB;AAqB1B,OAAO,SAASC,eAAeC,MAAc;IAC3C,OAAOA,OACJC,KAAK,CAACH,mBACNI,MAAM,CAAC,CAACC,OAASA,KAAKC,MAAM,GAAG,GAC/BC,GAAG,CAACV;AACT;AAEA,OAAO,SAASW,aACdC,QAAqC,EACrCC,IAAyB;IAEzB,IAAIA,KAAKC,IAAI,KAAK,aAAa;QAC7B,OAAO;YACLC,SAASX,eAAeS,KAAKR,MAAM;YACnCW,YAAY;YACZC,QAAQ;YACRC,OAAO;YACPC,UAAU;YACVC,SAAS;YACTC,WAAWR,KAAKS,QAAQ,CAACD,SAAS;YAClCE,YAAYV,KAAKS,QAAQ,CAACE,WAAW;YACrCC,WAAWZ,KAAKS,QAAQ,CAACI,UAAU;QACrC;IACF;IAEA,MAAMX,UAAUX,eAAeS,KAAKS,QAAQ,CAACjB,MAAM;IACnD,MAAMc,WAAWN,KAAKS,QAAQ,CAACJ,KAAK,KAAK,YAAY,CAACL,KAAKS,QAAQ,CAACK,QAAQ;IAE5E,OAAO;QACLZ,SAAS;eAAKH,UAAUG,WAAW,EAAE;eAAMA;SAAQ;QACnDC,YAAYH,KAAKS,QAAQ,CAACM,WAAW;QACrCX,QAAQ;QACRC,OAAOL,KAAKS,QAAQ,CAACJ,KAAK;QAC1BC;QACAC,SAASP,KAAKS,QAAQ,CAACK,QAAQ;QAC/BN,WAAWR,KAAKS,QAAQ,CAACD,SAAS;QAClCE,YAAY;QACZE,WAAW;IACb;AACF;AAEA,OAAO,SAASI,uBACdC,QAAqC,EACrCC,mBAAmB,KAAK;IAExB,sFAAsF;IACtF,wFAAwF;IACxF,wFAAwF;IACxF,iEAAiE;IACjE,IAAIA,kBAAkB,OAAO;IAC7B,IAAI,CAACD,YAAYA,SAASX,QAAQ,EAAE,OAAO;IAC3C,OAAOW,SAASV,OAAO,GAAGnB,4BAA4BC;AACxD"}

package/dist/core/log-tree.d.ts

@@ -0,0 +1,85 @@
+import type { LogRecord } from '@shipfox/api-logs-dto';
+/**
+ * Pure render transform for the step-log read stream. The runner emits a flat,
+ * ordered NDJSON record list; `group_start`/`group_end` form a tree that the
+ * reader reconstructs here before rendering. No React, no state — one function
+ * over the record array.
+ *
+ *   records[] ──▶ buildLogTree ──▶ { nodes (forest), terminated, originTs, lineCount }
+ *
+ * Group closing matches `group_id` (not a blind top-of-stack pop) so a stream that
+ * drops a `group_start` under backlog/gap pressure but still delivers its
+ * `group_end` does not mis-nest everything after it.
+ */
+export type OutputLogRecord = Extract<LogRecord, {
+    type: 'output';
+}>;
+export type GroupStartLogRecord = Extract<LogRecord, {
+    type: 'group_start';
+}>;
+export type EndLogRecord = Extract<LogRecord, {
+    type: 'end';
+}>;
+export type GapLogRecord = Extract<LogRecord, {
+    type: 'gap';
+}>;
+export type CappedLogRecord = Extract<LogRecord, {
+    type: 'capped';
+}>;
+export type RunnerLostLogRecord = Extract<LogRecord, {
+    type: 'runner_lost';
+}>;
+export type AgentSessionLogRecord = Extract<LogRecord, {
+    type: 'agent_session';
+}>;
+export type MarkerLogRecord = EndLogRecord | GapLogRecord | CappedLogRecord | RunnerLostLogRecord;
+/**
+ * Stable, unique render key in creation order. A natural key is not enough: `group_id`
+ * and a marker's `(type, ts)` can both repeat among siblings once a consumer feeds a
+ * concatenated multi-step/retry stream (or two markers land in the same millisecond),
+ * and the append-only build order keeps `seq` stable across re-renders.
+ */
+export interface LogNodeBase {
+    seq: number;
+}
+export interface OutputLogNode extends LogNodeBase {
+    kind: 'output';
+    lineNumber: number;
+    record: OutputLogRecord;
+}
+export interface MarkerLogNode extends LogNodeBase {
+    kind: 'marker';
+    record: MarkerLogRecord;
+}
+export interface GroupLogNode extends LogNodeBase {
+    kind: 'group';
+    record: GroupStartLogRecord;
+    /** False when no matching `group_end` arrived (still streaming, or truncated). */
+    closed: boolean;
+    /** `group_end` timestamp when closed by its matching end, else null. */
+    endTs: number | null;
+    /** Precomputed: subtree contains a `runner_lost` (a genuine failure). `stderr` is a channel, not an error, so it never sets this. */
+    hasError: boolean;
+    /** Precomputed output-line count in the subtree, for the collapsed summary. */
+    lineCount: number;
+    children: LogNode[];
+}
+export interface SessionLogNode extends LogNodeBase {
+    kind: 'session';
+    record: AgentSessionLogRecord;
+}
+export type LogNode = OutputLogNode | MarkerLogNode | GroupLogNode | SessionLogNode;
+export interface LogTree {
+    nodes: LogNode[];
+    /** The stream is closed: the records contain an `end` or a `runner_lost`. */
+    terminated: boolean;
+    /** First record's timestamp; the baseline for relative timestamps. Null when empty. */
+    originTs: number | null;
+    /** Physical output lines (one per `output` record in v1); drives the end banner. */
+    lineCount: number;
+}
+/** Strips a single trailing line ending (CRLF or LF) so a line-framed record renders without a blank continuation. */
+export declare function stripTrailingNewline(data: string): string;
+export declare function assertNever(value: never): never;
+export declare function buildLogTree(records: readonly LogRecord[]): LogTree;
+//# sourceMappingURL=log-tree.d.ts.map

package/dist/core/log-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-tree.d.ts","sourceRoot":"","sources":["../../src/core/log-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,uBAAuB,CAAC;AAErD;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,SAAS,EAAE;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAC,CAAC,CAAC;AACnE,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,SAAS,EAAE;IAAC,IAAI,EAAE,aAAa,CAAA;CAAC,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,EAAE;IAAC,IAAI,EAAE,KAAK,CAAA;CAAC,CAAC,CAAC;AAC7D,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,EAAE;IAAC,IAAI,EAAE,KAAK,CAAA;CAAC,CAAC,CAAC;AAC7D,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,SAAS,EAAE;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAC,CAAC,CAAC;AACnE,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,SAAS,EAAE;IAAC,IAAI,EAAE,aAAa,CAAA;CAAC,CAAC,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,SAAS,EAAE;IAAC,IAAI,EAAE,eAAe,CAAA;CAAC,CAAC,CAAC;AAChF,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,YAAY,GAAG,eAAe,GAAG,mBAAmB,CAAC;AAElG;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAc,SAAQ,WAAW;IAChD,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,eAAe,CAAC;CACzB;AAED,MAAM,WAAW,aAAc,SAAQ,WAAW;IAChD,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,eAAe,CAAC;CACzB;AAED,MAAM,WAAW,YAAa,SAAQ,WAAW;IAC/C,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,mBAAmB,CAAC;IAC5B,kFAAkF;IAClF,MAAM,EAAE,OAAO,CAAC;IAChB,wEAAwE;IACxE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,qIAAqI;IACrI,QAAQ,EAAE,OAAO,CAAC;IAClB,+EAA+E;IAC/E,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,cAAe,SAAQ,WAAW;IACjD,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,qBAAqB,CAAC;CAC/B;AAED,MAAM,MAAM,OAAO,GAAG,aAAa,GAAG,aAAa,GAAG,YAAY,GAAG,cAAc,CAAC;AAEpF,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,6EAA6E;IAC7E,UAAU,EAAE,OAAO,CAAC;IACpB,uFAAuF;IACvF,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,oFAAoF;IACpF,SAAS,EAAE,MAAM,CAAC;CACnB;AAID,sHAAsH;AACtH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAE/C;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAgHnE"}

package/dist/core/log-tree.js

@@ -0,0 +1,139 @@
+const TRAILING_NEWLINE = /\r?\n$/;
+/** Strips a single trailing line ending (CRLF or LF) so a line-framed record renders without a blank continuation. */ export function stripTrailingNewline(data) {
+    return data.replace(TRAILING_NEWLINE, '');
+}
+export function assertNever(value) {
+    throw new Error(`unexpected log record type: ${JSON.stringify(value)}`);
+}
+export function buildLogTree(records) {
+    const nodes = [];
+    const stack = [];
+    let seq = 0;
+    let lineNumber = 0;
+    let lineCount = 0;
+    let terminated = false;
+    let originTs = null;
+    const childrenOf = ()=>stack[stack.length - 1]?.children ?? nodes;
+    // Bubble a failure signal (a runner_lost only) to every currently-open ancestor group
+    // in one pass, so `hasError` is read in O(1) at render time instead of re-walking subtrees.
+    const markOpenGroupsError = ()=>{
+        for (const frame of stack)frame.hasError = true;
+    };
+    for (const record of records){
+        if (originTs === null) originTs = record.ts;
+        switch(record.type){
+            case 'output':
+                {
+                    lineNumber += 1;
+                    lineCount += 1;
+                    for (const frame of stack)frame.lineCount += 1;
+                    childrenOf().push({
+                        kind: 'output',
+                        seq: seq++,
+                        lineNumber,
+                        record
+                    });
+                    break;
+                }
+            case 'group_start':
+                {
+                    // Reconcile the open stack to the declared parent before nesting. `parent_group_id`
+                    // is the runner's stack top at emit time (null at the root), so any reader frame
+                    // below that parent (or every open frame, when the parent is root) is a group whose
+                    // own `group_end` was dropped under backlog pressure. Orphan-close those frames so a
+                    // dropped end never mis-parents the groups that follow. A parent whose own start was
+                    // dropped is not on the stack: it falls through to best-effort root placement.
+                    const parentId = record.parent_group_id;
+                    let parentIndex = -1;
+                    if (parentId !== null) {
+                        for(let i = stack.length - 1; i >= 0; i -= 1){
+                            if (stack[i]?.record.group_id === parentId) {
+                                parentIndex = i;
+                                break;
+                            }
+                        }
+                    }
+                    for(let i = stack.length - 1; i > parentIndex; i -= 1){
+                        const frame = stack[i];
+                        if (frame) frame.closed = true;
+                    }
+                    stack.length = parentIndex + 1;
+                    const group = {
+                        kind: 'group',
+                        seq: seq++,
+                        record,
+                        closed: false,
+                        endTs: null,
+                        hasError: false,
+                        lineCount: 0,
+                        children: []
+                    };
+                    childrenOf().push(group);
+                    stack.push(group);
+                    break;
+                }
+            case 'group_end':
+                {
+                    // Close the matching open group_id; any inner frames orphaned by a dropped
+                    // group_end close with it. An end with no matching open start is ignored.
+                    let matchIndex = -1;
+                    for(let i = stack.length - 1; i >= 0; i -= 1){
+                        if (stack[i]?.record.group_id === record.group_id) {
+                            matchIndex = i;
+                            break;
+                        }
+                    }
+                    if (matchIndex !== -1) {
+                        for(let i = stack.length - 1; i >= matchIndex; i -= 1){
+                            const frame = stack[i];
+                            if (frame) frame.closed = true;
+                        }
+                        const matched = stack[matchIndex];
+                        if (matched) matched.endTs = record.ts;
+                        stack.length = matchIndex;
+                    }
+                    break;
+                }
+            case 'end':
+            case 'gap':
+            case 'capped':
+                {
+                    if (record.type === 'end') terminated = true;
+                    childrenOf().push({
+                        kind: 'marker',
+                        seq: seq++,
+                        record
+                    });
+                    break;
+                }
+            case 'runner_lost':
+                {
+                    terminated = true;
+                    childrenOf().push({
+                        kind: 'marker',
+                        seq: seq++,
+                        record
+                    });
+                    markOpenGroupsError();
+                    break;
+                }
+            case 'agent_session':
+                childrenOf().push({
+                    kind: 'session',
+                    seq: seq++,
+                    record
+                });
+                break;
+            default:
+                assertNever(record);
+        }
+    }
+    return {
+        nodes,
+        terminated,
+        originTs,
+        lineCount
+    };
+}
+
+//# sourceMappingURL=log-tree.js.map

package/dist/core/log-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/log-tree.ts"],"sourcesContent":["import type {LogRecord} from '@shipfox/api-logs-dto';\n\n/**\n * Pure render transform for the step-log read stream. The runner emits a flat,\n * ordered NDJSON record list; `group_start`/`group_end` form a tree that the\n * reader reconstructs here before rendering. No React, no state — one function\n * over the record array.\n *\n *   records[] ──▶ buildLogTree ──▶ { nodes (forest), terminated, originTs, lineCount }\n *\n * Group closing matches `group_id` (not a blind top-of-stack pop) so a stream that\n * drops a `group_start` under backlog/gap pressure but still delivers its\n * `group_end` does not mis-nest everything after it.\n */\n\nexport type OutputLogRecord = Extract<LogRecord, {type: 'output'}>;\nexport type GroupStartLogRecord = Extract<LogRecord, {type: 'group_start'}>;\nexport type EndLogRecord = Extract<LogRecord, {type: 'end'}>;\nexport type GapLogRecord = Extract<LogRecord, {type: 'gap'}>;\nexport type CappedLogRecord = Extract<LogRecord, {type: 'capped'}>;\nexport type RunnerLostLogRecord = Extract<LogRecord, {type: 'runner_lost'}>;\nexport type AgentSessionLogRecord = Extract<LogRecord, {type: 'agent_session'}>;\nexport type MarkerLogRecord = EndLogRecord | GapLogRecord | CappedLogRecord | RunnerLostLogRecord;\n\n/**\n * Stable, unique render key in creation order. A natural key is not enough: `group_id`\n * and a marker's `(type, ts)` can both repeat among siblings once a consumer feeds a\n * concatenated multi-step/retry stream (or two markers land in the same millisecond),\n * and the append-only build order keeps `seq` stable across re-renders.\n */\nexport interface LogNodeBase {\n  seq: number;\n}\n\nexport interface OutputLogNode extends LogNodeBase {\n  kind: 'output';\n  lineNumber: number;\n  record: OutputLogRecord;\n}\n\nexport interface MarkerLogNode extends LogNodeBase {\n  kind: 'marker';\n  record: MarkerLogRecord;\n}\n\nexport interface GroupLogNode extends LogNodeBase {\n  kind: 'group';\n  record: GroupStartLogRecord;\n  /** False when no matching `group_end` arrived (still streaming, or truncated). */\n  closed: boolean;\n  /** `group_end` timestamp when closed by its matching end, else null. */\n  endTs: number | null;\n  /** Precomputed: subtree contains a `runner_lost` (a genuine failure). `stderr` is a channel, not an error, so it never sets this. */\n  hasError: boolean;\n  /** Precomputed output-line count in the subtree, for the collapsed summary. */\n  lineCount: number;\n  children: LogNode[];\n}\n\nexport interface SessionLogNode extends LogNodeBase {\n  kind: 'session';\n  record: AgentSessionLogRecord;\n}\n\nexport type LogNode = OutputLogNode | MarkerLogNode | GroupLogNode | SessionLogNode;\n\nexport interface LogTree {\n  nodes: LogNode[];\n  /** The stream is closed: the records contain an `end` or a `runner_lost`. */\n  terminated: boolean;\n  /** First record's timestamp; the baseline for relative timestamps. Null when empty. */\n  originTs: number | null;\n  /** Physical output lines (one per `output` record in v1); drives the end banner. */\n  lineCount: number;\n}\n\nconst TRAILING_NEWLINE = /\\r?\\n$/;\n\n/** Strips a single trailing line ending (CRLF or LF) so a line-framed record renders without a blank continuation. */\nexport function stripTrailingNewline(data: string): string {\n  return data.replace(TRAILING_NEWLINE, '');\n}\n\nexport function assertNever(value: never): never {\n  throw new Error(`unexpected log record type: ${JSON.stringify(value)}`);\n}\n\nexport function buildLogTree(records: readonly LogRecord[]): LogTree {\n  const nodes: LogNode[] = [];\n  const stack: GroupLogNode[] = [];\n  let seq = 0;\n  let lineNumber = 0;\n  let lineCount = 0;\n  let terminated = false;\n  let originTs: number | null = null;\n\n  const childrenOf = (): LogNode[] => stack[stack.length - 1]?.children ?? nodes;\n\n  // Bubble a failure signal (a runner_lost only) to every currently-open ancestor group\n  // in one pass, so `hasError` is read in O(1) at render time instead of re-walking subtrees.\n  const markOpenGroupsError = (): void => {\n    for (const frame of stack) frame.hasError = true;\n  };\n\n  for (const record of records) {\n    if (originTs === null) originTs = record.ts;\n    switch (record.type) {\n      case 'output': {\n        lineNumber += 1;\n        lineCount += 1;\n        for (const frame of stack) frame.lineCount += 1;\n        childrenOf().push({kind: 'output', seq: seq++, lineNumber, record});\n        break;\n      }\n      case 'group_start': {\n        // Reconcile the open stack to the declared parent before nesting. `parent_group_id`\n        // is the runner's stack top at emit time (null at the root), so any reader frame\n        // below that parent (or every open frame, when the parent is root) is a group whose\n        // own `group_end` was dropped under backlog pressure. Orphan-close those frames so a\n        // dropped end never mis-parents the groups that follow. A parent whose own start was\n        // dropped is not on the stack: it falls through to best-effort root placement.\n        const parentId = record.parent_group_id;\n        let parentIndex = -1;\n        if (parentId !== null) {\n          for (let i = stack.length - 1; i >= 0; i -= 1) {\n            if (stack[i]?.record.group_id === parentId) {\n              parentIndex = i;\n              break;\n            }\n          }\n        }\n        for (let i = stack.length - 1; i > parentIndex; i -= 1) {\n          const frame = stack[i];\n          if (frame) frame.closed = true;\n        }\n        stack.length = parentIndex + 1;\n\n        const group: GroupLogNode = {\n          kind: 'group',\n          seq: seq++,\n          record,\n          closed: false,\n          endTs: null,\n          hasError: false,\n          lineCount: 0,\n          children: [],\n        };\n        childrenOf().push(group);\n        stack.push(group);\n        break;\n      }\n      case 'group_end': {\n        // Close the matching open group_id; any inner frames orphaned by a dropped\n        // group_end close with it. An end with no matching open start is ignored.\n        let matchIndex = -1;\n        for (let i = stack.length - 1; i >= 0; i -= 1) {\n          if (stack[i]?.record.group_id === record.group_id) {\n            matchIndex = i;\n            break;\n          }\n        }\n        if (matchIndex !== -1) {\n          for (let i = stack.length - 1; i >= matchIndex; i -= 1) {\n            const frame = stack[i];\n            if (frame) frame.closed = true;\n          }\n          const matched = stack[matchIndex];\n          if (matched) matched.endTs = record.ts;\n          stack.length = matchIndex;\n        }\n        break;\n      }\n      case 'end':\n      case 'gap':\n      case 'capped': {\n        if (record.type === 'end') terminated = true;\n        childrenOf().push({kind: 'marker', seq: seq++, record});\n        break;\n      }\n      case 'runner_lost': {\n        terminated = true;\n        childrenOf().push({kind: 'marker', seq: seq++, record});\n        markOpenGroupsError();\n        break;\n      }\n      case 'agent_session':\n        childrenOf().push({kind: 'session', seq: seq++, record});\n        break;\n      default:\n        assertNever(record);\n    }\n  }\n\n  return {\n    nodes,\n    terminated,\n    originTs,\n    lineCount,\n  };\n}\n"],"names":["TRAILING_NEWLINE","stripTrailingNewline","data","replace","assertNever","value","Error","JSON","stringify","buildLogTree","records","nodes","stack","seq","lineNumber","lineCount","terminated","originTs","childrenOf","length","children","markOpenGroupsError","frame","hasError","record","ts","type","push","kind","parentId","parent_group_id","parentIndex","i","group_id","closed","group","endTs","matchIndex","matched"],"mappings":"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"}

package/dist/env.d.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=env.d.js.map

package/dist/env.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/env.d.ts"],"names":[],"mappings":""}

package/dist/hooks/api/step-logs.d.ts

@@ -0,0 +1,24 @@
+import type { ReadLogsResponseDto } from '@shipfox/api-logs-dto';
+import { type StepLogSnapshot } from '#core/log-read.js';
+export declare const stepLogsQueryKeys: {
+    all: readonly ["step-logs"];
+    detail: (stepId: string, attempt: number) => readonly ["step-logs", "detail", string, number];
+};
+interface ReadStepAttemptLogsPageParams {
+    stepId: string;
+    attempt: number;
+    cursor: number;
+    signal?: AbortSignal;
+}
+export declare function readStepAttemptLogsPage({ stepId, attempt, cursor, signal, }: ReadStepAttemptLogsPageParams): Promise<ReadLogsResponseDto>;
+export declare function isMissingStepLogStreamError(error: unknown): boolean;
+export interface UseStepAttemptLogsQueryOptions {
+    retryMissingStream?: boolean;
+    missingStreamRetryCount?: number | undefined;
+    missingStreamRetryDelayMs?: number | undefined;
+    initialErrorRetryCount?: number;
+    initialErrorRetryDelayMs?: number;
+}
+export declare function useStepAttemptLogsQuery(stepId: string | undefined, attempt: number | undefined, options?: UseStepAttemptLogsQueryOptions): import("@tanstack/react-query").UseQueryResult<NoInfer<StepLogSnapshot>, Error>;
+export {};
+//# sourceMappingURL=step-logs.d.ts.map

package/dist/hooks/api/step-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-logs.d.ts","sourceRoot":"","sources":["../../../src/hooks/api/step-logs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAI/D,OAAO,EAGL,KAAK,eAAe,EAErB,MAAM,mBAAmB,CAAC;AAE3B,eAAO,MAAM,iBAAiB;;qBAEX,MAAM,WAAW,MAAM;CAEzC,CAAC;AAEF,UAAU,6BAA6B;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,wBAAsB,uBAAuB,CAAC,EAC5C,MAAM,EACN,OAAO,EACP,MAAM,EACN,MAAM,GACP,EAAE,6BAA6B,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAM9D;AAkBD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEnE;AAED,MAAM,WAAW,8BAA8B;IAC7C,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,uBAAuB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,yBAAyB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,GAAE,8BAAmC,mFAmF7C"}

package/dist/hooks/api/step-logs.js

@@ -0,0 +1,129 @@
+import { ApiError, apiRequest } from '@shipfox/client-api';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { useRef } from 'react';
+import { mergeLogRead, STEP_LOG_LIVE_REFETCH_MS, stepLogRefetchInterval } from '#core/log-read.js';
+export const stepLogsQueryKeys = {
+    all: [
+        'step-logs'
+    ],
+    detail: (stepId, attempt)=>[
+            ...stepLogsQueryKeys.all,
+            'detail',
+            stepId,
+            attempt
+        ]
+};
+export async function readStepAttemptLogsPage({ stepId, attempt, cursor, signal }) {
+    const params = new URLSearchParams({
+        cursor: String(cursor)
+    });
+    return await apiRequest(`/steps/${encodeURIComponent(stepId)}/attempts/${attempt}/logs?${params.toString()}`, {
+        signal
+    });
+}
+let StepLogObjectFetchError = class StepLogObjectFetchError extends Error {
+    constructor(status){
+        super(`Could not load compacted logs (${status})`);
+        this.name = 'StepLogObjectFetchError';
+        this.status = status;
+    }
+};
+async function readPresignedLogObject(url, signal) {
+    const response = await fetch(url, signal ? {
+        signal
+    } : undefined);
+    if (!response.ok) throw new StepLogObjectFetchError(response.status);
+    return await response.text();
+}
+export function isMissingStepLogStreamError(error) {
+    return error instanceof ApiError && error.status === 404 && error.code === 'not-found';
+}
+export function useStepAttemptLogsQuery(stepId, attempt, options = {}) {
+    const queryClient = useQueryClient();
+    const missingStreamFailureCountRef = useRef(0);
+    const missingStreamScopeRef = useRef(null);
+    const enabled = Boolean(stepId && attempt && Number.isInteger(attempt) && attempt > 0);
+    const queryKey = enabled && stepId && attempt ? stepLogsQueryKeys.detail(stepId, attempt) : [
+        ...stepLogsQueryKeys.all,
+        'detail'
+    ];
+    const missingStreamScope = enabled && stepId && attempt ? `${stepId}:${attempt}:${options.missingStreamRetryCount ?? 'unbounded'}` : null;
+    if (missingStreamScopeRef.current !== missingStreamScope) {
+        missingStreamScopeRef.current = missingStreamScope;
+        missingStreamFailureCountRef.current = 0;
+    }
+    const initialErrorRetryCount = options.initialErrorRetryCount ?? 0;
+    const initialErrorRetryDelayMs = options.initialErrorRetryDelayMs ?? STEP_LOG_LIVE_REFETCH_MS;
+    const missingStreamRetryDelayMs = options.missingStreamRetryDelayMs ?? STEP_LOG_LIVE_REFETCH_MS;
+    return useQuery({
+        queryKey,
+        enabled,
+        queryFn: async ({ signal })=>{
+            const previous = queryClient.getQueryData(queryKey);
+            let response;
+            try {
+                response = await readStepAttemptLogsPage({
+                    stepId: stepId ?? '',
+                    attempt: attempt ?? 0,
+                    cursor: previous?.nextCursor ?? 0,
+                    signal
+                });
+            } catch (error) {
+                if (options.retryMissingStream && previous === undefined && isMissingStepLogStreamError(error)) {
+                    const retryCount = options.missingStreamRetryCount;
+                    if (retryCount === undefined) throw error;
+                    if (missingStreamFailureCountRef.current >= retryCount) {
+                        return emptyCompleteLogSnapshot();
+                    }
+                    missingStreamFailureCountRef.current += 1;
+                }
+                throw error;
+            }
+            missingStreamFailureCountRef.current = 0;
+            if (response.mode === 'presigned') {
+                const ndjson = await readPresignedLogObject(response.url, signal);
+                return mergeLogRead(previous, {
+                    mode: 'presigned',
+                    response,
+                    ndjson
+                });
+            }
+            return mergeLogRead(previous, {
+                mode: 'inline',
+                response
+            });
+        },
+        retry: (failureCount, error)=>{
+            if (initialErrorRetryCount <= 0) return false;
+            if (queryClient.getQueryData(queryKey) !== undefined) return false;
+            if (options.retryMissingStream && isMissingStepLogStreamError(error)) return false;
+            return failureCount < initialErrorRetryCount;
+        },
+        retryDelay: initialErrorRetryDelayMs,
+        refetchInterval: (query)=>{
+            if (options.retryMissingStream && query.state.data === undefined && isMissingStepLogStreamError(query.state.error)) {
+                return missingStreamRetryDelayMs;
+            }
+            return stepLogRefetchInterval(query.state.data, query.state.status === 'error');
+        },
+        refetchIntervalInBackground: false,
+        refetchOnMount: (query)=>!query.state.data?.complete,
+        refetchOnWindowFocus: (query)=>!query.state.data?.complete,
+        refetchOnReconnect: (query)=>!query.state.data?.complete
+    });
+}
+function emptyCompleteLogSnapshot() {
+    return {
+        records: [],
+        nextCursor: 0,
+        source: 'inline',
+        state: 'closed',
+        complete: true,
+        hasMore: false,
+        truncated: false,
+        totalBytes: null,
+        expiresAt: null
+    };
+}
+
+//# sourceMappingURL=step-logs.js.map