From 9113db33e66a2d1fd9242794b010fde20b522aac Mon Sep 17 00:00:00 2001 From: Brendan Irvine-Broque Date: Sat, 17 Oct 2026 08:23:09 -0700 Subject: [PATCH 1/7] Enable the new module registry by default from 2026-11-01 Compatibility decision: use the new JavaScript module registry for compatibility dates on or after 2026-11-01, including import.meta, URL-based resolution, import attribute validation, and Node.js require(esm) semantics. Earlier dates retain the opt-in behavior and legacy_module_registry remains an opt-out. Python Workers retain the legacy registry. Allow the scheduled Sunday date in the existing weekday guard. Remove the standalone server experimental-mode restriction so date-enabled Workers can start without --experimental. --- src/workerd/io/compatibility-date-test.c++ | 6 ++++-- src/workerd/io/compatibility-date.capnp | 3 ++- src/workerd/server/factory/worker-factory.c++ | 3 --- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/workerd/io/compatibility-date-test.c++ b/src/workerd/io/compatibility-date-test.c++ index ede8f3eed6b..b15d891ef46 100644 --- a/src/workerd/io/compatibility-date-test.c++ +++ b/src/workerd/io/compatibility-date-test.c++ @@ -590,8 +590,7 @@ KJ_TEST("encode to full flag list") { } KJ_TEST("compatibility dates must be Tuesday, Wednesday, or Thursday") { - // List of specific flags that are allowed to use non-conformant dates - // (already deployed and can't be changed for compatibility reasons) + // Specific flags with compatibility dates outside the normal release weekdays. kj::HashSet allowedFlagExceptions; allowedFlagExceptions.insertAll(std::initializer_list{ // Existing non-conformant dates that are already deployed @@ -649,6 +648,9 @@ KJ_TEST("compatibility dates must be Tuesday, Wednesday, or Thursday") { "pythonWorkers20250116"_kj, // 2025-09-29 (Monday) via impliedByAfterDate "removeNodejsCompatEOLv22"_kj, // 2027-04-30 (Friday) via impliedByAfterDate "removeNodejsCompatEOLv24"_kj, // 2028-04-30 (Sunday) via impliedByAfterDate + + // Scheduled default enablement on November 1, 2026 (Sunday). + "newModuleRegistry"_kj, }); // Helper function to suggest the next valid date (Tuesday, Wednesday, or Thursday) diff --git a/src/workerd/io/compatibility-date.capnp b/src/workerd/io/compatibility-date.capnp index bbac0edd1bf..55abdc7d72a 100644 --- a/src/workerd/io/compatibility-date.capnp +++ b/src/workerd/io/compatibility-date.capnp @@ -513,7 +513,8 @@ struct CompatibilityFlags @0x8f8c1b68151b6cef { newModuleRegistry @52 :Bool $compatEnableFlag("new_module_registry") - $compatDisableFlag("legacy_module_registry"); + $compatDisableFlag("legacy_module_registry") + $compatEnableDate("2026-11-01"); # Enables the new module registry implementation, which handles module # specifiers as URLs, implements import.meta (url/main/resolve), supports # import attributes, and allows a registry to be shared across isolate diff --git a/src/workerd/server/factory/worker-factory.c++ b/src/workerd/server/factory/worker-factory.c++ index c28d3e07e53..7a1550e7106 100644 --- a/src/workerd/server/factory/worker-factory.c++ +++ b/src/workerd/server/factory/worker-factory.c++ @@ -1569,9 +1569,6 @@ kj::Promise> factory_new_worker(const WorkerFactory& con bool usingNewModuleRegistry = isNewModuleRegistryEnabled(featureFlags); kj::Maybe> newModuleRegistry; if (usingNewModuleRegistry) { - KJ_REQUIRE(experimental, - "The new ModuleRegistry implementation is an experimental feature. " - "You must run workerd with `--experimental` to use this feature."); // Module URLs follow the virtual file system: a module at "/foo/bar/baz.js" in the bundle // is "file:///foo/bar/baz.js". const jsg::Url& bundleBase = workerFs->getBundleRoot(); From e7b1cc8b0a10769ea2457550c9e0fb21a3d0eaa4 Mon Sep 17 00:00:00 2001 From: Brendan Irvine-Broque Date: Thu, 22 Oct 2026 18:21:14 -0700 Subject: [PATCH 2/7] Delay new module registry default to 2026-11-08 Compatibility decision: use the new JavaScript module registry for compatibility dates on or after 2026-11-08, one week after the previously scheduled date. Keep the Sunday exception aligned with the enable date. --- src/workerd/io/compatibility-date-test.c++ | 2 +- src/workerd/io/compatibility-date.capnp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/workerd/io/compatibility-date-test.c++ b/src/workerd/io/compatibility-date-test.c++ index b15d891ef46..b0d16338587 100644 --- a/src/workerd/io/compatibility-date-test.c++ +++ b/src/workerd/io/compatibility-date-test.c++ @@ -649,7 +649,7 @@ KJ_TEST("compatibility dates must be Tuesday, Wednesday, or Thursday") { "removeNodejsCompatEOLv22"_kj, // 2027-04-30 (Friday) via impliedByAfterDate "removeNodejsCompatEOLv24"_kj, // 2028-04-30 (Sunday) via impliedByAfterDate - // Scheduled default enablement on November 1, 2026 (Sunday). + // Scheduled default enablement on November 8, 2026 (Sunday). "newModuleRegistry"_kj, }); diff --git a/src/workerd/io/compatibility-date.capnp b/src/workerd/io/compatibility-date.capnp index 55abdc7d72a..77530935556 100644 --- a/src/workerd/io/compatibility-date.capnp +++ b/src/workerd/io/compatibility-date.capnp @@ -514,7 +514,7 @@ struct CompatibilityFlags @0x8f8c1b68151b6cef { newModuleRegistry @52 :Bool $compatEnableFlag("new_module_registry") $compatDisableFlag("legacy_module_registry") - $compatEnableDate("2026-11-01"); + $compatEnableDate("2026-11-08"); # Enables the new module registry implementation, which handles module # specifiers as URLs, implements import.meta (url/main/resolve), supports # import attributes, and allows a registry to be shared across isolate From c1bf288f11c443cbac46843d214e323039c73735 Mon Sep 17 00:00:00 2001 From: Brendan Irvine-Broque Date: Thu, 29 Oct 2026 20:16:23 -0700 Subject: [PATCH 3/7] Delay new module registry default to 2026-11-12 Compatibility decision: enable the new JavaScript module registry by default for compatibility dates on or after 2026-11-12. Remove the Sunday weekday-check exception because the new date is a Thursday. --- src/workerd/io/compatibility-date-test.c++ | 6 ++---- src/workerd/io/compatibility-date.capnp | 2 +- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/src/workerd/io/compatibility-date-test.c++ b/src/workerd/io/compatibility-date-test.c++ index b0d16338587..ede8f3eed6b 100644 --- a/src/workerd/io/compatibility-date-test.c++ +++ b/src/workerd/io/compatibility-date-test.c++ @@ -590,7 +590,8 @@ KJ_TEST("encode to full flag list") { } KJ_TEST("compatibility dates must be Tuesday, Wednesday, or Thursday") { - // Specific flags with compatibility dates outside the normal release weekdays. + // List of specific flags that are allowed to use non-conformant dates + // (already deployed and can't be changed for compatibility reasons) kj::HashSet allowedFlagExceptions; allowedFlagExceptions.insertAll(std::initializer_list{ // Existing non-conformant dates that are already deployed @@ -648,9 +649,6 @@ KJ_TEST("compatibility dates must be Tuesday, Wednesday, or Thursday") { "pythonWorkers20250116"_kj, // 2025-09-29 (Monday) via impliedByAfterDate "removeNodejsCompatEOLv22"_kj, // 2027-04-30 (Friday) via impliedByAfterDate "removeNodejsCompatEOLv24"_kj, // 2028-04-30 (Sunday) via impliedByAfterDate - - // Scheduled default enablement on November 8, 2026 (Sunday). - "newModuleRegistry"_kj, }); // Helper function to suggest the next valid date (Tuesday, Wednesday, or Thursday) diff --git a/src/workerd/io/compatibility-date.capnp b/src/workerd/io/compatibility-date.capnp index 79ac11ce612..8d8f4f67721 100644 --- a/src/workerd/io/compatibility-date.capnp +++ b/src/workerd/io/compatibility-date.capnp @@ -514,7 +514,7 @@ struct CompatibilityFlags @0x8f8c1b68151b6cef { newModuleRegistry @52 :Bool $compatEnableFlag("new_module_registry") $compatDisableFlag("legacy_module_registry") - $compatEnableDate("2026-11-08"); + $compatEnableDate("2026-11-12"); # Enables the new module registry implementation, which handles module # specifiers as URLs, implements import.meta (url/main/resolve), supports # import attributes, and allows a registry to be shared across isolate From d3f01098920b16655e3d40fd4fc838b190d2f11c Mon Sep 17 00:00:00 2001 From: Brendan Irvine-Broque Date: Thu, 29 Oct 2026 20:22:18 -0700 Subject: [PATCH 4/7] Test the module registry default and preserve the fallback experimental gate Keep module fallback behind --experimental independently of registry selection. Cover the November 12 compatibility boundary, early opt-in, legacy opt-out, Python exclusion, module-worker startup without experimental mode, and fallback rejection with both registries. Update comments to describe date enablement. --- src/workerd/io/compatibility-date-test.c++ | 29 +++++++++++- src/workerd/io/features.h | 8 ++-- src/workerd/server/factory/worker-factory.c++ | 7 +-- src/workerd/server/server-test.c++ | 24 ++++++++++ .../module-fallback/module-fallback-test.mjs | 46 ++++++++++++++++++- 5 files changed, 104 insertions(+), 10 deletions(-) diff --git a/src/workerd/io/compatibility-date-test.c++ b/src/workerd/io/compatibility-date-test.c++ index ede8f3eed6b..d431a909466 100644 --- a/src/workerd/io/compatibility-date-test.c++ +++ b/src/workerd/io/compatibility-date-test.c++ @@ -589,6 +589,33 @@ KJ_TEST("encode to full flag list") { } } +KJ_TEST("new module registry defaults on at 2026-11-12") { + auto compileFlags = [](kj::StringPtr date, kj::ArrayPtr flags) { + capnp::MallocMessageBuilder message; + auto flagList = message.initRoot>(flags.size()); + for (auto i: kj::indices(flags)) { + flagList.set(i, flags[i]); + } + auto output = message.getOrphanage().newOrphan(); + SimpleWorkerErrorReporter errorReporter; + compileCompatibilityFlags(date, flagList.asReader(), output.get(), errorReporter, + /*allowExperimentalFeatures=*/false, CompatibilityDateValidation::FUTURE_FOR_TEST, nullptr); + KJ_ASSERT(errorReporter.errors.empty()); + return capnp::clone(output.getReader()); + }; + + auto before = compileFlags("2026-11-11", {}); + KJ_EXPECT(!isNewModuleRegistryEnabled(*before)); + auto enabled = compileFlags("2026-11-12", {}); + KJ_EXPECT(isNewModuleRegistryEnabled(*enabled)); + auto optedIn = compileFlags("2026-11-11", {"new_module_registry"_kj}); + KJ_EXPECT(isNewModuleRegistryEnabled(*optedIn)); + auto optedOut = compileFlags("2026-11-12", {"legacy_module_registry"_kj}); + KJ_EXPECT(!isNewModuleRegistryEnabled(*optedOut)); + auto python = compileFlags("2026-11-12", {"python_workers"_kj}); + KJ_EXPECT(!isNewModuleRegistryEnabled(*python)); +} + KJ_TEST("compatibility dates must be Tuesday, Wednesday, or Thursday") { // List of specific flags that are allowed to use non-conformant dates // (already deployed and can't be changed for compatibility reasons) @@ -766,7 +793,7 @@ KJ_TEST("isNewModuleRegistryEnabled ignores the flag for Python workers") { KJ_EXPECT(check(true, false)); // Python workers always use the original module registry: the // new_module_registry flag is ignored for them, whether set explicitly or - // (once the flag has a default-on date) implied by the compatibility date. + // implied by the compatibility date. KJ_EXPECT(!check(true, true)); KJ_EXPECT(!check(false, true)); } diff --git a/src/workerd/io/features.h b/src/workerd/io/features.h index 12e42ed3250..a2deaab9f17 100644 --- a/src/workerd/io/features.h +++ b/src/workerd/io/features.h @@ -67,10 +67,10 @@ inline void configureJsgIsolate(jsg::Lock& js, CompatibilityFlags::Reader flags) // Returns whether the new module registry implementation should be used for a // worker with the given flags. Python workers always use the original module // registry: the new_module_registry flag is ignored for them, whether it was -// listed explicitly or (once the flag gains an enable date) implied by the -// worker's compatibility date. Every decision about which registry to use MUST -// go through this function rather than reading getNewModuleRegistry() directly; -// otherwise a Python worker could end up split across the two registries. +// listed explicitly or implied by the worker's compatibility date. Every decision +// about which registry to use MUST go through this function rather than reading +// getNewModuleRegistry() directly; otherwise a Python worker could end up split +// across the two registries. // // Note that Cloudflare.compatibilityFlags.new_module_registry (as observed by // user code) still reflects the configured flag value, not this function's diff --git a/src/workerd/server/factory/worker-factory.c++ b/src/workerd/server/factory/worker-factory.c++ index 3b6bf775730..62689ed100a 100644 --- a/src/workerd/server/factory/worker-factory.c++ +++ b/src/workerd/server/factory/worker-factory.c++ @@ -1567,6 +1567,10 @@ kj::Promise> factory_new_worker(const WorkerFactory& con // The file system roots use their defaults; the config does not expose mount points. auto workerFs = newWorkerFileSystem(kj::heap(), getBundleDirectory(workerSource)); + KJ_REQUIRE(experimental || moduleFallback == kj::none, + "The module fallback service is an experimental feature. " + "You must run workerd with `--experimental` to use the module fallback service."); + // Python workers never use the new module registry, whatever their flags say. bool usingNewModuleRegistry = isNewModuleRegistryEnabled(featureFlags); kj::Maybe> newModuleRegistry; @@ -1667,9 +1671,6 @@ kj::Promise> factory_new_worker(const WorkerFactory& con if (!usingNewModuleRegistry) { KJ_IF_SOME(fallback, moduleFallback) { - KJ_REQUIRE(experimental, - "The module fallback service is an experimental feature. " - "You must run workerd with `--experimental` to use the module fallback service."); auto& apiIsolate = isolate->getApi(); apiIsolate.setModuleFallbackCallback( [client = kj::heap(kj::str(fallback)), diff --git a/src/workerd/server/server-test.c++ b/src/workerd/server/server-test.c++ index c4a45f41b9f..94961b86bce 100644 --- a/src/workerd/server/server-test.c++ +++ b/src/workerd/server/server-test.c++ @@ -412,6 +412,9 @@ class Server: public kj::PtrTarget { void setDefaultCompatibilityDate(kj::String date) { options->defaultCompatibilityDate = kj::mv(date); } + void setTestCompatibilityDateOverride(kj::String date) { + options->testCompatibilityDateOverride = kj::mv(date); + } void enableDebugPort(kj::String addr) { debugPort = kj::str("loopback:", addr); } @@ -1033,6 +1036,27 @@ KJ_TEST("Server: serve Service Worker using the new module registry") { conn.httpGet200("/service-worker", "NMR: http://foo/service-worker"); } +KJ_TEST("Server: module registry enabled by date starts without experimental mode") { + TestServer test(singleWorker(R"(( + modules = [ + ( name = "worker", + esModule = + `import message from "./message.js"; + `export default { + ` fetch() { return new Response(message + ":" + import.meta.main); } + `} + ), + ( name = "message.js", esModule = "export default 'date-default';" ) + ] + ))"_kj)); + + test.server.setTestCompatibilityDateOverride(kj::str("2026-11-12")); + test.start(); + + auto conn = test.connect("test-addr"); + conn.httpGet200("/", "date-default:true"); +} + // Note: Python workers ignore the new_module_registry flag entirely — they // always use the original module registry. That decision is centralized in // isNewModuleRegistryEnabled() (io/features.h) and unit-tested in diff --git a/src/workerd/server/tests/module-fallback/module-fallback-test.mjs b/src/workerd/server/tests/module-fallback/module-fallback-test.mjs index 526aa4f7dbd..0f28efd3d77 100644 --- a/src/workerd/server/tests/module-fallback/module-fallback-test.mjs +++ b/src/workerd/server/tests/module-fallback/module-fallback-test.mjs @@ -88,12 +88,12 @@ function sendJson(response, value) { response.end(JSON.stringify(value)); } -async function runWorkerd(configPath) { +async function runWorkerd(configPath, extraArgs = ['--experimental']) { return await new Promise((resolve, reject) => { let output = ''; const child = spawn( env.WORKERD_BINARY, - ['test', configPath, '--experimental'], + ['test', configPath, ...extraArgs], { stdio: ['ignore', 'pipe', 'pipe'] } ); const timeout = setTimeout(() => { @@ -114,6 +114,48 @@ async function runWorkerd(configPath) { }); } +test('module fallback requires experimental mode with either registry', async (t) => { + const directory = await mkdtemp( + join(env.TEST_TMPDIR, 'module-fallback-gate-') + ); + const cases = [ + ['date-default', '2026-11-12', []], + ['explicit-opt-in', '2026-11-11', ['new_module_registry']], + ['legacy-opt-out', '2026-11-12', ['legacy_module_registry']], + ['legacy-default', '2026-11-11', []], + ]; + + for (const [name, date, flags] of cases) { + await t.test(name, async () => { + const configPath = join(directory, `${name}.capnp`); + await writeFile( + configPath, + `using Workerd = import "/workerd/workerd.capnp"; +const config :Workerd.Config = ( + services = [( + name = "worker", + worker = ( + compatibilityFlags = ${JSON.stringify(flags)}, + moduleFallback = "127.0.0.1:1", + modules = [( + name = "worker.js", + esModule = "export const check = { test() {} };" + )] + ) + )] +);` + ); + + const result = await runWorkerd(configPath, [`--compat-date=${date}`]); + assert.notEqual(result.code, 0, result.output); + assert.match( + result.output, + /The module fallback service is an experimental feature/ + ); + }); + } +}); + test('module fallback serves V1 and V2 module types', async () => { const requests = []; const handlerErrors = []; From 325d28397d6d44a17693c8debebbd67df0a2d2cf Mon Sep 17 00:00:00 2001 From: Brendan Irvine-Broque Date: Thu, 29 Oct 2026 20:32:37 -0700 Subject: [PATCH 5/7] Keep legacy Wasm source URL cases on the legacy module registry --- src/workerd/api/tests/wasm-source-url-test.wd-test | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/workerd/api/tests/wasm-source-url-test.wd-test b/src/workerd/api/tests/wasm-source-url-test.wd-test index 9f4138dd394..a7c258b5184 100644 --- a/src/workerd/api/tests/wasm-source-url-test.wd-test +++ b/src/workerd/api/tests/wasm-source-url-test.wd-test @@ -4,14 +4,16 @@ using Workerd = import "/workerd/workerd.capnp"; # must recompile it rather than keep this worker's URL. const unitTests :Workerd.Config = ( services = [ - # With the flag, the module's frames name it by its module name. + # With the flag and the legacy registry, the module's frames name it by its module name. ( name = "wasm-source-url-test", worker = ( modules = [ (name = "worker", esModule = embed "wasm-source-url-test.js"), (name = "trap.wasm", wasm = embed "wasm-source-url.wasm"), ], - compatibilityFlags = ["nodejs_compat", "experimental", "wasm_source_url_support"], + compatibilityFlags = [ + "nodejs_compat", "experimental", "wasm_source_url_support", "legacy_module_registry", + ], bindings = [ (name = "expectedFrame", text = "at trap.wasm:wasm-function[0]:0x"), (name = "childFlag", text = "no_wasm_source_url_support"), @@ -45,7 +47,9 @@ const unitTests :Workerd.Config = ( (name = "worker", esModule = embed "wasm-source-url-test.js"), (name = "trap.wasm", wasm = embed "wasm-source-url.wasm"), ], - compatibilityFlags = ["nodejs_compat", "experimental", "no_wasm_source_url_support"], + compatibilityFlags = [ + "nodejs_compat", "experimental", "no_wasm_source_url_support", "legacy_module_registry", + ], bindings = [ (name = "expectedFrame", text = "at wasm://wasm/"), (name = "childFlag", text = "wasm_source_url_support"), From 4cf9716517b2842a8c131f4afce854682907921c Mon Sep 17 00:00:00 2001 From: Brendan Irvine-Broque Date: Fri, 30 Oct 2026 17:16:34 -0700 Subject: [PATCH 6/7] Update src/workerd/io/compatibility-date.capnp Co-authored-by: James M Snell --- src/workerd/io/compatibility-date.capnp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/workerd/io/compatibility-date.capnp b/src/workerd/io/compatibility-date.capnp index 8d8f4f67721..30aa1ce279f 100644 --- a/src/workerd/io/compatibility-date.capnp +++ b/src/workerd/io/compatibility-date.capnp @@ -514,7 +514,7 @@ struct CompatibilityFlags @0x8f8c1b68151b6cef { newModuleRegistry @52 :Bool $compatEnableFlag("new_module_registry") $compatDisableFlag("legacy_module_registry") - $compatEnableDate("2026-11-12"); + $compatEnableDate("2026-11-17"); # Enables the new module registry implementation, which handles module # specifiers as URLs, implements import.meta (url/main/resolve), supports # import attributes, and allows a registry to be shared across isolate From a9c47226e9aac8d9bf8b66eb25e23531a630b9e4 Mon Sep 17 00:00:00 2001 From: Brendan Irvine-Broque Date: Fri, 30 Oct 2026 17:20:23 -0700 Subject: [PATCH 7/7] Align module registry default tests with November 17 --- src/workerd/io/compatibility-date-test.c++ | 12 ++++++------ src/workerd/server/server-test.c++ | 2 +- .../tests/module-fallback/module-fallback-test.mjs | 8 ++++---- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/workerd/io/compatibility-date-test.c++ b/src/workerd/io/compatibility-date-test.c++ index d431a909466..90454b8d563 100644 --- a/src/workerd/io/compatibility-date-test.c++ +++ b/src/workerd/io/compatibility-date-test.c++ @@ -589,7 +589,7 @@ KJ_TEST("encode to full flag list") { } } -KJ_TEST("new module registry defaults on at 2026-11-12") { +KJ_TEST("new module registry defaults on at 2026-11-17") { auto compileFlags = [](kj::StringPtr date, kj::ArrayPtr flags) { capnp::MallocMessageBuilder message; auto flagList = message.initRoot>(flags.size()); @@ -604,15 +604,15 @@ KJ_TEST("new module registry defaults on at 2026-11-12") { return capnp::clone(output.getReader()); }; - auto before = compileFlags("2026-11-11", {}); + auto before = compileFlags("2026-11-16", {}); KJ_EXPECT(!isNewModuleRegistryEnabled(*before)); - auto enabled = compileFlags("2026-11-12", {}); + auto enabled = compileFlags("2026-11-17", {}); KJ_EXPECT(isNewModuleRegistryEnabled(*enabled)); - auto optedIn = compileFlags("2026-11-11", {"new_module_registry"_kj}); + auto optedIn = compileFlags("2026-11-16", {"new_module_registry"_kj}); KJ_EXPECT(isNewModuleRegistryEnabled(*optedIn)); - auto optedOut = compileFlags("2026-11-12", {"legacy_module_registry"_kj}); + auto optedOut = compileFlags("2026-11-17", {"legacy_module_registry"_kj}); KJ_EXPECT(!isNewModuleRegistryEnabled(*optedOut)); - auto python = compileFlags("2026-11-12", {"python_workers"_kj}); + auto python = compileFlags("2026-11-17", {"python_workers"_kj}); KJ_EXPECT(!isNewModuleRegistryEnabled(*python)); } diff --git a/src/workerd/server/server-test.c++ b/src/workerd/server/server-test.c++ index b8ecc2b9990..c58b2caaf86 100644 --- a/src/workerd/server/server-test.c++ +++ b/src/workerd/server/server-test.c++ @@ -1050,7 +1050,7 @@ KJ_TEST("Server: module registry enabled by date starts without experimental mod ] ))"_kj)); - test.server.setTestCompatibilityDateOverride(kj::str("2026-11-12")); + test.server.setTestCompatibilityDateOverride(kj::str("2026-11-17")); test.start(); auto conn = test.connect("test-addr"); diff --git a/src/workerd/server/tests/module-fallback/module-fallback-test.mjs b/src/workerd/server/tests/module-fallback/module-fallback-test.mjs index 0f28efd3d77..69510893f6d 100644 --- a/src/workerd/server/tests/module-fallback/module-fallback-test.mjs +++ b/src/workerd/server/tests/module-fallback/module-fallback-test.mjs @@ -119,10 +119,10 @@ test('module fallback requires experimental mode with either registry', async (t join(env.TEST_TMPDIR, 'module-fallback-gate-') ); const cases = [ - ['date-default', '2026-11-12', []], - ['explicit-opt-in', '2026-11-11', ['new_module_registry']], - ['legacy-opt-out', '2026-11-12', ['legacy_module_registry']], - ['legacy-default', '2026-11-11', []], + ['date-default', '2026-11-17', []], + ['explicit-opt-in', '2026-11-16', ['new_module_registry']], + ['legacy-opt-out', '2026-11-17', ['legacy_module_registry']], + ['legacy-default', '2026-11-16', []], ]; for (const [name, date, flags] of cases) {