@devvit/build-pack 0.12.0-next-2025-04-30-5d2b49b36.0 → 0.12.0-next-2025-08-12-20-06-14-50f19bb3e.0

package/esbuild/ESBuildPack.js

@@ -9,24 +9,26 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Watcher_instances, _Watcher_disableExternDevvitProtos, _Watcher_typeChecker, _Watcher_targetRuntimes, _Watcher_root, _Watcher_observable, _Watcher_disposedNotifier, _Watcher_disposeWatcher, _Watcher_namespace, _Watcher_buildTargets, _Watcher_ready, _Watcher_init, _Watcher_makeEsbuildContext, _Watcher_onBuildEnd, _ESBuildPack_bundleWatchers, _ESBuildPack_namespace, _ESBuildPack_disableExternDevvitProtos, _ESBuildPack_typeChecker, _ESBuildPack_disableTypeCheckerWarning;
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import { Bundle, CompileLog, CompileResponse, Minify, } from '@devvit/protos/types/devvit/plugin/buildpack/buildpack_common.js';
+var _Watcher_instances, _Watcher_disableExternDevvitProtos, _Watcher_config, _Watcher_root, _Watcher_observable, _Watcher_disposedNotifier, _Watcher_disposeWatcher, _Watcher_namespace, _Watcher_buildTargets, _Watcher_ready, _Watcher_init, _Watcher_makeEntry, _Watcher_makeEsbuildContext, _Watcher_onBuildEnd, _ESBuildPack_bundleWatchers, _ESBuildPack_namespace, _ESBuildPack_disableExternDevvitProtos;
+import fs, { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { Bundle } from '@devvit/protos/types/devvit/plugin/buildpack/buildpack_common.js';
 import { TargetRuntime, } from '@devvit/protos/types/devvit/runtime/bundle.js';
 import { ConfigImpl as Config } from '@devvit/shared-types/ConfigImpl.js';
-import { assertNonNull, NonNull } from '@devvit/shared-types/NonNull.js';
+import { NonNull } from '@devvit/shared-types/NonNull.js';
 import { StringUtil } from '@devvit/shared-types/StringUtil.js';
 import esbuild, {} from 'esbuild';
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { of } from 'rxjs';
 import { takeUntil } from 'rxjs/operators';
-import glob from 'tiny-glob';
-import { getModuleEntrypoint } from '../lib/BuildPack.js';
+import { getClassicModuleEntrypoint, getModuleEntrypoint } from '../lib/BuildPack.js';
 import { newBuildInfoDependencies } from './BuildInfoUtil.js';
 import { dangerouslyGetBundleActor } from './BundleModule.js';
+import { createDependencySpec } from './dependency-spec-util.js';
 import { externalizeDevvitProtos } from './plugins/externalizeDevvitProtos.js';
 import { postProcessServerStubCode, serverClientCodeSplit, } from './plugins/serverClientCodeSplit.js';
-import { mergeCompileRes, prefixBuildResultLogs } from './utils.js';
+import { templatize } from './templatizer/templatizer.js';
+import { prefixBuildResultLogs } from './utils.js';
 const FAKE_FACTORY = {
     // TODO: remove use of any below
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -38,11 +40,10 @@ export class Watcher {
      * The default behavior is to externalize @devvit/protos. Set
      * disableExternDevvitProtos to bundle this large dependency.
      */
-    constructor(namespace, root, actorSpec, options) {
+    constructor(config, namespace, root, actorSpec, options) {
         _Watcher_instances.add(this);
         _Watcher_disableExternDevvitProtos.set(this, void 0);
-        _Watcher_typeChecker.set(this, void 0);
-        _Watcher_targetRuntimes.set(this, void 0);
+        _Watcher_config.set(this, void 0);
         _Watcher_root.set(this, void 0);
         /**
          * the actual emitter of updates
@@ -59,11 +60,10 @@ export class Watcher {
         _Watcher_namespace.set(this, void 0);
         _Watcher_buildTargets.set(this, new Map());
         _Watcher_ready.set(this, void 0);
+        __classPrivateFieldSet(this, _Watcher_config, config, "f");
         __classPrivateFieldSet(this, _Watcher_namespace, namespace, "f");
         __classPrivateFieldSet(this, _Watcher_root, root, "f");
         __classPrivateFieldSet(this, _Watcher_disableExternDevvitProtos, options?.disableExternDevvitProtos ?? false, "f");
-        __classPrivateFieldSet(this, _Watcher_typeChecker, options?.typeChecker, "f");
-        __classPrivateFieldSet(this, _Watcher_targetRuntimes, options?.targetRuntimes ?? BUILD_TARGETS, "f");
         //  observers of this will be subscribed until this.disposedNotifier emits a value
         const sourceObservable = new Observable().pipe(takeUntil(__classPrivateFieldGet(this, _Watcher_disposedNotifier, "f")));
         // our observable is a BehaviorSubject used to multicast the source observer
@@ -88,11 +88,12 @@ export class Watcher {
         __classPrivateFieldGet(this, _Watcher_disposedNotifier, "f").complete();
     }
 }
-_Watcher_disableExternDevvitProtos = new WeakMap(), _Watcher_typeChecker = new WeakMap(), _Watcher_targetRuntimes = new WeakMap(), _Watcher_root = new WeakMap(), _Watcher_observable = new WeakMap(), _Watcher_disposedNotifier = new WeakMap(), _Watcher_disposeWatcher = new WeakMap(), _Watcher_namespace = new WeakMap(), _Watcher_buildTargets = new WeakMap(), _Watcher_ready = new WeakMap(), _Watcher_instances = new WeakSet(), _Watcher_init = async function _Watcher_init(actorSpec) {
+_Watcher_disableExternDevvitProtos = new WeakMap(), _Watcher_config = new WeakMap(), _Watcher_root = new WeakMap(), _Watcher_observable = new WeakMap(), _Watcher_disposedNotifier = new WeakMap(), _Watcher_disposeWatcher = new WeakMap(), _Watcher_namespace = new WeakMap(), _Watcher_buildTargets = new WeakMap(), _Watcher_ready = new WeakMap(), _Watcher_instances = new WeakSet(), _Watcher_init = async function _Watcher_init(actorSpec) {
+    const entry = __classPrivateFieldGet(this, _Watcher_instances, "m", _Watcher_makeEntry).call(this);
     // Building for Universal and Client targets. May include Server in the future.
-    for (const target of __classPrivateFieldGet(this, _Watcher_targetRuntimes, "f")) {
+    for (const target of BUILD_TARGETS) {
         __classPrivateFieldGet(this, _Watcher_buildTargets, "f").set(target, {
-            ctx: await __classPrivateFieldGet(this, _Watcher_instances, "m", _Watcher_makeEsbuildContext).call(this, actorSpec, target),
+            ctx: await __classPrivateFieldGet(this, _Watcher_instances, "m", _Watcher_makeEsbuildContext).call(this, actorSpec, target, entry),
         });
     }
     __classPrivateFieldSet(this, _Watcher_disposeWatcher, async () => {
@@ -110,12 +111,19 @@ _Watcher_disableExternDevvitProtos = new WeakMap(), _Watcher_typeChecker = new W
         watchers.push(target.ctx.watch());
     }
     await Promise.all(watchers);
-}, _Watcher_makeEsbuildContext = async function _Watcher_makeEsbuildContext(actorSpec, targetRuntime) {
-    const entryPoint = getModuleEntrypoint(__classPrivateFieldGet(this, _Watcher_root, "f"));
-    const cfg = esbuildConfig(__classPrivateFieldGet(this, _Watcher_disableExternDevvitProtos, "f"), targetRuntime, true);
+}, _Watcher_makeEntry = function _Watcher_makeEntry() {
+    // The watched file doesn't change but its dependencies do.
+    const entry = getModuleEntrypoint(__classPrivateFieldGet(this, _Watcher_config, "f"), __classPrivateFieldGet(this, _Watcher_root, "f"));
+    if (__classPrivateFieldGet(this, _Watcher_config, "f")) {
+        const template = templatize(__classPrivateFieldGet(this, _Watcher_root, "f"), __classPrivateFieldGet(this, _Watcher_config, "f").blocks?.entry);
+        fs.writeFileSync(entry, template);
+    }
+    return entry;
+}, _Watcher_makeEsbuildContext = async function _Watcher_makeEsbuildContext(actorSpec, targetRuntime, entry) {
+    const cfg = esbuildConfig(__classPrivateFieldGet(this, _Watcher_config, "f"), __classPrivateFieldGet(this, _Watcher_disableExternDevvitProtos, "f"), targetRuntime, true);
     return await esbuild.context({
         ...cfg,
-        entryPoints: [entryPoint],
+        entryPoints: [entry],
         minify: false,
         sourcemap: 'external',
         outfile: 'main.js',
@@ -125,7 +133,7 @@ _Watcher_disableExternDevvitProtos = new WeakMap(), _Watcher_typeChecker = new W
                 name: 'optionally-type-check-and-publish-compile-result-on-build-end',
                 setup: (build) => {
                     build.onEnd(async (result) => {
-                        await __classPrivateFieldGet(this, _Watcher_instances, "m", _Watcher_onBuildEnd).call(this, actorSpec, result, entryPoint, targetRuntime);
+                        await __classPrivateFieldGet(this, _Watcher_instances, "m", _Watcher_onBuildEnd).call(this, actorSpec, result, targetRuntime);
                     });
                 },
             },
@@ -137,7 +145,7 @@ _Watcher_disableExternDevvitProtos = new WeakMap(), _Watcher_typeChecker = new W
 /**
  * @description The callback function for esbuild's onEnd hook. This is called after esbuild has finished building.
  */
-async function _Watcher_onBuildEnd(actorSpec, esbuildResult, entryPoint, targetRuntime) {
+async function _Watcher_onBuildEnd(actorSpec, esbuildResult, targetRuntime) {
     await __classPrivateFieldGet(this, _Watcher_ready, "f");
     __classPrivateFieldGet(this, _Watcher_buildTargets, "f").get(targetRuntime).result = esbuildResult;
     const results = new Map();
@@ -147,22 +155,12 @@ async function _Watcher_onBuildEnd(actorSpec, esbuildResult, entryPoint, targetR
             return;
         results.set(targetRuntime, target.result);
     }
-    const esbuildCompileRes = await newCompileResponse(__classPrivateFieldGet(this, _Watcher_namespace, "f"), actorSpec, results, entryPoint);
+    const esbuildCompileRes = await newCompileResponse(__classPrivateFieldGet(this, _Watcher_config, "f"), __classPrivateFieldGet(this, _Watcher_namespace, "f"), actorSpec, results, __classPrivateFieldGet(this, _Watcher_root, "f"));
     // clear saved values so we don't double-fire the next time we get results
     for (const [_, target] of __classPrivateFieldGet(this, _Watcher_buildTargets, "f")) {
         target.result = undefined;
     }
-    // to-do: why is type-checking disabled for projects with tsx files (nearly
-    //        all projects).
-    if (!__classPrivateFieldGet(this, _Watcher_typeChecker, "f") || (await hasTsxFiles(__classPrivateFieldGet(this, _Watcher_root, "f")))) {
-        console.warn('Type checking is disabled.');
-        __classPrivateFieldGet(this, _Watcher_observable, "f").next(esbuildCompileRes);
-        return;
-    }
-    const typeCheckCompileRes = await __classPrivateFieldGet(this, _Watcher_typeChecker, "f").check({
-        filename: __classPrivateFieldGet(this, _Watcher_root, "f"),
-    });
-    __classPrivateFieldGet(this, _Watcher_observable, "f").next(mergeCompileRes(esbuildCompileRes, typeCheckCompileRes));
+    __classPrivateFieldGet(this, _Watcher_observable, "f").next(esbuildCompileRes);
 };
 export class ESBuildPack {
     /**
@@ -178,35 +176,32 @@ export class ESBuildPack {
         _ESBuildPack_namespace.set(this, void 0);
         // EsbuildPack options
         _ESBuildPack_disableExternDevvitProtos.set(this, void 0);
-        // type chcecking will be disabled if typeChecker is undefined
-        _ESBuildPack_typeChecker.set(this, void 0);
-        // don't print out warnings if this is set
-        _ESBuildPack_disableTypeCheckerWarning.set(this, void 0);
         __classPrivateFieldSet(this, _ESBuildPack_namespace, namespace, "f");
         __classPrivateFieldSet(this, _ESBuildPack_disableExternDevvitProtos, options?.disableExternDevvitProtos ?? false, "f");
-        __classPrivateFieldSet(this, _ESBuildPack_typeChecker, options?.typeChecker, "f");
-        __classPrivateFieldSet(this, _ESBuildPack_disableTypeCheckerWarning, options?.disableTypeCheckerWarning ?? false, "f");
     }
-    async Compile({ filename, minify, info, includeMetafile }, _metadata) {
-        // TODO: add flag to conditionally compile stripped bundle
-        if (filename == null) {
-            // TODO: implement virtualFileSystem
-            throw new Error('Bundling virtual file system not implemented yet');
+    async compile({ config, minify, info, includeMetafile, root, }) {
+        const entry = getModuleEntrypoint(config, root);
+        if (config) {
+            const template = templatize(root, config.blocks?.entry);
+            try {
+                fs.writeFileSync(entry, template);
+            }
+            catch (err) {
+                return unknownToErrorCompileResponse('Compilation', err);
+            }
         }
-        assertNonNull(info, "Expected 'info' of CompileParams to be non-null");
-        const entrypoint = getModuleEntrypoint(filename);
         const buildResults = new Map();
         for (const targetRuntime of BUILD_TARGETS) {
-            const cfg = esbuildConfig(__classPrivateFieldGet(this, _ESBuildPack_disableExternDevvitProtos, "f"), targetRuntime);
+            const cfg = esbuildConfig(config, __classPrivateFieldGet(this, _ESBuildPack_disableExternDevvitProtos, "f"), targetRuntime);
             try {
                 const buildResult = await esbuild.build({
                     ...cfg,
-                    entryPoints: [entrypoint],
+                    entryPoints: [entry],
                     metafile: true,
                     sourcemap: 'external',
                     plugins: [excludeNodeModulesFromSourceMapsPlugin(), ...(cfg.plugins || [])],
                     sourcesContent: false,
-                    minify: minify === Minify.ALL,
+                    minify: minify === 'All',
                     outfile: 'main.js',
                     treeShaking: true,
                 });
@@ -214,46 +209,40 @@ export class ESBuildPack {
             }
             catch (err) {
                 return isEsbuildResult(err)
-                    ? await newCompileResponse(__classPrivateFieldGet(this, _ESBuildPack_namespace, "f"), info, new Map([[targetRuntime, err]]), entrypoint, includeMetafile)
+                    ? await newCompileResponse(config, __classPrivateFieldGet(this, _ESBuildPack_namespace, "f"), info, new Map([[targetRuntime, err]]), root, includeMetafile)
                     : unknownToErrorCompileResponse('Compilation', err);
             }
         }
-        const esbuildCompileResult = await newCompileResponse(__classPrivateFieldGet(this, _ESBuildPack_namespace, "f"), info, buildResults, entrypoint, includeMetafile);
+        const esbuildCompileResult = await newCompileResponse(config, __classPrivateFieldGet(this, _ESBuildPack_namespace, "f"), info, buildResults, root, includeMetafile);
         if (esbuildCompileResult.bundles.length === 0) {
             throw new Error(esbuildCompileResult.errors?.[0]?.text ?? 'Missing bundle');
         }
-        // to-do: why is type-checking disabled for projects with tsx files (nearly
-        //        all projects).
-        if (!__classPrivateFieldGet(this, _ESBuildPack_typeChecker, "f") || (await hasTsxFiles(filename))) {
-            if (!__classPrivateFieldGet(this, _ESBuildPack_disableTypeCheckerWarning, "f"))
-                console.warn('Type checking is disabled.');
-            return esbuildCompileResult;
-        }
-        const typeCheckingResult = await __classPrivateFieldGet(this, _ESBuildPack_typeChecker, "f").check({ filename });
-        return mergeCompileRes(esbuildCompileResult, typeCheckingResult);
+        return esbuildCompileResult;
     }
     async dispose() {
         await Promise.all(Array.from(__classPrivateFieldGet(this, _ESBuildPack_bundleWatchers, "f").values()).map((watcher) => watcher.dispose()));
     }
-    Watch({ filename, info }, _metadata) {
-        assertNonNull(filename, "Expected 'filename' of CompileParams to be non-null");
-        assertNonNull(info, "Expected 'info' of CompileParams to be non-null");
-        if (!__classPrivateFieldGet(this, _ESBuildPack_bundleWatchers, "f").has(filename)) {
-            const watcher = new Watcher(__classPrivateFieldGet(this, _ESBuildPack_namespace, "f"), filename, info, {
-                disableExternDevvitProtos: __classPrivateFieldGet(this, _ESBuildPack_disableExternDevvitProtos, "f"),
-                typeChecker: __classPrivateFieldGet(this, _ESBuildPack_typeChecker, "f"),
-            });
-            __classPrivateFieldGet(this, _ESBuildPack_bundleWatchers, "f").set(filename, watcher);
+    watch({ config, root, info }) {
+        // Use a stable entrypoint, not a template.
+        const blocksEntry = config?.blocks?.entry ?? getClassicModuleEntrypoint(root);
+        if (!__classPrivateFieldGet(this, _ESBuildPack_bundleWatchers, "f").has(blocksEntry)) {
+            let watcher;
+            try {
+                watcher = new Watcher(config, __classPrivateFieldGet(this, _ESBuildPack_namespace, "f"), root, info, {
+                    disableExternDevvitProtos: __classPrivateFieldGet(this, _ESBuildPack_disableExternDevvitProtos, "f"),
+                });
+            }
+            catch (err) {
+                return of(unknownToErrorCompileResponse('Compilation', err));
+            }
+            __classPrivateFieldGet(this, _ESBuildPack_bundleWatchers, "f").set(root, watcher);
             return watcher.getObservable();
         }
-        return NonNull(__classPrivateFieldGet(this, _ESBuildPack_bundleWatchers, "f").get(filename)).getObservable();
+        return NonNull(__classPrivateFieldGet(this, _ESBuildPack_bundleWatchers, "f").get(blocksEntry)).getObservable();
     }
 }
-_ESBuildPack_bundleWatchers = new WeakMap(), _ESBuildPack_namespace = new WeakMap(), _ESBuildPack_disableExternDevvitProtos = new WeakMap(), _ESBuildPack_typeChecker = new WeakMap(), _ESBuildPack_disableTypeCheckerWarning = new WeakMap();
-// TODO: Complete way to determine dependencies from module's config.ts or config.yaml. See DX-61
-// TODO: Owner should come from project root's config file
-async function newCompileResponse(namespace, actorSpec, buildResults, entryPoint, includeMetafile = false) {
-    assertNonNull(actorSpec, 'Expected actorSpec to be non-null');
+_ESBuildPack_bundleWatchers = new WeakMap(), _ESBuildPack_namespace = new WeakMap(), _ESBuildPack_disableExternDevvitProtos = new WeakMap();
+async function newCompileResponse(config, namespace, actorSpec, buildResults, root, includeMetafile = false) {
     const errors = [];
     const warnings = [];
     const bundles = [];
@@ -289,8 +278,7 @@ async function newCompileResponse(namespace, actorSpec, buildResults, entryPoint
         }
         let dependencies;
         try {
-            const ActorClass = await dangerouslyGetBundleActor(code);
-            dependencies = await makeDependencySpec(namespace, actorSpec, ActorClass);
+            dependencies = await getDependencySpec(actorSpec, code, config, namespace);
         }
         catch (err) {
             return unknownToErrorCompileResponse('Evaluation', err);
@@ -306,31 +294,25 @@ async function newCompileResponse(namespace, actorSpec, buildResults, entryPoint
             dependencies,
             buildInfo: {
                 created: new Date(),
-                dependencies: newBuildInfoDependencies(entryPoint),
+                dependencies: newBuildInfoDependencies(root),
                 targetRuntime,
             },
             webviewAssetIds: {},
             metafile,
         });
     }
-    // remove duplicate bundles
-    const filteredBundles = [];
-    const bundleHashes = new Set();
-    bundles.forEach((bundle) => {
-        const algo = crypto.createHash('sha256');
-        algo.update(bundle.code);
-        const hash = algo.digest('hex');
-        if (!bundleHashes.has(hash)) {
-            bundleHashes.add(hash);
-            filteredBundles.push(bundle);
-        }
-    });
-    if (filteredBundles.length === 1) {
-        filteredBundles[0].buildInfo.targetRuntime = TargetRuntime.UNIVERSAL;
+    try {
+        updateBundleServer(bundles, root, config?.server);
     }
-    return { bundles: filteredBundles, errors, warnings };
+    catch {
+        const serverEntry = config?.server
+            ? path.join(config.server.dir, config.server.entry)
+            : undefined;
+        return unknownToErrorCompileResponse('Evaluation', `Cannot read \`config.server.entry\` file (${serverEntry}).`);
+    }
+    return { bundles, errors, warnings };
 }
-async function makeDependencySpec(namespace, actorSpec, ActorClass) {
+async function dangerouslyMakeDependencySpec(namespace, actorSpec, ActorClass) {
     const config = new Config(FAKE_FACTORY, actorSpec, {}, {});
     new ActorClass(config);
     const spec = config.export(namespace);
@@ -368,10 +350,22 @@ function esbuildMessageToBuildLog(msg) {
 function isEsbuildResult(err) {
     return err instanceof Object && 'errors' in err && 'warnings' in err;
 }
-function esbuildConfig(disableExternDevvitProtos, targetRuntime, watchMode = false) {
+/** Call with defined config for v1 behavior. */
+function esbuildConfig(config, disableExternDevvitProtos, targetRuntime, watchMode = false) {
     return {
+        // When Blocks migration is used, the Devvit singleton used in the template
+        // must be the same instance as that used elsewhere. Aliases are resolved
+        // from the current working directory, not the compiled file's directory, so
+        // this effectively maps the template's @devvit/public-api to the app's
+        // version. The same could be done for @devvit/server but apps don't
+        // necessarily have a copy.
+        alias: config?.blocks ? { '@devvit/public-api': '@devvit/public-api' } : {},
         // Recursively inline any imported dependencies.
         bundle: true,
+        // Tightly coupled to blocks.template.tsx.
+        define: {
+            'globalThis.__devvit__': config ? JSON.stringify({ config }, undefined, 2) : 'undefined',
+        },
         external: [
             'node:*',
             // All .js files from https://github.com/nodejs/node/tree/b2405e9/lib that
@@ -474,6 +468,50 @@ function excludeNodeModulesFromSourceMapsPlugin() {
         },
     };
 }
-async function hasTsxFiles(dir) {
-    return await glob('**/*.tsx', { cwd: dir }).then((files) => files.length > 0);
+async function getDependencySpec(actorSpec, code, config, namespace) {
+    if (config)
+        return createDependencySpec(actorSpec, config, namespace);
+    const ActorClass = await dangerouslyGetBundleActor(code);
+    return await dangerouslyMakeDependencySpec(namespace, actorSpec, ActorClass);
+}
+/** Throws when unable to read config.server.entry. */
+function newServerBundle(root, server) {
+    const serverEntry = path.join(server.dir, server.entry);
+    let code;
+    try {
+        code = readFileSync(path.resolve(root, serverEntry), 'utf8');
+    }
+    catch (err) {
+        throw Error(`Cannot read \`config.server.entry\` file (${serverEntry}).`, {
+            cause: err,
+        });
+    }
+    const sourceMapFilename = findSourceMapURL(code) ?? `${serverEntry}.map`;
+    let sourceMap = '';
+    try {
+        sourceMap = readFileSync(path.resolve(root, sourceMapFilename), 'utf8');
+    }
+    catch {
+        // source map files aren't required, safe to swallow this error
+    }
+    return { code, sourceMap };
+}
+/** @internal */
+export function findSourceMapURL(src) {
+    return /[@#]\s*sourceMappingURL=([^\s*]+)(?![\s\S]*sourceMappingURL)/.exec(src)?.[1];
+}
+/** Throws when unable to read config.server.entry. */
+export function updateBundleServer(bundles, root, server) {
+    if (!server)
+        return;
+    for (const bundle of bundles)
+        if (bundle.buildInfo?.targetRuntime === TargetRuntime.UNIVERSAL)
+            bundle.server = newServerBundle(root, server);
+}
+export function updateBundleVersion(bundles, version) {
+    for (const bundle of bundles) {
+        bundle.dependencies ??= { hostname: '', provides: [], uses: [], permissions: [] };
+        bundle.dependencies.actor ??= { name: '', owner: '', version: '' };
+        bundle.dependencies.actor.version = version.toString();
+    }
 }

package/esbuild/dependency-spec-util.d.ts

@@ -0,0 +1,10 @@
+import type { ActorSpec, DependencySpec } from '@devvit/protos/community.js';
+import type { Namespace } from '@devvit/shared-types/Namespace.js';
+import type { AppConfig } from '@devvit/shared-types/schemas/config-file.v1.js';
+/**
+ * Convert a static `AppConfig` to a `DependencySpec`. Similar to the classic
+ * `Devvit` singleton, `ConfigImpl`, `addPaymentHandler()`, and
+ * `paymentsPlugin`.
+ */
+export declare function createDependencySpec(actorSpec: Readonly<ActorSpec>, config: Readonly<Omit<AppConfig, 'json'>>, namespace: Readonly<Namespace>): DependencySpec;
+//# sourceMappingURL=dependency-spec-util.d.ts.map

package/esbuild/dependency-spec-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-spec-util.d.ts","sourceRoot":"","sources":["../../src/esbuild/dependency-spec-util.ts"],"names":[],"mappings":"AAgDA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAK7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,EACzC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,GAC7B,cAAc,CAgHhB"}

package/esbuild/dependency-spec-util.js

@@ -0,0 +1,135 @@
+import { AppSettingsDefinition, ContextActionDefinition, CustomPostDefinition, Definition, FlairDefinition, GraphQLDefinition, HTTPDefinition, InstallationSettingsDefinition, LinksAndCommentsDefinition, ListingsDefinition, MediaServiceDefinition, ModerationDefinition, ModlogDefinition, ModNoteDefinition, NewModmailDefinition, OnAppInstallDefinition, OnAppUpgradeDefinition, OnAutomoderatorFilterCommentDefinition, OnAutomoderatorFilterPostDefinition, OnCommentCreateDefinition, OnCommentDeleteDefinition, OnCommentReportDefinition, OnCommentSubmitDefinition, OnCommentUpdateDefinition, OnModActionDefinition, OnModMailDefinition, OnPostCreateDefinition, OnPostDeleteDefinition, OnPostFlairUpdateDefinition, OnPostNsfwUpdateDefinition, OnPostReportDefinition, OnPostSpoilerUpdateDefinition, OnPostSubmitDefinition, OnPostUpdateDefinition, PrivateMessagesDefinition, RealtimeDefinition, RedisAPIDefinition, SchedulerHandlerDefinition, SettingsDefinition, SubredditsDefinition, UIEventHandlerDefinition, UserActionsDefinition, UsersDefinition, WidgetsDefinition, WikiDefinition, } from '@devvit/protos';
+import { PaymentProcessorDefinition, PaymentsServiceDefinition } from '@devvit/protos/payments.js';
+import { WebbitServerDefinition } from '@devvit/protos/types/devvit/actor/webbit/webbit.js';
+import { normalizeDomains } from '@devvit/shared-types/fetch-domains.js';
+import { PLUGIN_NAME, resolveActorHostname } from '@devvit/shared-types/HostnameUtil.js';
+/**
+ * Convert a static `AppConfig` to a `DependencySpec`. Similar to the classic
+ * `Devvit` singleton, `ConfigImpl`, `addPaymentHandler()`, and
+ * `paymentsPlugin`.
+ */
+export function createDependencySpec(actorSpec, config, namespace) {
+    const spec = {
+        actor: actorSpec,
+        hostname: resolveActorHostname(actorSpec.name, namespace),
+        permissions: [],
+        provides: [],
+        uses: [],
+    };
+    const permissions = {
+        requestedFetchDomains: [],
+        asUserScopes: [],
+    };
+    if (config.permissions.http.enable) {
+        use(spec, HTTPDefinition);
+        permissions.requestedFetchDomains.push(...normalizeDomains(config.permissions.http.domains));
+    }
+    if (config.permissions.media)
+        use(spec, MediaServiceDefinition);
+    if (config.permissions.payments) {
+        use(spec, PaymentsServiceDefinition);
+        provide(spec, PaymentProcessorDefinition);
+    }
+    if (config.permissions.realtime)
+        use(spec, RealtimeDefinition);
+    if (config.permissions.reddit.enable) {
+        use(spec, FlairDefinition, GraphQLDefinition, LinksAndCommentsDefinition, ListingsDefinition, ModerationDefinition, ModNoteDefinition, NewModmailDefinition, PrivateMessagesDefinition, SubredditsDefinition, UsersDefinition, WidgetsDefinition, WikiDefinition);
+        if (config.permissions.reddit.scope === 'moderator')
+            use(spec, ModlogDefinition);
+        if (config.permissions.reddit.asUser.length > 0) {
+            use(spec, UserActionsDefinition);
+            if (config.permissions.reddit.asUser.length > 0) {
+                permissions.asUserScopes.push(...config.permissions.reddit.asUser);
+            }
+        }
+    }
+    if (config.permissions.redis)
+        use(spec, RedisAPIDefinition);
+    if (permissions.requestedFetchDomains.length > 0 || permissions.asUserScopes.length > 0) {
+        spec.permissions.push(permissions);
+    }
+    if (config.post) {
+        provide(spec, CustomPostDefinition, UIEventHandlerDefinition);
+    }
+    if (config.server)
+        provide(spec, WebbitServerDefinition);
+    if (config.permissions.menu)
+        provide(spec, ContextActionDefinition);
+    if (config.permissions.settings) {
+        use(spec, SettingsDefinition);
+        provide(spec, AppSettingsDefinition, InstallationSettingsDefinition);
+    }
+    if (config.forms)
+        provide(spec, UIEventHandlerDefinition);
+    if (config.scheduler) {
+        provide(spec, SchedulerHandlerDefinition);
+        if (Object.values(config.scheduler.tasks).some((task) => task.cron)) {
+            provide(spec, OnAppInstallDefinition);
+            provide(spec, OnAppUpgradeDefinition);
+        }
+    }
+    if (config.triggers) {
+        if (config.triggers.onAppInstall)
+            provide(spec, OnAppInstallDefinition);
+        if (config.triggers.onAppUpgrade)
+            provide(spec, OnAppUpgradeDefinition);
+        if (config.triggers.onAutomoderatorFilterComment)
+            provide(spec, OnAutomoderatorFilterCommentDefinition);
+        if (config.triggers.onAutomoderatorFilterPost)
+            provide(spec, OnAutomoderatorFilterPostDefinition);
+        if (config.triggers.onCommentCreate)
+            provide(spec, OnCommentCreateDefinition);
+        if (config.triggers.onCommentDelete)
+            provide(spec, OnCommentDeleteDefinition);
+        if (config.triggers.onCommentReport)
+            provide(spec, OnCommentReportDefinition);
+        if (config.triggers.onCommentSubmit)
+            provide(spec, OnCommentSubmitDefinition);
+        if (config.triggers.onCommentUpdate)
+            provide(spec, OnCommentUpdateDefinition);
+        if (config.triggers.onModAction)
+            provide(spec, OnModActionDefinition);
+        if (config.triggers.onModMail)
+            provide(spec, OnModMailDefinition);
+        if (config.triggers.onPostCreate)
+            provide(spec, OnPostCreateDefinition);
+        if (config.triggers.onPostDelete)
+            provide(spec, OnPostDeleteDefinition);
+        if (config.triggers.onPostFlairUpdate)
+            provide(spec, OnPostFlairUpdateDefinition);
+        if (config.triggers.onPostNsfwUpdate)
+            provide(spec, OnPostNsfwUpdateDefinition);
+        if (config.triggers.onPostReport)
+            provide(spec, OnPostReportDefinition);
+        if (config.triggers.onPostSpoilerUpdate)
+            provide(spec, OnPostSpoilerUpdateDefinition);
+        if (config.triggers.onPostSubmit)
+            provide(spec, OnPostSubmitDefinition);
+        if (config.triggers.onPostUpdate)
+            provide(spec, OnPostUpdateDefinition);
+    }
+    if (config.settings) {
+        use(spec, SettingsDefinition);
+        if (config.settings.global) {
+            provide(spec, AppSettingsDefinition);
+        }
+        if (config.settings.subreddit) {
+            provide(spec, InstallationSettingsDefinition);
+        }
+    }
+    return spec;
+}
+function provide(spec, ...definitions) {
+    spec.provides.push(...definitions
+        .filter((def) => !spec.provides.some((provide) => provide.definition?.fullName === def.fullName))
+        .map((def) => ({
+        actor: structuredClone(spec.actor),
+        definition: Definition.toSerializable(def),
+        partitionsBy: [],
+    })));
+}
+function use(spec, ...definitions) {
+    spec.uses.push(...definitions
+        .filter((def) => !spec.uses.some((use) => use.typeName === def.fullName))
+        .map((def) => ({ name: PLUGIN_NAME, typeName: def.fullName })));
+}

package/esbuild/dependency-spec-util.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-spec-util.test.d.ts","sourceRoot":"","sources":["../../src/esbuild/dependency-spec-util.test.ts"],"names":[],"mappings":""}

package/esbuild/templatizer/blocks.template.d.ts

@@ -0,0 +1,10 @@
+import { Devvit, type FormKey } from '@devvit/public-api';
+import type { UiResponse } from '@devvit/shared';
+/** @internal [state] Map of devvit.json form keys to Devvit-singleton form keys. */
+export declare const formKeyMap: {
+    [formKey: string]: FormKey;
+};
+/** @internal */
+export declare function validateUiResponse(uiResponse: UiResponse): void;
+export default Devvit;
+//# sourceMappingURL=blocks.template.d.ts.map

package/esbuild/templatizer/blocks.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.template.d.ts","sourceRoot":"","sources":["../../../src/esbuild/templatizer/blocks.template.tsx"],"names":[],"mappings":"AAGA,OAAO,EAEL,MAAM,EACN,KAAK,OAAO,EAOb,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAA8C,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAwB7F,oFAAoF;AACpF,eAAO,MAAM,UAAU,EAAE;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAA;CAAO,CAAC;AAkH7D,gBAAgB;AAChB,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CA4D/D;AA4OD,eAAe,MAAM,CAAC"}