@fsvreddit/bot-bouncer-evaluation 0.7.40

package/dist/userEvaluation/EvaluateWorldTraveller.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateWorldTraveller = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const constants_js_1 = require("../constants.js");
+const lodash_1 = require("lodash");
+const date_fns_1 = require("date-fns");
+class EvaluateWorldTraveller extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "World Traveller";
+        this.shortname = "worldtraveler";
+        this.canAutoBan = true;
+        this.banContentThreshold = 10;
+    }
+    validateVariables() {
+        const subGroups = this.getWTSubGroups();
+        const results = [];
+        const allSubs = new Set();
+        const duplicateSubs = new Set();
+        for (const group of subGroups) {
+            for (const sub of group.subs) {
+                if (allSubs.has(sub)) {
+                    duplicateSubs.add(sub);
+                }
+                else {
+                    allSubs.add(sub);
+                }
+            }
+        }
+        if (duplicateSubs.size > 0) {
+            results.push({
+                severity: "warning",
+                message: `Subreddits found in more than one group: ${Array.from(duplicateSubs).join(", ")}`,
+            });
+        }
+        return results;
+    }
+    getWTSubGroups() {
+        const subGroups = this.getVariable("subgroups", []);
+        return subGroups.map(group => ({ group, subs: group.split(",").map(s => s.trim()) }));
+    }
+    getSubList() {
+        return this.getWTSubGroups().map(group => group.subs).flat();
+    }
+    isInEligibleSubreddit() {
+        if (!this.context.subredditName) {
+            return false;
+        }
+        return this.context.subredditName.startsWith(constants_js_1.CONTROL_SUBREDDIT) || this.getSubList().includes(this.context.subredditName);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    preEvaluatePost(post) {
+        if (!post.nsfw) {
+            return false;
+        }
+        return this.getSubList().includes(post.subredditName);
+    }
+    preEvaluateUser(user) {
+        return user.nsfw && this.isInEligibleSubreddit();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const nsfwOnly = this.getVariable("nsfwonly", false);
+        const relevantHistory = this.getPosts({ since: (0, date_fns_1.subMonths)(new Date(), 1) })
+            .filter(post => nsfwOnly ? post.nsfw : true)
+            .filter(post => this.getSubList().includes(post.subredditName));
+        const distinctSubreddits = (0, lodash_1.uniq)(relevantHistory.map(item => item.subredditName));
+        const distinctSubGroups = (0, lodash_1.uniq)(this.getWTSubGroups()
+            .filter(group => distinctSubreddits.some(sub => group.subs.includes(sub)))
+            .map(group => group.group));
+        const requiredSubCount = this.getVariable("distinctgroups", 5);
+        return distinctSubGroups.length >= requiredSubCount;
+    }
+}
+exports.EvaluateWorldTraveller = EvaluateWorldTraveller;

package/dist/userEvaluation/UserEvaluatorBase.d.ts

