emdash-plugin-relink 0.2.2

package/dist/core/api.d.ts

@@ -0,0 +1,559 @@
+import { z } from "zod";
+import type { LinkRecord, Settings } from "./schema.js";
+export declare const viewSchema: z.ZodEnum<{
+    grokipedia: "grokipedia";
+    all: "all";
+    problems: "problems";
+    archives: "archives";
+    reviews: "reviews";
+    history: "history";
+}>;
+export declare const listQuerySchema: z.ZodObject<{
+    view: z.ZodDefault<z.ZodEnum<{
+        grokipedia: "grokipedia";
+        all: "all";
+        problems: "problems";
+        archives: "archives";
+        reviews: "reviews";
+        history: "history";
+    }>>;
+    search: z.ZodDefault<z.ZodString>;
+    domain: z.ZodDefault<z.ZodString>;
+    collection: z.ZodDefault<z.ZodString>;
+    contentId: z.ZodDefault<z.ZodString>;
+    language: z.ZodDefault<z.ZodString>;
+    state: z.ZodDefault<z.ZodEnum<{
+        "": "";
+        healthy: "healthy";
+        broken: "broken";
+        unverifiable: "unverifiable";
+        excluded: "excluded";
+        pending: "pending";
+    }>>;
+    reviewBefore: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type ListQuery = z.infer<typeof listQuerySchema>;
+export declare const summarySchema: z.ZodObject<{
+    attention: z.ZodNumber;
+    archives: z.ZodNumber;
+    reviews: z.ZodNumber;
+    unverifiable: z.ZodNumber;
+}, z.core.$strip>;
+export declare const snapshotSchema: z.ZodObject<{
+    links: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        url: z.ZodURL;
+        host: z.ZodString;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        nextCheckAt: z.ZodNumber;
+        firstFailureAt: z.ZodNullable<z.ZodNumber>;
+        lastFailureAt: z.ZodNullable<z.ZodNumber>;
+        failures: z.ZodNumber;
+        recoveryAt: z.ZodNullable<z.ZodNumber>;
+        lastCheck: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodNumber;
+            contentType: z.ZodString;
+            evidence: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"healthy">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodEnum<{
+                "not-found": "not-found";
+                "server-error": "server-error";
+                dns: "dns";
+                timeout: "timeout";
+                connection: "connection";
+                "redirect-loop": "redirect-loop";
+            }>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"broken">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodEnum<{
+                authentication: "authentication";
+                blocked: "blocked";
+                "rate-limited": "rate-limited";
+                "unsafe-url": "unsafe-url";
+                "soft-error": "soft-error";
+                "network-outage": "network-outage";
+                "unsupported-response": "unsupported-response";
+                "response-too-large": "response-too-large";
+            }>;
+            retryAt: z.ZodNullable<z.ZodNumber>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"unverifiable">;
+        }, z.core.$strip>], "kind">>;
+        replacement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"archive">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            snapshotAt: z.ZodNumber;
+            reason: z.ZodLiteral<"confirmed-failures">;
+            fragments: z.ZodArray<z.ZodString>;
+            evidence: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"grokipedia">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            reason: z.ZodLiteral<"identity-language-match">;
+            fragments: z.ZodArray<z.ZodString>;
+            evidence: z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"manual">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            reason: z.ZodLiteral<"editor-override">;
+        }, z.core.$strip>], "kind">>;
+        review: z.ZodNullable<z.ZodObject<{
+            dueAt: z.ZodNumber;
+            reason: z.ZodEnum<{
+                unverifiable: "unverifiable";
+                "archive-active": "archive-active";
+                "archive-missing": "archive-missing";
+                "archive-unavailable": "archive-unavailable";
+                "grokipedia-ambiguous": "grokipedia-ambiguous";
+                "replacement-failed": "replacement-failed";
+                "manual-review": "manual-review";
+            }>;
+        }, z.core.$strip>>;
+        excluded: z.ZodBoolean;
+        automaticDisabled: z.ZodBoolean;
+        active: z.ZodBoolean;
+        archiveRetryAt: z.ZodNullable<z.ZodNumber>;
+        grokipediaChecked: z.ZodBoolean;
+    }, z.core.$strip>>;
+    occurrences: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        linkId: z.ZodString;
+        originalUrl: z.ZodURL;
+        collection: z.ZodString;
+        contentId: z.ZodString;
+        slug: z.ZodString;
+        locale: z.ZodString;
+        title: z.ZodString;
+        path: z.ZodString;
+        text: z.ZodString;
+        pagePath: z.ZodString;
+        generation: z.ZodString;
+    }, z.core.$strip>>;
+    history: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        linkId: z.ZodString;
+        originalUrl: z.ZodOptional<z.ZodURL>;
+        at: z.ZodNumber;
+        event: z.ZodEnum<{
+            excluded: "excluded";
+            checked: "checked";
+            "archive-applied": "archive-applied";
+            "grokipedia-applied": "grokipedia-applied";
+            "original-restored": "original-restored";
+            "replacement-unavailable": "replacement-unavailable";
+            included: "included";
+            override: "override";
+            undo: "undo";
+            rescheduled: "rescheduled";
+        }>;
+        result: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodNumber;
+            contentType: z.ZodString;
+            evidence: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"healthy">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodEnum<{
+                "not-found": "not-found";
+                "server-error": "server-error";
+                dns: "dns";
+                timeout: "timeout";
+                connection: "connection";
+                "redirect-loop": "redirect-loop";
+            }>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"broken">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodEnum<{
+                authentication: "authentication";
+                blocked: "blocked";
+                "rate-limited": "rate-limited";
+                "unsafe-url": "unsafe-url";
+                "soft-error": "soft-error";
+                "network-outage": "network-outage";
+                "unsupported-response": "unsupported-response";
+                "response-too-large": "response-too-large";
+            }>;
+            retryAt: z.ZodNullable<z.ZodNumber>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"unverifiable">;
+        }, z.core.$strip>], "kind">>;
+        destination: z.ZodNullable<z.ZodString>;
+        replacement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"archive">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            snapshotAt: z.ZodNumber;
+            reason: z.ZodLiteral<"confirmed-failures">;
+            fragments: z.ZodArray<z.ZodString>;
+            evidence: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"grokipedia">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            reason: z.ZodLiteral<"identity-language-match">;
+            fragments: z.ZodArray<z.ZodString>;
+            evidence: z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"manual">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            reason: z.ZodLiteral<"editor-override">;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    summary: z.ZodObject<{
+        attention: z.ZodNumber;
+        archives: z.ZodNumber;
+        reviews: z.ZodNumber;
+        unverifiable: z.ZodNumber;
+    }, z.core.$strip>;
+    settings: z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        archiveEnabled: z.ZodDefault<z.ZodBoolean>;
+        grokipediaEnabled: z.ZodDefault<z.ZodBoolean>;
+        direction: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            ltr: "ltr";
+            rtl: "rtl";
+        }>>;
+        healthyDays: z.ZodDefault<z.ZodNumber>;
+        reviewDays: z.ZodDefault<z.ZodNumber>;
+        archiveRetryDays: z.ZodDefault<z.ZodNumber>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        batchSize: z.ZodDefault<z.ZodNumber>;
+        excludedDomains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    worker: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        scan: z.ZodNullable<z.ZodObject<{
+            sourceIndex: z.ZodNumber;
+            cursor: z.ZodNullable<z.ZodString>;
+            generation: z.ZodString;
+            startedAt: z.ZodNumber;
+        }, z.core.$strip>>;
+        nextScanAt: z.ZodNumber;
+        lastStartedAt: z.ZodNullable<z.ZodNumber>;
+        lastCompletedAt: z.ZodNullable<z.ZodNumber>;
+        lastError: z.ZodNullable<z.ZodEnum<{
+            content: "content";
+            storage: "storage";
+            network: "network";
+        }>>;
+        processed: z.ZodNumber;
+    }, z.core.$strip>;
+    scheduled: z.ZodBoolean;
+    nextRunAt: z.ZodNullable<z.ZodNumber>;
+    pendingCommands: z.ZodNumber;
+    canManage: z.ZodBoolean;
+}, z.core.$strip>;
+export type AdminSnapshot = z.infer<typeof snapshotSchema>;
+export declare const detailSchema: z.ZodObject<{
+    link: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        url: z.ZodURL;
+        host: z.ZodString;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        nextCheckAt: z.ZodNumber;
+        firstFailureAt: z.ZodNullable<z.ZodNumber>;
+        lastFailureAt: z.ZodNullable<z.ZodNumber>;
+        failures: z.ZodNumber;
+        recoveryAt: z.ZodNullable<z.ZodNumber>;
+        lastCheck: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodNumber;
+            contentType: z.ZodString;
+            evidence: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"healthy">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodEnum<{
+                "not-found": "not-found";
+                "server-error": "server-error";
+                dns: "dns";
+                timeout: "timeout";
+                connection: "connection";
+                "redirect-loop": "redirect-loop";
+            }>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"broken">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodEnum<{
+                authentication: "authentication";
+                blocked: "blocked";
+                "rate-limited": "rate-limited";
+                "unsafe-url": "unsafe-url";
+                "soft-error": "soft-error";
+                "network-outage": "network-outage";
+                "unsupported-response": "unsupported-response";
+                "response-too-large": "response-too-large";
+            }>;
+            retryAt: z.ZodNullable<z.ZodNumber>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"unverifiable">;
+        }, z.core.$strip>], "kind">>;
+        replacement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"archive">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            snapshotAt: z.ZodNumber;
+            reason: z.ZodLiteral<"confirmed-failures">;
+            fragments: z.ZodArray<z.ZodString>;
+            evidence: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"grokipedia">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            reason: z.ZodLiteral<"identity-language-match">;
+            fragments: z.ZodArray<z.ZodString>;
+            evidence: z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"manual">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            reason: z.ZodLiteral<"editor-override">;
+        }, z.core.$strip>], "kind">>;
+        review: z.ZodNullable<z.ZodObject<{
+            dueAt: z.ZodNumber;
+            reason: z.ZodEnum<{
+                unverifiable: "unverifiable";
+                "archive-active": "archive-active";
+                "archive-missing": "archive-missing";
+                "archive-unavailable": "archive-unavailable";
+                "grokipedia-ambiguous": "grokipedia-ambiguous";
+                "replacement-failed": "replacement-failed";
+                "manual-review": "manual-review";
+            }>;
+        }, z.core.$strip>>;
+        excluded: z.ZodBoolean;
+        automaticDisabled: z.ZodBoolean;
+        active: z.ZodBoolean;
+        archiveRetryAt: z.ZodNullable<z.ZodNumber>;
+        grokipediaChecked: z.ZodBoolean;
+    }, z.core.$strip>>;
+    occurrences: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        linkId: z.ZodString;
+        originalUrl: z.ZodURL;
+        collection: z.ZodString;
+        contentId: z.ZodString;
+        slug: z.ZodString;
+        locale: z.ZodString;
+        title: z.ZodString;
+        path: z.ZodString;
+        text: z.ZodString;
+        pagePath: z.ZodString;
+        generation: z.ZodString;
+    }, z.core.$strip>>;
+    history: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        linkId: z.ZodString;
+        originalUrl: z.ZodOptional<z.ZodURL>;
+        at: z.ZodNumber;
+        event: z.ZodEnum<{
+            excluded: "excluded";
+            checked: "checked";
+            "archive-applied": "archive-applied";
+            "grokipedia-applied": "grokipedia-applied";
+            "original-restored": "original-restored";
+            "replacement-unavailable": "replacement-unavailable";
+            included: "included";
+            override: "override";
+            undo: "undo";
+            rescheduled: "rescheduled";
+        }>;
+        result: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodNumber;
+            contentType: z.ZodString;
+            evidence: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"healthy">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodEnum<{
+                "not-found": "not-found";
+                "server-error": "server-error";
+                dns: "dns";
+                timeout: "timeout";
+                connection: "connection";
+                "redirect-loop": "redirect-loop";
+            }>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"broken">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodEnum<{
+                authentication: "authentication";
+                blocked: "blocked";
+                "rate-limited": "rate-limited";
+                "unsafe-url": "unsafe-url";
+                "soft-error": "soft-error";
+                "network-outage": "network-outage";
+                "unsupported-response": "unsupported-response";
+                "response-too-large": "response-too-large";
+            }>;
+            retryAt: z.ZodNullable<z.ZodNumber>;
+            checkedAt: z.ZodNumber;
+            finalUrl: z.ZodURL;
+            kind: z.ZodLiteral<"unverifiable">;
+        }, z.core.$strip>], "kind">>;
+        destination: z.ZodNullable<z.ZodString>;
+        replacement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"archive">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            snapshotAt: z.ZodNumber;
+            reason: z.ZodLiteral<"confirmed-failures">;
+            fragments: z.ZodArray<z.ZodString>;
+            evidence: z.ZodNullable<z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"grokipedia">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            reason: z.ZodLiteral<"identity-language-match">;
+            fragments: z.ZodArray<z.ZodString>;
+            evidence: z.ZodObject<{
+                title: z.ZodString;
+                language: z.ZodString;
+                canonical: z.ZodString;
+                introduction: z.ZodString;
+                anchors: z.ZodArray<z.ZodString>;
+                sourceUrls: z.ZodArray<z.ZodString>;
+                disambiguation: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"manual">;
+            url: z.ZodURL;
+            verifiedAt: z.ZodNumber;
+            reason: z.ZodLiteral<"editor-override">;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LinkDetail = z.infer<typeof detailSchema>;
+export declare const projectionSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodTuple<[z.ZodURL, z.ZodURL], null>>;
+}, z.core.$strip>;
+export declare function effectiveDestination(link: LinkRecord, original: string, settings: Settings): string;
+/** Spreadsheet applications must not interpret URL or editor text as formulas. */
+export declare function csvCell(value: string): string;
+//# sourceMappingURL=api.d.ts.map

