@pagebridge/core 0.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+[?9001h[?1004h[?25l> @pagebridge/core@0.0.1 build F:\Code\pagebridge\oss\packages\core
+> tsc]0;C:\WINDOWS\system32\cmd.exe[?25h[?9001l[?1004l

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soma Somorjai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,241 @@
+# @pagebridge/core
+
+Core business logic for syncing Google Search Console data to Sanity CMS, detecting content decay patterns, and generating refresh tasks.
+
+## Installation
+
+```bash
+pnpm add @pagebridge/core
+```
+
+## Overview
+
+This package provides the main building blocks for content performance tracking:
+
+- **GSCClient** - Fetches search analytics from Google Search Console API
+- **SyncEngine** - Orchestrates data sync between GSC, PostgreSQL, and Sanity
+- **DecayDetector** - Analyzes metrics to identify content decay patterns
+- **URLMatcher** - Maps GSC URLs to Sanity documents by slug
+- **TaskGenerator** - Creates refresh tasks in Sanity for decaying content
+
+## Usage
+
+### GSCClient
+
+Authenticates with Google and fetches search analytics data.
+
+```typescript
+import { GSCClient } from '@pagebridge/core';
+
+const client = new GSCClient({
+  serviceAccountJson: process.env.GOOGLE_SERVICE_ACCOUNT,
+});
+
+// List available sites
+const sites = await client.listSites();
+
+// Fetch search analytics
+const data = await client.fetchSearchAnalytics({
+  siteUrl: 'sc-domain:example.com',
+  startDate: '2024-01-01',
+  endDate: '2024-01-31',
+  dimensions: ['page', 'query'],
+});
+
+// Check URL index status
+const status = await client.inspectUrl({
+  siteUrl: 'sc-domain:example.com',
+  inspectionUrl: 'https://example.com/blog/post',
+});
+```
+
+### SyncEngine
+
+Coordinates the full sync workflow: fetching data, storing metrics, and writing Sanity snapshots.
+
+```typescript
+import { SyncEngine } from '@pagebridge/core';
+import { createDb } from '@pagebridge/db';
+import { createClient } from '@sanity/client';
+
+const db = createDb(process.env.DATABASE_URL);
+const sanityClient = createClient({
+  projectId: 'your-project',
+  dataset: 'production',
+  token: process.env.SANITY_TOKEN,
+  apiVersion: '2024-01-01',
+  useCdn: false,
+});
+
+const engine = new SyncEngine({
+  gscClient,
+  db,
+  sanityClient,
+});
+
+const result = await engine.sync({
+  siteUrl: 'sc-domain:example.com',
+  siteId: 'sanity-site-document-id',
+  dryRun: false,
+});
+```
+
+### DecayDetector
+
+Identifies content showing signs of performance decline.
+
+```typescript
+import { DecayDetector } from '@pagebridge/core';
+
+const detector = new DecayDetector({
+  db,
+  rules: [
+    {
+      name: 'position_decay',
+      enabled: true,
+      threshold: 3, // positions dropped
+      windowDays: 28,
+    },
+    {
+      name: 'low_ctr',
+      enabled: true,
+      threshold: 0.01, // 1% CTR
+      positionThreshold: 10,
+    },
+    {
+      name: 'impressions_drop',
+      enabled: true,
+      threshold: 0.5, // 50% drop
+      windowDays: 28,
+    },
+  ],
+  quietPeriod: {
+    enabled: true,
+    days: 45,
+  },
+});
+
+const signals = await detector.detect({
+  siteId: 'sanity-site-document-id',
+  documents: matchedDocuments,
+});
+```
+
+### URLMatcher
+
+Maps GSC page URLs to Sanity documents.
+
+```typescript
+import { URLMatcher } from '@pagebridge/core';
+
+const matcher = new URLMatcher({
+  siteUrl: 'https://example.com',
+  pathPrefix: '/blog',
+});
+
+const results = matcher.match({
+  pages: gscPages,
+  documents: sanityDocuments,
+});
+
+// Results include exact, normalized, and fuzzy matches
+```
+
+### TaskGenerator
+
+Creates refresh tasks in Sanity for pages with decay signals.
+
+```typescript
+import { TaskGenerator } from '@pagebridge/core';
+
+const generator = new TaskGenerator({
+  sanityClient,
+  siteId: 'sanity-site-document-id',
+});
+
+const tasks = await generator.generate({
+  signals: decaySignals,
+  dryRun: false,
+});
+```
+
+## Decay Detection Rules
+
+The default rules detect three patterns:
+
+| Rule | Description | Default Threshold |
+|------|-------------|-------------------|
+| `position_decay` | Average position dropped significantly | 3+ positions over 28 days |
+| `low_ctr` | Low CTR despite good rankings | CTR < 1% for pages in top 10 |
+| `impressions_drop` | Sharp decline in impressions | 50%+ drop over 28 days |
+
+A configurable "quiet period" (default 45 days) prevents flagging recently published content.
+
+## Environment Variables
+
+Required for full functionality:
+
+- `GOOGLE_SERVICE_ACCOUNT` - JSON stringified Google service account credentials
+- `DATABASE_URL` - PostgreSQL connection string
+- `SANITY_PROJECT_ID` - Sanity project ID
+- `SANITY_DATASET` - Sanity dataset name
+- `SANITY_TOKEN` - Sanity API token with write access
+
+## API Reference
+
+### Types
+
+```typescript
+// GSC Client
+interface GSCClientOptions {
+  serviceAccountJson: string;
+}
+
+interface IndexStatusResult {
+  verdict: IndexVerdict;
+  coverageState: string;
+  indexingState: string;
+  pageFetchState: string;
+  lastCrawlTime?: string;
+  robotsTxtState: string;
+}
+
+// Sync Engine
+interface SyncOptions {
+  siteUrl: string;
+  siteId: string;
+  dryRun?: boolean;
+  days?: number;
+}
+
+interface SyncResult {
+  rowsProcessed: number;
+  snapshotsWritten: number;
+  errors: string[];
+}
+
+// Decay Detection
+interface DecaySignal {
+  page: string;
+  documentId: string;
+  rule: string;
+  severity: 'low' | 'medium' | 'high';
+  metrics: {
+    before: number;
+    now: number;
+    delta: number;
+  };
+}
+
+// URL Matching
+interface MatchResult {
+  page: string;
+  documentId: string;
+  matchType: 'exact' | 'normalized' | 'fuzzy';
+  confidence: number;
+}
+```
+
+## License
+
+MIT

package/dist/decay-detector.d.ts

@@ -0,0 +1,37 @@
+import type { DrizzleClient } from "@pagebridge/db";
+export interface DecayRule {
+    type: "position_decay" | "low_ctr" | "impressions_drop";
+    threshold: number;
+    minImpressions: number;
+    comparisonWindowDays: number;
+    sustainedDays: number;
+}
+export interface QuietPeriodConfig {
+    enabled: boolean;
+    days: number;
+}
+export interface DecaySignal {
+    page: string;
+    reason: "position_decay" | "low_ctr" | "impressions_drop";
+    severity: "low" | "medium" | "high";
+    metrics: {
+        positionBefore: number;
+        positionNow: number;
+        positionDelta: number;
+        ctrBefore: number;
+        ctrNow: number;
+        impressions: number;
+    };
+}
+export declare const defaultRules: DecayRule[];
+export declare class DecayDetector {
+    private db;
+    private rules;
+    constructor(db: DrizzleClient, rules?: DecayRule[]);
+    detectDecay(siteId: string, publishedDates: Map<string, Date>, quietPeriod?: QuietPeriodConfig): Promise<DecaySignal[]>;
+    private getAverageMetrics;
+    private evaluateRule;
+    private calculateSeverity;
+    private deduplicateSignals;
+}
+//# sourceMappingURL=decay-detector.d.ts.map

package/dist/decay-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decay-detector.d.ts","sourceRoot":"","sources":["../src/decay-detector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIpD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,gBAAgB,GAAG,SAAS,GAAG,kBAAkB,CAAC;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,GAAG,SAAS,GAAG,kBAAkB,CAAC;IAC1D,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACpC,OAAO,EAAE;QACP,cAAc,EAAE,MAAM,CAAC;QACvB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AASD,eAAO,MAAM,YAAY,EAAE,SAAS,EAsBnC,CAAC;AAEF,qBAAa,aAAa;IAEtB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,KAAK;gBADL,EAAE,EAAE,aAAa,EACjB,KAAK,GAAE,SAAS,EAAiB;IAGrC,WAAW,CACf,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,EACjC,WAAW,GAAE,iBAA+C,GAC3D,OAAO,CAAC,WAAW,EAAE,CAAC;YAsCX,iBAAiB;IA8B/B,OAAO,CAAC,YAAY;IAwEpB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,kBAAkB;CAgB3B"}

package/dist/decay-detector.js

@@ -0,0 +1,175 @@
+import { searchAnalytics } from "@pagebridge/db";
+import { and, avg, gte, lte, sql, eq } from "drizzle-orm";
+export const defaultRules = [
+    {
+        type: "position_decay",
+        threshold: 3,
+        minImpressions: 100,
+        comparisonWindowDays: 28,
+        sustainedDays: 14,
+    },
+    {
+        type: "low_ctr",
+        threshold: 0.01,
+        minImpressions: 1000,
+        comparisonWindowDays: 28,
+        sustainedDays: 7,
+    },
+    {
+        type: "impressions_drop",
+        threshold: 0.5,
+        minImpressions: 500,
+        comparisonWindowDays: 28,
+        sustainedDays: 14,
+    },
+];
+export class DecayDetector {
+    db;
+    rules;
+    constructor(db, rules = defaultRules) {
+        this.db = db;
+        this.rules = rules;
+    }
+    async detectDecay(siteId, publishedDates, quietPeriod = { enabled: true, days: 45 }) {
+        const signals = [];
+        const now = new Date();
+        for (const rule of this.rules) {
+            const currentPeriodEnd = now;
+            const currentPeriodStart = daysAgo(rule.sustainedDays);
+            const previousPeriodEnd = daysAgo(rule.comparisonWindowDays);
+            const previousPeriodStart = daysAgo(rule.comparisonWindowDays + rule.sustainedDays);
+            const [currentMetrics, previousMetrics] = await Promise.all([
+                this.getAverageMetrics(siteId, currentPeriodStart, currentPeriodEnd),
+                this.getAverageMetrics(siteId, previousPeriodStart, previousPeriodEnd),
+            ]);
+            for (const current of currentMetrics) {
+                if (quietPeriod.enabled) {
+                    const publishDate = publishedDates.get(current.page);
+                    if (publishDate && daysSince(publishDate) < quietPeriod.days) {
+                        continue;
+                    }
+                }
+                if (current.impressions < rule.minImpressions)
+                    continue;
+                const previous = previousMetrics.find((p) => p.page === current.page);
+                if (!previous)
+                    continue;
+                const signal = this.evaluateRule(rule, current, previous);
+                if (signal)
+                    signals.push(signal);
+            }
+        }
+        return this.deduplicateSignals(signals);
+    }
+    async getAverageMetrics(siteId, startDate, endDate) {
+        const results = await this.db
+            .select({
+            page: searchAnalytics.page,
+            avgPosition: avg(searchAnalytics.position),
+            avgCtr: avg(searchAnalytics.ctr),
+            totalImpressions: sql `sum(${searchAnalytics.impressions})`,
+        })
+            .from(searchAnalytics)
+            .where(and(eq(searchAnalytics.siteId, siteId), gte(searchAnalytics.date, formatDate(startDate)), lte(searchAnalytics.date, formatDate(endDate))))
+            .groupBy(searchAnalytics.page);
+        return results.map((r) => ({
+            page: r.page,
+            position: Number(r.avgPosition) || 0,
+            ctr: Number(r.avgCtr) || 0,
+            impressions: Number(r.totalImpressions) || 0,
+        }));
+    }
+    evaluateRule(rule, current, previous) {
+        switch (rule.type) {
+            case "position_decay": {
+                const delta = current.position - previous.position;
+                if (delta >= rule.threshold) {
+                    return {
+                        page: current.page,
+                        reason: "position_decay",
+                        severity: this.calculateSeverity(delta, [3, 5, 8]),
+                        metrics: {
+                            positionBefore: previous.position,
+                            positionNow: current.position,
+                            positionDelta: delta,
+                            ctrBefore: previous.ctr,
+                            ctrNow: current.ctr,
+                            impressions: current.impressions,
+                        },
+                    };
+                }
+                break;
+            }
+            case "low_ctr": {
+                if (current.ctr < rule.threshold && current.position <= 10) {
+                    return {
+                        page: current.page,
+                        reason: "low_ctr",
+                        severity: this.calculateSeverity(rule.threshold - current.ctr, [0.005, 0.01, 0.02]),
+                        metrics: {
+                            positionBefore: previous.position,
+                            positionNow: current.position,
+                            positionDelta: current.position - previous.position,
+                            ctrBefore: previous.ctr,
+                            ctrNow: current.ctr,
+                            impressions: current.impressions,
+                        },
+                    };
+                }
+                break;
+            }
+            case "impressions_drop": {
+                const dropRatio = 1 - current.impressions / previous.impressions;
+                if (dropRatio >= rule.threshold) {
+                    return {
+                        page: current.page,
+                        reason: "impressions_drop",
+                        severity: this.calculateSeverity(dropRatio, [0.3, 0.5, 0.7]),
+                        metrics: {
+                            positionBefore: previous.position,
+                            positionNow: current.position,
+                            positionDelta: current.position - previous.position,
+                            ctrBefore: previous.ctr,
+                            ctrNow: current.ctr,
+                            impressions: current.impressions,
+                        },
+                    };
+                }
+                break;
+            }
+        }
+        return undefined;
+    }
+    calculateSeverity(value, thresholds) {
+        if (value >= thresholds[2])
+            return "high";
+        if (value >= thresholds[1])
+            return "medium";
+        return "low";
+    }
+    deduplicateSignals(signals) {
+        const byPage = new Map();
+        const severityOrder = { high: 3, medium: 2, low: 1 };
+        for (const signal of signals) {
+            const existing = byPage.get(signal.page);
+            if (!existing ||
+                severityOrder[signal.severity] > severityOrder[existing.severity]) {
+                byPage.set(signal.page, signal);
+            }
+        }
+        return Array.from(byPage.values());
+    }
+}
+function daysAgo(days) {
+    const date = new Date();
+    date.setDate(date.getDate() - days);
+    return date;
+}
+function daysSince(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    return Math.floor(diff / (1000 * 60 * 60 * 24));
+}
+function formatDate(date) {
+    return date.toISOString().split("T")[0];
+}

package/dist/gsc-client.d.ts

@@ -0,0 +1,40 @@
+export interface GSCClientOptions {
+    credentials: {
+        client_email: string;
+        private_key: string;
+    };
+}
+export interface SearchAnalyticsRow {
+    page: string;
+    query?: string;
+    date?: string;
+    clicks: number;
+    impressions: number;
+    ctr: number;
+    position: number;
+}
+export interface FetchOptions {
+    siteUrl: string;
+    startDate: Date;
+    endDate: Date;
+    dimensions?: ("page" | "query" | "date")[];
+    rowLimit?: number;
+}
+export type IndexVerdict = "PASS" | "FAIL" | "NEUTRAL" | "VERDICT_UNSPECIFIED";
+export interface IndexStatusResult {
+    verdict: IndexVerdict;
+    coverageState: string | null;
+    indexingState: string | null;
+    pageFetchState: string | null;
+    lastCrawlTime: Date | null;
+    robotsTxtState: string | null;
+}
+export declare class GSCClient {
+    private auth;
+    private searchConsole;
+    constructor(options: GSCClientOptions);
+    fetchSearchAnalytics(options: FetchOptions): Promise<SearchAnalyticsRow[]>;
+    listSites(): Promise<string[]>;
+    inspectUrl(siteUrl: string, inspectionUrl: string): Promise<IndexStatusResult>;
+}
+//# sourceMappingURL=gsc-client.d.ts.map

package/dist/gsc-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gsc-client.d.ts","sourceRoot":"","sources":["../src/gsc-client.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE;QACX,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;IACd,UAAU,CAAC,EAAE,CAAC,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,qBAAqB,CAAC;AAE/E,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,YAAY,CAAC;IACtB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,IAAI,GAAG,IAAI,CAAC;IAC3B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,aAAa,CAAiC;gBAE1C,OAAO,EAAE,gBAAgB;IAa/B,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAyC1E,SAAS,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAK9B,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAmBrF"}

package/dist/gsc-client.js

@@ -0,0 +1,76 @@
+import { google } from "googleapis";
+export class GSCClient {
+    auth;
+    searchConsole;
+    constructor(options) {
+        this.auth = new google.auth.JWT({
+            email: options.credentials.client_email,
+            key: options.credentials.private_key,
+            scopes: ["https://www.googleapis.com/auth/webmasters.readonly"],
+        });
+        this.searchConsole = google.searchconsole({
+            version: "v1",
+            auth: this.auth,
+        });
+    }
+    async fetchSearchAnalytics(options) {
+        const { siteUrl, startDate, endDate, dimensions = ["page", "date"], rowLimit = 25000 } = options;
+        const rows = [];
+        let startRow = 0;
+        while (true) {
+            const response = await this.searchConsole.searchanalytics.query({
+                siteUrl,
+                requestBody: {
+                    startDate: formatDate(startDate),
+                    endDate: formatDate(endDate),
+                    dimensions,
+                    rowLimit,
+                    startRow,
+                },
+            });
+            const responseRows = response.data.rows ?? [];
+            if (responseRows.length === 0)
+                break;
+            for (const row of responseRows) {
+                const keys = row.keys ?? [];
+                rows.push({
+                    page: dimensions.includes("page") ? keys[dimensions.indexOf("page")] : "",
+                    query: dimensions.includes("query") ? keys[dimensions.indexOf("query")] : undefined,
+                    date: dimensions.includes("date") ? keys[dimensions.indexOf("date")] : undefined,
+                    clicks: row.clicks ?? 0,
+                    impressions: row.impressions ?? 0,
+                    ctr: row.ctr ?? 0,
+                    position: row.position ?? 0,
+                });
+            }
+            if (responseRows.length < rowLimit)
+                break;
+            startRow += rowLimit;
+        }
+        return rows;
+    }
+    async listSites() {
+        const response = await this.searchConsole.sites.list();
+        return (response.data.siteEntry ?? []).map((site) => site.siteUrl).filter(Boolean);
+    }
+    async inspectUrl(siteUrl, inspectionUrl) {
+        const response = await this.searchConsole.urlInspection.index.inspect({
+            requestBody: {
+                inspectionUrl,
+                siteUrl,
+            },
+        });
+        const result = response.data.inspectionResult?.indexStatusResult;
+        return {
+            verdict: result?.verdict ?? "VERDICT_UNSPECIFIED",
+            coverageState: result?.coverageState ?? null,
+            indexingState: result?.indexingState ?? null,
+            pageFetchState: result?.pageFetchState ?? null,
+            lastCrawlTime: result?.lastCrawlTime ? new Date(result.lastCrawlTime) : null,
+            robotsTxtState: result?.robotsTxtState ?? null,
+        };
+    }
+}
+function formatDate(date) {
+    return date.toISOString().split("T")[0];
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { GSCClient, type GSCClientOptions, type IndexStatusResult, type IndexVerdict, } from "./gsc-client.js";
+export { SyncEngine, type SyncOptions, type SyncResult, type IndexStatusSyncResult, } from "./sync-engine.js";
+export { DecayDetector, defaultRules, type DecayRule, type DecaySignal, type QuietPeriodConfig, } from "./decay-detector.js";
+export { URLMatcher, type MatchResult, type URLMatcherConfig, type UnmatchReason, type MatchDiagnostics, } from "./url-matcher.js";
+export { TaskGenerator, type TaskGeneratorOptions, type QueryContext, } from "./task-generator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,YAAY,GAClB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,UAAU,EACV,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,aAAa,EACb,YAAY,EACZ,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,iBAAiB,GACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,UAAU,EACV,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,EACzB,KAAK,YAAY,GAClB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { GSCClient, } from "./gsc-client.js";
+export { SyncEngine, } from "./sync-engine.js";
+export { DecayDetector, defaultRules, } from "./decay-detector.js";
+export { URLMatcher, } from "./url-matcher.js";
+export { TaskGenerator, } from "./task-generator.js";

package/dist/sync-engine.d.ts

@@ -0,0 +1,41 @@
+import type { DrizzleClient } from "@pagebridge/db";
+import type { SanityClient } from "@sanity/client";
+import type { GSCClient, IndexStatusResult } from "./gsc-client.js";
+export interface SyncOptions {
+    siteUrl: string;
+    startDate?: Date;
+    endDate?: Date;
+    dimensions?: ("page" | "query" | "date")[];
+}
+export interface SyncResult {
+    pages: string[];
+    rowsProcessed: number;
+    syncLogId: string;
+}
+export interface IndexStatusSyncResult {
+    checked: number;
+    indexed: number;
+    notIndexed: number;
+    skipped: number;
+}
+export interface SyncEngineOptions {
+    gsc: GSCClient;
+    db: DrizzleClient;
+    sanity: SanityClient;
+}
+export declare class SyncEngine {
+    private gsc;
+    private db;
+    private sanity;
+    constructor(options: SyncEngineOptions);
+    sync(options: SyncOptions): Promise<SyncResult>;
+    writeSnapshots(siteId: string, matches: {
+        gscUrl: string;
+        sanityId: string | undefined;
+    }[], siteUrl?: string): Promise<void>;
+    syncIndexStatus(siteUrl: string, pages: string[]): Promise<IndexStatusSyncResult>;
+    getIndexStatus(siteUrl: string, page: string): Promise<IndexStatusResult | null>;
+    private getAggregatedMetrics;
+    private getTopQueries;
+}
+//# sourceMappingURL=sync-engine.d.ts.map

package/dist/sync-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-engine.d.ts","sourceRoot":"","sources":["../src/sync-engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAQpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,UAAU,CAAC,EAAE,CAAC,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,SAAS,CAAC;IACf,EAAE,EAAE,aAAa,CAAC;IAClB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,GAAG,CAAY;IACvB,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,MAAM,CAAe;gBAEjB,OAAO,EAAE,iBAAiB;IAMhC,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IA+G/C,cAAc,CAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,EAAE,EAC3D,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAmFV,eAAe,CACnB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,qBAAqB,CAAC;IA6E3B,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAqBtB,oBAAoB;YAiDpB,aAAa;CAyD5B"}