@@ -0,0 +1,67 @@
+import { CommentCreate, CommentUpdate } from "@devvit/protos";
+import { Comment, Post, TriggerContext, UserSocialLink } from "@devvit/public-api";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+interface HistoryOptions {
+    since?: Date;
+    omitRemoved?: boolean;
+    edited?: boolean;
+}
+export interface ValidationIssue {
+    severity: "error" | "warning";
+    message: string;
+}
+export interface EvaluatorRegex {
+    evaluatorName: string;
+    subName?: string;
+    regex: string;
+    flags?: string;
+}
+export interface HitReasonDetailed {
+    reason: string;
+    details: {
+        key: string;
+        value: string;
+    }[];
+}
+export type HitReason = string | HitReasonDetailed;
+export declare abstract class UserEvaluatorBase {
+    protected context: TriggerContext;
+    private variables;
+    abstract name: string;
+    abstract shortname: string;
+    socialLinks: UserSocialLink[] | undefined;
+    readonly needsOpenAiKey: boolean;
+    protected openAiKey: string | undefined;
+    banContentThreshold: number;
+    canAutoBan: boolean;
+    protected history: (Post | Comment)[];
+    private userPosts;
+    private userComments;
+    protected ignoredSubs: Set<string>;
+    constructor(context: TriggerContext, history: (Post | Comment)[], socialLinks: UserSocialLink[] | undefined, variables: Record<string, unknown>);
+    setHistory(history: (Post | Comment)[]): void;
+    setSocialLinks(socialLinks: UserSocialLink[]): void;
+    setOpenAiKey(key: string): void;
+    evaluatorDisabled(): boolean;
+    validateVariables(): ValidationIssue[];
+    gatherRegexes(): EvaluatorRegex[];
+    getSubGroups(): string[] | undefined;
+    getVariableOverrides(): Record<string, unknown>;
+    protected getAllVariables(filter?: string): Record<string, unknown>;
+    protected getVariable<Type>(name: string, defaultValue: Type): Type;
+    protected getGenericVariable<Type>(name: string, defaultValue: Type): Type;
+    protected getModuleVariable<Type>(module: string, name: string, defaultValue: Type): Type;
+    protected getSocialLinks(username: string): Promise<UserSocialLink[]>;
+    protected addHitReason(reason: HitReason): void;
+    hitReasons: HitReason[] | undefined;
+    abstract preEvaluateComment(event: CommentCreate): boolean | Promise<boolean>;
+    preEvaluateCommentEdit(event: CommentUpdate): boolean | Promise<boolean>;
+    abstract preEvaluatePost(post: Post): boolean | Promise<boolean>;
+    preEvaluatePostEdit(post: Post): boolean | Promise<boolean>;
+    abstract preEvaluateUser(user: UserExtended): boolean | Promise<boolean>;
+    abstract evaluate(user: UserExtended): boolean | Promise<boolean>;
+    private getContent;
+    protected getComments(options?: HistoryOptions): Comment[];
+    protected getPosts(options?: HistoryOptions): Post[];
+}
+export {};

package/dist/userEvaluation/UserEvaluatorBase.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserEvaluatorBase = void 0;
+const tid_js_1 = require("@devvit/public-api/types/tid.js");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+class UserEvaluatorBase {
+    constructor(context, history, socialLinks, variables) {
+        this.variables = {};
+        this.needsOpenAiKey = false;
+        this.banContentThreshold = 10;
+        this.canAutoBan = true;
+        this.hitReasons = undefined;
+        this.context = context;
+        this.socialLinks = socialLinks;
+        this.variables = variables;
+        this.ignoredSubs = new Set(this.getGenericVariable("ignoredsubs", []));
+        this.history = history;
+    }
+    setHistory(history) {
+        this.history = history;
+        this.userPosts = undefined;
+        this.userComments = undefined;
+    }
+    setSocialLinks(socialLinks) {
+        this.socialLinks = socialLinks;
+    }
+    setOpenAiKey(key) {
+        this.openAiKey = key;
+    }
+    evaluatorDisabled() {
+        return this.getVariable("killswitch", false);
+    }
+    validateVariables() {
+        return [];
+    }
+    gatherRegexes() {
+        return [];
+    }
+    getSubGroups() {
+        return;
+    }
+    getVariableOverrides() {
+        return {};
+    }
+    getAllVariables(filter) {
+        const result = {};
+        const root = this.shortname + ":" + (filter ?? "");
+        for (const key in this.variables) {
+            if (key.startsWith(root)) {
+                result[key] = this.variables[key];
+            }
+        }
+        return result;
+    }
+    getVariable(name, defaultValue) {
+        return this.variables[`${this.shortname}:${name}`] ?? defaultValue;
+    }
+    getGenericVariable(name, defaultValue) {
+        return this.variables[`generic:${name}`] ?? defaultValue;
+    }
+    getModuleVariable(module, name, defaultValue) {
+        return this.variables[`${module}:${name}`] ?? defaultValue;
+    }
+    async getSocialLinks(username) {
+        this.socialLinks ?? (this.socialLinks = await (0, evaluatorHelpers_js_1.getSocialLinksWithCache)(username, this.context));
+        return this.socialLinks;
+    }
+    addHitReason(reason) {
+        if (!this.hitReasons) {
+            this.hitReasons = [reason];
+        }
+        else {
+            this.hitReasons.push(reason);
+        }
+    }
+    preEvaluateCommentEdit(event) {
+        return this.preEvaluateComment(event);
+    }
+    preEvaluatePostEdit(post) {
+        return this.preEvaluatePost(post);
+    }
+    getContent(history, options) {
+        if (!options) {
+            return history;
+        }
+        const filteredHistory = history.filter((item) => {
+            if (options.since && item.createdAt < options.since) {
+                return false;
+            }
+            if (options.omitRemoved && item.body === "[removed]") {
+                return false;
+            }
+            if (options.edited !== undefined) {
+                return item.edited === options.edited;
+            }
+            return true;
+        });
+        return filteredHistory;
+    }
+    getComments(options) {
+        this.userComments ?? (this.userComments = this.history.filter(item => (0, tid_js_1.isCommentId)(item.id) && !this.ignoredSubs.has(item.subredditName)));
+        return this.getContent(this.userComments, options);
+    }
+    getPosts(options) {
+        this.userPosts ?? (this.userPosts = this.history.filter(item => (0, tid_js_1.isLinkId)(item.id) && !this.ignoredSubs.has(item.subredditName)));
+        return this.getContent(this.userPosts, options);
+    }
+}
+exports.UserEvaluatorBase = UserEvaluatorBase;