package/dist/core/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/core/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGxD,eAAO,MAAM,UAAU;;;;;;;EAOrB,CAAC;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;iBAa1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,eAAO,MAAM,aAAa;;;;;iBAKxB,CAAC;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYzB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC3D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIvB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACtD,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC;AAEH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,QAAQ,GACjB,MAAM,CAgBR;AAED,kFAAkF;AAClF,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG7C"}

package/dist/core/api.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { historySchema, linkSchema, occurrenceSchema, settingsSchema, stateSchema, } from "./schema.js";
+import { domainExcluded } from "./url.js";
+export const viewSchema = z.enum([
+    "all",
+    "problems",
+    "archives",
+    "reviews",
+    "grokipedia",
+    "history",
+]);
+export const listQuerySchema = z.object({
+    view: viewSchema.default("all"),
+    search: z.string().max(500).default(""),
+    domain: z.string().max(253).default(""),
+    collection: z.string().max(100).default(""),
+    contentId: z.string().max(100).default(""),
+    language: z.string().max(30).default(""),
+    state: z
+        .enum(["", "pending", "healthy", "broken", "unverifiable", "excluded"])
+        .default(""),
+    reviewBefore: z.coerce.number().nonnegative().optional(),
+    offset: z.coerce.number().int().nonnegative().default(0),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+});
+export const summarySchema = z.object({
+    attention: z.number(),
+    archives: z.number(),
+    reviews: z.number(),
+    unverifiable: z.number(),
+});
+export const snapshotSchema = z.object({
+    links: z.array(linkSchema),
+    occurrences: z.array(occurrenceSchema),
+    history: z.array(historySchema),
+    total: z.number(),
+    summary: summarySchema,
+    settings: settingsSchema,
+    worker: stateSchema,
+    scheduled: z.boolean(),
+    nextRunAt: z.number().nullable(),
+    pendingCommands: z.number(),
+    canManage: z.boolean(),
+});
+export const detailSchema = z.object({
+    link: linkSchema.nullable(),
+    occurrences: z.array(occurrenceSchema),
+    history: z.array(historySchema),
+});
+export const projectionSchema = z.object({
+    rules: z.array(z.tuple([z.url(), z.url()])),
+});
+export function effectiveDestination(link, original, settings) {
+    const rule = link.replacement;
+    if (!rule ||
+        !settings.enabled ||
+        link.excluded ||
+        !link.active ||
+        domainExcluded(link.host, settings.excludedDomains))
+        return original;
+    if (rule.kind === "archive" && !settings.archiveEnabled)
+        return original;
+    if (rule.kind === "grokipedia" && !settings.grokipediaEnabled)
+        return original;
+    if (rule.kind === "manual")
+        return rule.url;
+    if (!rule.fragments.includes(new URL(original).hash))
+        return original;
+    return `${rule.url}${new URL(original).hash}`;
+}
+/** Spreadsheet applications must not interpret URL or editor text as formulas. */
+export function csvCell(value) {
+    const safe = /^[\s]*[=+@-]/u.test(value) ? `'${value}` : value;
+    return `"${safe.replaceAll('"', '""')}"`;
+}
+//# sourceMappingURL=api.js.map

