@secondlayer/shared 13.3.0 → 13.5.0

package/dist/src/index.js

@@ -854,6 +854,7 @@ var TABLE_TO_DB = {
   subgraph_health_snapshots: "target",
   subgraph_gaps: "target",
   subgraph_violations: "target",
+  subgraph_error_groups: "target",
   subgraph_processing_stats: "target",
   account_credits: "target",
   archive_fetches: "target",
@@ -865,6 +866,8 @@ var TABLE_TO_DB = {
   contact_requests: "target",
   api_failed_requests: "target",
   api_request_log: "target",
+  insights: "target",
+  insight_mutes: "target",
   feedback_tickets: "target",
   service_heartbeats: "both"
 };
@@ -1255,8 +1258,94 @@ var BILLING_PAUSED_PREFIX = "billing_paused: ";
 function billingPausedCode(lastError) {
   return lastError?.startsWith(BILLING_PAUSED_PREFIX) ? lastError.slice(BILLING_PAUSED_PREFIX.length) : null;
 }
-// src/schemas/webhooks.ts
+// src/schemas/insights.ts
 import { z as z3 } from "zod";
+var INSIGHT_SEVERITIES = [
+  "losing",
+  "will_fail",
+  "costs",
+  "recovered"
+];
+var InsightSeveritySchema = z3.enum(INSIGHT_SEVERITIES);
+var InsightResourceKindSchema = z3.enum(["webhook", "subgraph", "account"]);
+var InsightEvidenceSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("series"),
+    title: z3.string(),
+    series: z3.array(z3.object({
+      name: z3.string(),
+      role: z3.enum(["a", "context", "mark"]),
+      points: z3.array(z3.number())
+    })),
+    labels: z3.array(z3.tuple([z3.number(), z3.string()])),
+    unit: z3.string().optional()
+  }),
+  z3.object({
+    kind: z3.literal("table"),
+    title: z3.string(),
+    columns: z3.array(z3.string()),
+    rows: z3.array(z3.array(z3.union([z3.string(), z3.number()]))),
+    markRow: z3.number().optional()
+  }),
+  z3.object({
+    kind: z3.literal("shapes"),
+    title: z3.string(),
+    shapes: z3.array(z3.object({
+      code: z3.string(),
+      body: z3.string(),
+      count: z3.number(),
+      isNew: z3.boolean()
+    }))
+  }),
+  z3.object({
+    kind: z3.literal("timeline"),
+    title: z3.string(),
+    steps: z3.array(z3.object({
+      what: z3.string(),
+      at: z3.string(),
+      note: z3.string().optional(),
+      failed: z3.boolean()
+    }))
+  })
+]);
+var InsightSchema = z3.object({
+  id: z3.string(),
+  rule: z3.string(),
+  severity: InsightSeveritySchema,
+  impact: z3.number(),
+  resource: z3.object({
+    kind: InsightResourceKindSchema,
+    id: z3.string(),
+    name: z3.string()
+  }),
+  line: z3.string(),
+  meta: z3.string().optional(),
+  lead: z3.string(),
+  body: z3.string(),
+  evidence: z3.array(InsightEvidenceSchema),
+  handoff: z3.object({
+    prompt: z3.string(),
+    commands: z3.array(z3.string())
+  }),
+  how: z3.object({
+    detector: z3.string(),
+    facts: z3.array(z3.tuple([z3.string(), z3.string()])),
+    label: z3.object({ cause: z3.string(), confidence: z3.number() }).optional()
+  }),
+  createdAt: z3.string(),
+  resolvedAt: z3.string().nullable().optional()
+});
+var InsightListResponseSchema = z3.object({
+  data: z3.array(InsightSchema)
+});
+var SEVERITY_ORDER = {
+  losing: 0,
+  will_fail: 1,
+  costs: 2,
+  recovered: 3
+};
+// src/schemas/webhooks.ts
+import { z as z4 } from "zod";
 var WEBHOOK_FORMATS = [
   "standard-webhooks",
   "inngest",
@@ -1282,7 +1371,7 @@ function webhookTimeoutMsCeiling() {
   return ceilingFromEnv("WEBHOOK_TIMEOUT_MS_CEILING", WEBHOOK_TIMEOUT_MS_CEILING_DEFAULT);
 }
 function maxRetriesField() {
-  return z3.number().int().min(0).optional().superRefine((v, ctx) => {
+  return z4.number().int().min(0).optional().superRefine((v, ctx) => {
     if (v === undefined)
       return;
     const ceiling = webhookMaxRetriesCeiling();
@@ -1295,7 +1384,7 @@ function maxRetriesField() {
   });
 }
 function timeoutMsField() {
-  return z3.number().int().min(100).optional().superRefine((v, ctx) => {
+  return z4.number().int().min(100).optional().superRefine((v, ctx) => {
     if (v === undefined)
       return;
     const ceiling = webhookTimeoutMsCeiling();
@@ -1307,8 +1396,8 @@ function timeoutMsField() {
     }
   });
 }
-var webhookUrl = z3.string().trim().min(1).refine((value) => value.startsWith("http://") || value.startsWith("https://"), "must be an http(s) URL");
-var name = z3.string().trim().min(1).max(128);
+var webhookUrl = z4.string().trim().min(1).refine((value) => value.startsWith("http://") || value.startsWith("https://"), "must be an http(s) URL");
+var name = z4.string().trim().min(1).max(128);
 var MANAGED_NAME_PREFIXES = {
   "sentinel:": "Sentinel"
 };
@@ -1319,8 +1408,8 @@ function managedByForName(name) {
   }
   return null;
 }
-var WebhookStatusSchema = z3.enum(WEBHOOK_STATUSES);
-var WebhookFormatSchema = z3.enum(WEBHOOK_FORMATS);
+var WebhookStatusSchema = z4.enum(WEBHOOK_STATUSES);
+var WebhookFormatSchema = z4.enum(WEBHOOK_FORMATS);
 var CHAIN_TRIGGER_TYPES = [
   "stx_transfer",
   "stx_mint",
@@ -1350,212 +1439,212 @@ var CHAIN_TRIGGER_TYPES = [
   "rune_transfer",
   "rune_burn"
 ];
-var runeRef = z3.string().trim().min(1);
-var triggerAmount = z3.union([
-  z3.string().trim().regex(/^\d+$/, "must be a non-negative integer string"),
-  z3.number().int().nonnegative()
+var runeRef = z4.string().trim().min(1);
+var triggerAmount = z4.union([
+  z4.string().trim().regex(/^\d+$/, "must be a non-negative integer string"),
+  z4.number().int().nonnegative()
 ]);
-var triggerPattern = z3.string().trim().min(1);
-var trait = z3.string().trim().min(1);
-var printWhereValue = z3.string().min(1).max(256);
-var PrintWhereSchema = z3.record(z3.string().trim().min(1).max(64), z3.union([printWhereValue, z3.array(printWhereValue).min(1).max(20)])).refine((o) => {
+var triggerPattern = z4.string().trim().min(1);
+var trait = z4.string().trim().min(1);
+var printWhereValue = z4.string().min(1).max(256);
+var PrintWhereSchema = z4.record(z4.string().trim().min(1).max(64), z4.union([printWhereValue, z4.array(printWhereValue).min(1).max(20)])).refine((o) => {
   const n = Object.keys(o).length;
   return n >= 1 && n <= 10;
 }, "where takes 1 to 10 keys");
-var ChainTriggerSchema = z3.discriminatedUnion("type", [
-  z3.object({
-    type: z3.literal("stx_transfer"),
+var ChainTriggerSchema = z4.discriminatedUnion("type", [
+  z4.object({
+    type: z4.literal("stx_transfer"),
     sender: triggerPattern.optional(),
     recipient: triggerPattern.optional(),
     minAmount: triggerAmount.optional(),
     maxAmount: triggerAmount.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("stx_mint"),
+  z4.object({
+    type: z4.literal("stx_mint"),
     recipient: triggerPattern.optional(),
     minAmount: triggerAmount.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("stx_burn"),
+  z4.object({
+    type: z4.literal("stx_burn"),
     sender: triggerPattern.optional(),
     minAmount: triggerAmount.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("stx_lock"),
+  z4.object({
+    type: z4.literal("stx_lock"),
     lockedAddress: triggerPattern.optional(),
     minAmount: triggerAmount.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("ft_transfer"),
+  z4.object({
+    type: z4.literal("ft_transfer"),
     assetIdentifier: triggerPattern.optional(),
     sender: triggerPattern.optional(),
     recipient: triggerPattern.optional(),
     minAmount: triggerAmount.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("ft_mint"),
+  z4.object({
+    type: z4.literal("ft_mint"),
     assetIdentifier: triggerPattern.optional(),
     recipient: triggerPattern.optional(),
     minAmount: triggerAmount.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("ft_burn"),
+  z4.object({
+    type: z4.literal("ft_burn"),
     assetIdentifier: triggerPattern.optional(),
     sender: triggerPattern.optional(),
     minAmount: triggerAmount.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("nft_transfer"),
+  z4.object({
+    type: z4.literal("nft_transfer"),
     assetIdentifier: triggerPattern.optional(),
     sender: triggerPattern.optional(),
     recipient: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("nft_mint"),
+  z4.object({
+    type: z4.literal("nft_mint"),
     assetIdentifier: triggerPattern.optional(),
     recipient: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("nft_burn"),
+  z4.object({
+    type: z4.literal("nft_burn"),
     assetIdentifier: triggerPattern.optional(),
     sender: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("contract_call"),
+  z4.object({
+    type: z4.literal("contract_call"),
     contractId: triggerPattern.optional(),
     functionName: triggerPattern.optional(),
     caller: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("contract_deploy"),
+  z4.object({
+    type: z4.literal("contract_deploy"),
     deployer: triggerPattern.optional(),
     contractName: triggerPattern.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("print_event"),
+  z4.object({
+    type: z4.literal("print_event"),
     contractId: triggerPattern.optional(),
     topic: triggerPattern.optional(),
     trait: trait.optional(),
     where: PrintWhereSchema.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("nested_contract_call"),
+  z4.object({
+    type: z4.literal("nested_contract_call"),
     contractId: triggerPattern.optional(),
     functionName: triggerPattern.optional(),
     caller: triggerPattern.optional(),
     sender: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("var_set"),
+  z4.object({
+    type: z4.literal("var_set"),
     contractId: triggerPattern.optional(),
     varName: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("map_set"),
+  z4.object({
+    type: z4.literal("map_set"),
     contractId: triggerPattern.optional(),
     map: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("map_insert"),
+  z4.object({
+    type: z4.literal("map_insert"),
     contractId: triggerPattern.optional(),
     map: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("map_delete"),
+  z4.object({
+    type: z4.literal("map_delete"),
     contractId: triggerPattern.optional(),
     map: triggerPattern.optional(),
     trait: trait.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("sbtc_deposit"),
+  z4.object({
+    type: z4.literal("sbtc_deposit"),
     sender: triggerPattern.optional(),
     minAmount: triggerAmount.optional(),
     maxAmount: triggerAmount.optional(),
     bitcoinTxid: triggerPattern.optional(),
-    requestId: z3.number().int().nonnegative().optional()
+    requestId: z4.number().int().nonnegative().optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("sbtc_withdrawal_create"),
+  z4.object({
+    type: z4.literal("sbtc_withdrawal_create"),
     sender: triggerPattern.optional(),
     minAmount: triggerAmount.optional(),
     maxAmount: triggerAmount.optional(),
-    requestId: z3.number().int().nonnegative().optional()
+    requestId: z4.number().int().nonnegative().optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("sbtc_withdrawal_accept"),
-    requestId: z3.number().int().nonnegative().optional(),
+  z4.object({
+    type: z4.literal("sbtc_withdrawal_accept"),
+    requestId: z4.number().int().nonnegative().optional(),
     sweepTxid: triggerPattern.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("sbtc_withdrawal_reject"),
-    requestId: z3.number().int().nonnegative().optional()
+  z4.object({
+    type: z4.literal("sbtc_withdrawal_reject"),
+    requestId: z4.number().int().nonnegative().optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("sbtc_withdrawal_swept_confirmed"),
-    requestId: z3.number().int().nonnegative().optional(),
+  z4.object({
+    type: z4.literal("sbtc_withdrawal_swept_confirmed"),
+    requestId: z4.number().int().nonnegative().optional(),
     sweepTxid: triggerPattern.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("rune_etch"),
+  z4.object({
+    type: z4.literal("rune_etch"),
     rune: runeRef.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("rune_mint"),
+  z4.object({
+    type: z4.literal("rune_mint"),
     rune: runeRef.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("rune_transfer"),
+  z4.object({
+    type: z4.literal("rune_transfer"),
     rune: runeRef.optional(),
     address: triggerPattern.optional(),
     minAmount: triggerAmount.optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("rune_burn"),
+  z4.object({
+    type: z4.literal("rune_burn"),
     rune: runeRef.optional()
   }).strict()
 ]);
-var ChainTriggersSchema = z3.array(ChainTriggerSchema).min(1).max(50);
+var ChainTriggersSchema = z4.array(ChainTriggerSchema).min(1).max(50);
 var CHAIN_TRIGGER_FIELDS = Object.fromEntries(ChainTriggerSchema._zod.def.options.map((opt) => {
   const shape = opt._zod.def.shape;
   const type = shape.type._zod.def.values[0];
   return [type, Object.keys(shape).filter((k) => k !== "type")];
 }));
-var CreateWebhookRequestSchema = z3.object({
+var CreateWebhookRequestSchema = z4.object({
   name,
   triggers: ChainTriggersSchema,
   url: webhookUrl,
   format: WebhookFormatSchema.default("standard-webhooks"),
-  authConfig: z3.record(z3.string(), z3.unknown()).optional(),
+  authConfig: z4.record(z4.string(), z4.unknown()).optional(),
   maxRetries: maxRetriesField(),
   timeoutMs: timeoutMsField(),
-  concurrency: z3.number().int().min(1).max(100).optional()
+  concurrency: z4.number().int().min(1).max(100).optional()
 });
-var UpdateWebhookRequestSchema = z3.object({
+var UpdateWebhookRequestSchema = z4.object({
   name: name.optional(),
   url: webhookUrl.optional(),
   format: WebhookFormatSchema.optional(),
-  authConfig: z3.record(z3.string(), z3.unknown()).optional(),
+  authConfig: z4.record(z4.string(), z4.unknown()).optional(),
   maxRetries: maxRetriesField(),
   timeoutMs: timeoutMsField(),
-  concurrency: z3.number().int().min(1).max(100).optional()
+  concurrency: z4.number().int().min(1).max(100).optional()
 }).refine((value) => Object.keys(value).length > 0, {
   message: "At least one field must be provided"
 });
-var ReplayWebhookRequestSchema = z3.object({
-  fromBlock: z3.number().int().nonnegative(),
-  toBlock: z3.number().int().nonnegative(),
-  force: z3.string().trim().min(1).max(64).optional()
+var ReplayWebhookRequestSchema = z4.object({
+  fromBlock: z4.number().int().nonnegative(),
+  toBlock: z4.number().int().nonnegative(),
+  force: z4.string().trim().min(1).max(64).optional()
 }).refine((value) => value.fromBlock <= value.toBlock, {
   message: "fromBlock must be less than or equal to toBlock",
   path: ["toBlock"]
@@ -1997,6 +2086,61 @@ function generateSubgraphSpec(detail, format, options = {}) {
     return generateSubgraphAgentSchema(detail, options);
   return generateSubgraphMarkdown(detail, options);
 }
+// src/subgraphs/health.ts
+var HOUR_MS = 3600000;
+function positiveDeltas(values) {
+  let total = 0;
+  let prev = null;
+  for (const value of values) {
+    if (value === null)
+      continue;
+    if (prev !== null && value > prev)
+      total += value - prev;
+    prev = value;
+  }
+  return total;
+}
+function toNumber(value) {
+  if (value === null)
+    return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function bucketHourly(snapshots, hours, now = Date.now()) {
+  const sorted = snapshots.map((s) => ({ ...s, at: new Date(s.captured_at).getTime() })).sort((a, b) => a.at - b.at);
+  const currentHourStart = Math.floor(now / HOUR_MS) * HOUR_MS;
+  const out = [];
+  for (let i = hours - 1;i >= 0; i--) {
+    const start = currentHourStart - i * HOUR_MS;
+    const end = start + HOUR_MS;
+    const inHour = sorted.filter((s) => s.at >= start && s.at < end);
+    if (inHour.length === 0) {
+      out.push({
+        hour: new Date(start).toISOString(),
+        lagBlocks: null,
+        rowsWritten: 0,
+        errors: 0,
+        eventsHandled: 0
+      });
+      continue;
+    }
+    const before = sorted.filter((s) => s.at < start).at(-1);
+    const series = before ? [before, ...inHour] : inHour;
+    const lags = inHour.map((s) => {
+      const tip = toNumber(s.chain_tip);
+      const cursor = toNumber(s.last_processed_block);
+      return tip === null || cursor === null ? null : Math.max(0, tip - cursor);
+    }).filter((lag) => lag !== null);
+    out.push({
+      hour: new Date(start).toISOString(),
+      lagBlocks: lags.length > 0 ? Math.max(...lags) : null,
+      rowsWritten: positiveDeltas(series.map((s) => toNumber(s.rows_written_total))),
+      errors: positiveDeltas(series.map((s) => toNumber(s.total_errors))),
+      eventsHandled: positiveDeltas(series.map((s) => toNumber(s.total_processed)))
+    });
+  }
+  return out;
+}
 // src/crypto/hmac.ts
 var exports_hmac = {};
 __export(exports_hmac, {
@@ -2118,12 +2262,19 @@ export {
   EMPTY_RANGE_EVENT_INDEX_SENTINEL,
   ErrorCodes,
   ForbiddenError,
+  INSIGHT_SEVERITIES,
+  InsightEvidenceSchema,
+  InsightListResponseSchema,
+  InsightResourceKindSchema,
+  InsightSchema,
+  InsightSeveritySchema,
   KeyRotatedError,
   NotFoundError,
   PaymentRequiredError,
   RUNE_EVENT_TYPES,
   RateLimitError,
   ReplayWebhookRequestSchema,
+  SEVERITY_ORDER,
   SOURCE_READ_COLUMNS,
   SOURCE_READ_PKS,
   SOURCE_READ_TYPES,
@@ -2147,6 +2298,7 @@ export {
   assertDbSplit,
   billingPausedCode,
   blockEndCursor,
+  bucketHourly,
   closeDb,
   closeDbOrTimeout,
   committedHeight,
@@ -2186,5 +2338,5 @@ export {
   sql2 as sql
 };
 
-//# debugId=4CA800A5189D0B1364756E2164756E21
+//# debugId=D95357BE1793CC7464756E2164756E21
 //# sourceMappingURL=index.js.map