package/dist/userEvaluation/evaluatorHelpers.d.ts

@@ -0,0 +1,3 @@
+import { TriggerContext, UserSocialLink } from "@devvit/public-api";
+export declare function domainFromUrl(url: string): string | undefined;
+export declare function getSocialLinksWithCache(username: string, context: TriggerContext): Promise<UserSocialLink[]>;

package/dist/userEvaluation/evaluatorHelpers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.domainFromUrl = domainFromUrl;
+exports.getSocialLinksWithCache = getSocialLinksWithCache;
+const date_fns_1 = require("date-fns");
+const devvit_helpers_1 = require("devvit-helpers");
+function domainFromUrl(url) {
+    if (!url || url.startsWith("/")) {
+        // Reddit internal link or crosspost
+        return;
+    }
+    const hostname = new URL(url).hostname;
+    const trimmedHostname = hostname.startsWith("www.") ? hostname.substring(4) : hostname;
+    return trimmedHostname;
+}
+async function getSocialLinksWithCache(username, context) {
+    const cacheKey = `socialLinks:${username}`;
+    const cachedValue = await context.redis.get(cacheKey);
+    if (cachedValue) {
+        return JSON.parse(cachedValue);
+    }
+    const userSocialLinks = await (0, devvit_helpers_1.getUserSocialLinks)(username, context.metadata);
+    await context.redis.set(cacheKey, JSON.stringify(userSocialLinks), { expiration: (0, date_fns_1.addMinutes)(new Date(), 5) });
+    return userSocialLinks;
+}

package/dist/userEvaluation/index.d.ts

@@ -0,0 +1,26 @@
+export * from "./EvaluateBadDisplayname.js";
+export * from "./EvaluateBadDisplaynameDefinedHandles.js";
+export * from "./EvaluateBadUsername.js";
+export * from "./EvaluateBioText.js";
+export * from "./EvaluateBioTextDefinedHandles.js";
+export * from "./EvaluateCommentPhrase.js";
+export * from "./EvaluateDomainSharer.js";
+export * from "./EvaluateInconsistentAgeBot.js";
+export * from "./EvaluateInconsistentGenderBot.js";
+export * from "./EvaluateLinkReuse.js";
+export * from "./EvaluateObfuscatedBioKeywords.js";
+export * from "./EvaluatePinnedPostTitle.js";
+export * from "./EvaluatePostTitle.js";
+export * from "./EvaluatePostTitleDefinedHandles.js";
+export * from "./EvaluatePostTitleMulti.js";
+export * from "./EvaluateSelfComment.js";
+export * from "./EvaluateSocialLinks.js";
+export * from "./EvaluateSuspiciousFirstPost.js";
+export * from "./EvaluateTGGroup.js";
+export * from "./EvaluateWarmupBot.js";
+export * from "./EvaluateBotGroupAdvanced.js";
+export * from "./EvaluateBotGroupAdvancedInternal.js";
+export * from "./EvaluateTitleCopyBot.js";
+export * from "./EvaluateWorldTraveller.js";
+export * from "./EvaluateBotGroupSubmitters.js";
+export * from "./UserEvaluatorBase.js";