package/dist/core/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../src/core/api.ts"],"names":[],"mappings":"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"}

package/dist/core/engine.d.ts

@@ -0,0 +1,30 @@
+import type { ContentAccess } from "emdash";
+import { LinkChecker } from "./http.js";
+import type { HttpTransport } from "./http.js";
+import type { ArchiveProvider, EncyclopediaProvider } from "./providers.js";
+import type { LinkRecord, ResolvedOptions, Settings } from "./schema.js";
+import type { RelinkStore } from "./storage.js";
+export declare function newLink(id: string, url: string, now: number): LinkRecord;
+export interface EngineDependencies {
+    store: RelinkStore;
+    content: ContentAccess;
+    transport: HttpTransport;
+    options: ResolvedOptions;
+    clock?: () => number;
+    archive?: ArchiveProvider;
+    encyclopedia?: EncyclopediaProvider;
+}
+/** Invoke tick only through EmDash's single, atomically claimed recurring job. */
+export declare class RelinkEngine {
+    private readonly dependencies;
+    private readonly clock;
+    constructor(dependencies: EngineDependencies);
+    private get store();
+    tick(): Promise<void>;
+    private event;
+    private processCommands;
+    private apply;
+    private scanBatch;
+    checkLink(link: LinkRecord, settings: Settings, checker: LinkChecker): Promise<void>;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/core/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE5E,OAAO,KAAK,EAGV,UAAU,EACV,eAAe,EACf,QAAQ,EAET,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAsBxE;AACD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,SAAS,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,eAAe,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC;AAED,kFAAkF;AAClF,qBAAa,YAAY;IAEX,OAAO,CAAC,QAAQ,CAAC,YAAY;IADzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBACR,YAAY,EAAE,kBAAkB;IAG7D,OAAO,KAAK,KAAK,GAEhB;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAyCb,KAAK;YAkBL,eAAe;YAaf,KAAK;YAgEL,SAAS;IAwFjB,SAAS,CACb,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC;CAwJjB"}