package/dist/userEvaluation/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./EvaluateBadDisplayname.js"), exports);
+__exportStar(require("./EvaluateBadDisplaynameDefinedHandles.js"), exports);
+__exportStar(require("./EvaluateBadUsername.js"), exports);
+__exportStar(require("./EvaluateBioText.js"), exports);
+__exportStar(require("./EvaluateBioTextDefinedHandles.js"), exports);
+__exportStar(require("./EvaluateCommentPhrase.js"), exports);
+__exportStar(require("./EvaluateDomainSharer.js"), exports);
+__exportStar(require("./EvaluateInconsistentAgeBot.js"), exports);
+__exportStar(require("./EvaluateInconsistentGenderBot.js"), exports);
+__exportStar(require("./EvaluateLinkReuse.js"), exports);
+__exportStar(require("./EvaluateObfuscatedBioKeywords.js"), exports);
+__exportStar(require("./EvaluatePinnedPostTitle.js"), exports);
+__exportStar(require("./EvaluatePostTitle.js"), exports);
+__exportStar(require("./EvaluatePostTitleDefinedHandles.js"), exports);
+__exportStar(require("./EvaluatePostTitleMulti.js"), exports);
+__exportStar(require("./EvaluateSelfComment.js"), exports);
+__exportStar(require("./EvaluateSocialLinks.js"), exports);
+__exportStar(require("./EvaluateSuspiciousFirstPost.js"), exports);
+__exportStar(require("./EvaluateTGGroup.js"), exports);
+__exportStar(require("./EvaluateWarmupBot.js"), exports);
+__exportStar(require("./EvaluateBotGroupAdvanced.js"), exports);
+__exportStar(require("./EvaluateBotGroupAdvancedInternal.js"), exports);
+__exportStar(require("./EvaluateTitleCopyBot.js"), exports);
+__exportStar(require("./EvaluateWorldTraveller.js"), exports);
+__exportStar(require("./EvaluateBotGroupSubmitters.js"), exports);
+__exportStar(require("./UserEvaluatorBase.js"), exports);

package/dist/utility.d.ts

@@ -0,0 +1,34 @@
+import { JSONValue, TriggerContext, User } from "@devvit/public-api";
+import { Document } from "yaml";
+export declare function getUserOrUndefined(username: string, context: TriggerContext): Promise<User | undefined>;
+export interface DuplicateKeyInfo {
+    key: string;
+    path: string;
+    line: number;
+    col: number;
+}
+export declare function findDuplicateKeysInDoc(doc: Document.Parsed): DuplicateKeyInfo[];
+export declare function yamlToVariables(input: string, extraSubstitutions?: Record<string, string | string[]>): Record<string, JSONValue>;
+export interface AdditionalUserInfo {
+    createdAt: Date;
+    userDescription?: string;
+    displayName?: string;
+    nsfw: boolean;
+    commentKarma: number;
+    linkKarma: number;
+    hasRedditPremium: boolean;
+    hasVerifiedEmail: boolean;
+    isSubredditModerator: boolean;
+}
+export interface AdditionalUserInfo {
+    createdAt: Date;
+    userDescription?: string;
+    displayName?: string;
+    nsfw: boolean;
+    commentKarma: number;
+    linkKarma: number;
+    hasRedditPremium: boolean;
+    hasVerifiedEmail: boolean;
+    isSubredditModerator: boolean;
+}
+export declare function getAdditionalUserInfo(username: string, context: TriggerContext): Promise<AdditionalUserInfo | undefined>;

package/dist/utility.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserOrUndefined = getUserOrUndefined;
+exports.findDuplicateKeysInDoc = findDuplicateKeysInDoc;
+exports.yamlToVariables = yamlToVariables;
+exports.getAdditionalUserInfo = getAdditionalUserInfo;
+const fsv_devvit_helpers_1 = require("@fsvreddit/fsv-devvit-helpers");
+const date_fns_1 = require("date-fns");
+const yaml_1 = require("yaml");
+async function getUserOrUndefined(username, context) {
+    let user;
+    try {
+        user = await context.reddit.getUserByUsername(username);
+    }
+    catch {
+        //
+    }
+    return user;
+}
+function getSubstitutionsListFromYaml(yaml) {
+    const yamlDocuments = (0, yaml_1.parseAllDocuments)(yaml);
+    const substitutions = {};
+    for (const document of yamlDocuments) {
+        const json = document.toJSON();
+        if (json?.name !== "substitutions") {
+            continue;
+        }
+        for (const key in json) {
+            if (key !== "name") {
+                substitutions[key] = json[key];
+            }
+        }
+    }
+    return substitutions;
+}
+function findDuplicateKeysInDoc(doc) {
+    const duplicates = [];
+    function walk(node, path) {
+        // Only YAMLMap nodes have .items
+        if (!(node instanceof yaml_1.YAMLMap)) {
+            return;
+        }
+        const seen = new Map();
+        for (const pair of node.items) {
+            const keyNode = pair.key;
+            const key = keyNode?.value;
+            if (typeof key !== "string") {
+                continue;
+            }
+            const childPath = [...path, key];
+            if (seen.has(key)) {
+                const [line, col] = keyNode?.range ?? [0, 0];
+                duplicates.push({
+                    key,
+                    path: childPath.join("."),
+                    line,
+                    col,
+                });
+            }
+            else {
+                seen.set(key, true);
+            }
+            walk(pair.value, childPath);
+        }
+    }
+    walk(doc.contents, []);
+    return duplicates;
+}
+function yamlToVariables(input, extraSubstitutions = {}) {
+    const substitutionsList = { ...getSubstitutionsListFromYaml(input), ...extraSubstitutions };
+    let yaml = input;
+    for (const key in substitutionsList) {
+        if (typeof substitutionsList[key] === "string") {
+            yaml = yaml.replaceAll(`{{${key}}}`, substitutionsList[key]);
+        }
+        else {
+            // Handle array substitutions
+            yaml = yaml.replaceAll(`{{${key}}}`, JSON.stringify(substitutionsList[key]));
+        }
+    }
+    const variables = {};
+    const yamlDocuments = (0, yaml_1.parseAllDocuments)(yaml);
+    const modulesSeen = new Set();
+    const errors = [];
+    let index = 0;
+    for (const doc of yamlDocuments) {
+        const json = doc.toJSON();
+        if (!json) {
+            // Empty document
+            continue;
+        }
+        const root = json.name;
+        if (!root) {
+            console.error(`Evaluator Variables: Error parsing evaluator variables from wiki. Missing root name on document ${index}.`);
+            continue;
+        }
+        const duplicates = findDuplicateKeysInDoc(doc);
+        if (duplicates.length > 0) {
+            for (const duplicate of duplicates) {
+                const error = `Duplicate key "${duplicate.key}" found at path "${duplicate.path}" in module "${root}".`;
+                errors.push(error);
+            }
+        }
+        if (modulesSeen.has(root)) {
+            errors.push(`Module name ${root} is present more than once`);
+        }
+        else {
+            modulesSeen.add(root);
+        }
+        for (const key in json) {
+            if (key !== "name") {
+                variables[`${root}:${key}`] = json[key];
+            }
+        }
+        index++;
+    }
+    variables.errors = errors;
+    return variables;
+}
+async function getAdditionalUserInfo(username, context) {
+    const cacheKey = `bbe:additionalUserInfo:${username}`;
+    const cachedData = await context.redis.get(cacheKey);
+    if (cachedData) {
+        const parsedData = JSON.parse(cachedData);
+        return {
+            createdAt: new Date(parsedData.createdAt),
+            userDescription: parsedData.userDescription,
+            displayName: parsedData.displayName,
+            nsfw: parsedData.nsfw,
+            commentKarma: parsedData.commentKarma,
+            linkKarma: parsedData.linkKarma,
+            hasRedditPremium: parsedData.hasRedditPremium,
+            hasVerifiedEmail: parsedData.hasVerifiedEmail,
+            isSubredditModerator: parsedData.isSubredditModerator,
+        };
+    }
+    const user = await (0, fsv_devvit_helpers_1.getUserExtended)(username, context);
+    if (!user) {
+        return;
+    }
+    const dataToCache = {
+        createdAt: user.createdAt.getTime(),
+        userDescription: user.userDescription,
+        displayName: user.displayName,
+        nsfw: user.nsfw,
+        commentKarma: user.commentKarma,
+        linkKarma: user.linkKarma,
+        hasRedditPremium: user.isGold,
+        hasVerifiedEmail: user.hasVerifiedEmail,
+        isSubredditModerator: user.isModerator,
+    };
+    await context.redis.set(cacheKey, JSON.stringify(dataToCache), { expiration: (0, date_fns_1.addMinutes)(new Date(), 10) });
+    return {
+        createdAt: user.createdAt,
+        userDescription: user.userDescription,
+        displayName: user.displayName,
+        nsfw: user.nsfw,
+        commentKarma: user.commentKarma,
+        linkKarma: user.linkKarma,
+        hasRedditPremium: user.isGold,
+        hasVerifiedEmail: user.hasVerifiedEmail,
+        isSubredditModerator: user.isModerator,
+    };
+}

package/eslint.config.mjs

@@ -0,0 +1,3 @@
+import fsvconfig from "@fsvreddit/eslint-config";
+
+export default fsvconfig;

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@fsvreddit/bot-bouncer-evaluation",
+    "version": "0.7.40",
+    "description": "Evaluation code for Bot Bouncer, a Dev Platform app designed to hunt bots on Reddit",
+    "main": "dist/index.js",
+    "scripts": {
+        "test": "npm run test:unit",
+        "test:unit": "vitest --run",
+        "lint": "eslint . --ext .ts",
+        "build": "tsc --project tsconfig.build.json",
+        "prepare": "npm run build"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/fsvreddit/bot-bouncer-evaluation.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "author": "fsv",
+    "license": "BSD-3-Clause",
+    "dependencies": {
+        "@fsvreddit/fsv-devvit-helpers": "^0.1.13",
+        "@wordpress/wordcount": "^4.53.0",
+        "date-fns": "^4.1.0",
+        "devvit-helpers": "^0.11.0",
+        "lodash": "^4.17.21",
+        "markdown-escape": "^2.0.0",
+        "openai": "^7.5.0",
+        "regjsparser": "^0.13.0",
+        "yaml": "^2.8.0",
+        "zod": "^4.4.3"
+    },
+    "devDependencies": {
+        "@fsvreddit/eslint-config": "^0.1.0",
+        "@types/lodash": "^4.17.17",
+        "@types/markdown-escape": "^1.1.3",
+        "eslint": "^10.0.2",
+        "typescript": "^5.8.3",
+        "vitest": "^4.0.15"
+    },
+    "keywords": [
+        "reddit",
+        "devvit"
+    ],
+    "peerDependencies": {
+        "@devvit/protos": "^0.14.1",
+        "@devvit/public-api": "^0.14.1"
+    }
+}

package/tsconfig.build.json

@@ -0,0 +1,14 @@
+{
+    "extends": "./tsconfig.json",
+    "exclude": [
+        "vitest.config.ts",
+        "node_modules",
+        "tests",
+        "dist",
+        "eslint.config.mjs"
+    ],
+    "compilerOptions": {
+        "rootDir": "src",
+        "outDir": "dist",
+    }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "extends": "@devvit/public-api/devvit.tsconfig.json",
+    "compilerOptions": {
+        "target": "ES2020",
+        "lib": [
+            "ES2022",
+            "WebWorker"
+        ],
+        "resolveJsonModule": true,
+        "declaration": true,
+        "outDir": "dist",
+        "strict": true,
+        "esModuleInterop": true,
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+    },
+    "exclude": [
+        "**/node_modules",
+        "dist",
+        "**/.*/",
+        "eslint.config.mjs"
+    ]
+}