diff --git a/docs/guide/edge/revalidation.md b/docs/guide/edge/revalidation.md
index ee3cfe025..061c7607e 100644
--- a/docs/guide/edge/revalidation.md
+++ b/docs/guide/edge/revalidation.md
@@ -61,6 +61,8 @@ export const loader = defineHandler(async (c) => {
 });
 ```
 
+Use a whole-number literal such as `3600`. Void reads the value without running the file, so it ignores an expression such as `60 * 60` or a value re-exported from another module, and prints a warning.
+
 Per-page values take precedence over `void.config.ts` patterns.
 
 A page's `revalidate` export also applies to `routes/` handlers whose URLs match the page pattern. For example, if `pages/[...slug].server.ts` exports `revalidate`, Void can also cache the `GET` response of `routes/now.ts`. Void never caches paths under `/api`. To keep a route handler's response out of the cache, set `x-revalidate: 0` on it. See [Per-response TTL override](#per-response-ttl-override).
diff --git a/docs/guide/pages-routing/layouts.md b/docs/guide/pages-routing/layouts.md
index a51cb604a..13922e8d1 100644
--- a/docs/guide/pages-routing/layouts.md
+++ b/docs/guide/pages-routing/layouts.md
@@ -216,6 +216,8 @@ A named layout replaces the deepest default layout: in `[root, docs/layout]`, it
 
 Void uses the closest matching `_layouts/` file in the page's directory or an ancestor. A missing named layout fails the build.
 
+Declare `layout` in the page file itself with a string literal or `false`. Void reads it without running the page, so it ignores a computed or re-exported value and prints a warning.
+
 ## Shared Data
 
 Middleware can inject data available on every page via `c.set("shared", {...})`. Augment `CloudContextVariables` to type the shared data, and `useShared()` will infer the type automatically:
diff --git a/docs/guide/pages-routing/overview.md b/docs/guide/pages-routing/overview.md
index ba8fe91b7..3036b9990 100644
--- a/docs/guide/pages-routing/overview.md
+++ b/docs/guide/pages-routing/overview.md
@@ -153,6 +153,8 @@ Render and prerender flags combine like this:
 | Island page + `ssr = false`            | Invalid. Island pages already use the island renderer.                    |
 | `output: "static"` + `prerender` unset | Auto-prerender pages that have known paths, including client-only shells. |
 
+Write `ssr` and `prerender` as `true` or `false` with `export const` in the `.server.ts` file itself. Void reads them without running the file, so it ignores a computed or re-exported value and prints a warning.
+
 ### Typed navigation
 
 Use the `Link` component for SPA navigation between pages. Build dynamic URLs with [`routeUrl()`](../type-safety.md#typed-urls-and-navigation) to check the route pattern and its parameters:
diff --git a/docs/guide/queues.md b/docs/guide/queues.md
index d38428111..30f0c9c2f 100644
--- a/docs/guide/queues.md
+++ b/docs/guide/queues.md
@@ -110,6 +110,8 @@ export default defineQueue<Message>(async (batch, env) => {
 - `maxRetries`: maximum number of retries before delivery is exhausted (default `3`)
 - `retryDelay`: seconds to wait between retries (default `0`)
 
+Declare each option in the queue file with `export const` and a whole-number literal. Void reads these values without running the file, so computed values and options re-exported from another module are not supported. To use the same value in several queues, repeat it in each queue file.
+
 Void-managed queues do not configure a dead-letter queue. Cloudflare permanently
 deletes messages that exhaust their retries without one; see
 [Cloudflare's dead-letter queue guide](https://developers.cloudflare.com/queues/configuration/dead-letter-queues/).
diff --git a/packages/void/src/crons/scan.ts b/packages/void/src/crons/scan.ts
index 86e1aeade..055913278 100644
--- a/packages/void/src/crons/scan.ts
+++ b/packages/void/src/crons/scan.ts
@@ -3,7 +3,7 @@ import { join } from 'pathslash';
 import type { AstNode } from '../shared/ast.ts';
 import { listConventionFiles } from '../shared/convention-files.ts';
 import {
-  staticExportInitializers,
+  readStaticExports,
   staticLiteral,
   unwrapStaticExpression,
 } from '../shared/static-exports.ts';
@@ -23,7 +23,7 @@ function extractJobName(filePath: string): string {
 
 function extractCronExpressions(source: string, filePath: string): Array<string> {
   const initializer = unwrapStaticExpression(
-    staticExportInitializers(filePath, source, new Set(['cron'])).get('cron'),
+    readStaticExports(filePath, source, new Set(['cron'])).initializers.get('cron'),
   );
   if (!initializer) {
     throw new Error(
diff --git a/packages/void/src/pages/island-imports.ts b/packages/void/src/pages/island-imports.ts
index 5e6bd11df..6a9f517b9 100644
--- a/packages/void/src/pages/island-imports.ts
+++ b/packages/void/src/pages/island-imports.ts
@@ -15,7 +15,30 @@ export type IslandSourceEdit = { start: number; end: number; text: string };
 
 export type StaticCssImport = { statement: string; specifier: string };
 
-type ScriptBlock = { source: string; offset: number; filename: string };
+type ScriptBlock = {
+  source: string;
+  offset: number;
+  filename: string;
+  /** A Svelte instance script: its exports declare component props, not module exports. */
+  instance?: boolean;
+};
+
+const SCRIPT_ATTRIBUTE_RE = /([^\s"'=/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+
+/** `<script module>` (Svelte 5) or `<script context="module">` (Svelte 4). */
+function isSvelteModuleScript(attributes: string): boolean {
+  for (const [, name, doubleQuoted, singleQuoted, bare] of attributes.matchAll(
+    SCRIPT_ATTRIBUTE_RE,
+  )) {
+    if (
+      name === 'module' ||
+      (name === 'context' && (doubleQuoted ?? singleQuoted ?? bare) === 'module')
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
 
 // Same leading-script rule as @void/md's extractScript: a markdown page may open
 // with a <script> block, and its frontmatter starts right after that block.
@@ -40,9 +63,18 @@ export function scriptBlocks(code: string, filename: string): Array<ScriptBlock>
     return [{ source: code, offset: 0, filename }];
   }
   const scriptFilename = filename.replace(/\.(?:vue|svelte)$/, '.ts');
-  return [...code.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/gi)].map((match) => {
-    const source = match[1]!;
-    return { source, offset: match.index! + match[0].indexOf(source), filename: scriptFilename };
+  const svelte = filename.endsWith('.svelte');
+  return [...code.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi)].map((match) => {
+    const source = match[2]!;
+    const block: ScriptBlock = {
+      source,
+      offset: match.index! + match[0].indexOf(source),
+      filename: scriptFilename,
+    };
+    if (svelte && !isSvelteModuleScript(match[1]!)) {
+      block.instance = true;
+    }
+    return block;
   });
 }
 
diff --git a/packages/void/src/pages/scan.ts b/packages/void/src/pages/scan.ts
index bbb4a633e..9c85558bc 100644
--- a/packages/void/src/pages/scan.ts
+++ b/packages/void/src/pages/scan.ts
@@ -24,7 +24,12 @@ import {
 } from '../shared/ast.ts';
 import { ROUTE_EXTENSIONS, ROUTE_EXTENSIONS_SET } from '../shared/route-extensions.ts';
 import { deriveFromSource } from '../shared/source-analysis-cache.ts';
-import { staticExportInitializers, staticLiteral } from '../shared/static-exports.ts';
+import {
+  mayExportAll,
+  readStaticExports,
+  staticExports,
+  staticLiteral,
+} from '../shared/static-exports.ts';
 import { MARKDOWN_SCRIPT_RE, scriptBlocks } from './island-imports.ts';
 import { resolveNamedLayout } from './layout-resolution.ts';
 import { patternToRegex } from './manifest.ts';
@@ -47,6 +52,23 @@ export const MAX_REVALIDATE = 31536000; // 1 year in seconds
 const warnedLayoutPaths = new Set<string>();
 /** Unreachable pages already reported, for the same reason. */
 const warnedShadowedPages = new Set<string>();
+/** Ignored page settings already reported, for the same reason. */
+const warnedPageSettings = new Set<string>();
+
+/**
+ * Page settings (layout, revalidate, prerender, ssr) are read from the source
+ * without running it. One the source does not show keeps its default, as
+ * before, with a warning: a hard error would break builds that already ship it.
+ */
+function warnPageSettings(pagesDir: string, warnings: ReadonlyArray<string>): void {
+  for (const warning of warnings) {
+    const key = `${pagesDir}\0${warning}`;
+    if (!warnedPageSettings.has(key)) {
+      warnedPageSettings.add(key);
+      voidWarn(warning);
+    }
+  }
+}
 
 type PageRenderingSource = {
   componentPath: string;
@@ -83,27 +105,62 @@ type PageServerMetadata = {
   prerender?: ExplicitBoolean;
   ssr?: ExplicitBoolean;
   hasGetPrerenderPaths?: boolean;
+  /** Settings the scan ignores, reported once by scanPages. */
+  warnings: Array<string>;
 };
 
-function componentLayout(source: string, filename: string): string | false | undefined {
-  if (!source.includes('layout')) {
-    return undefined;
+type ComponentLayout = {
+  layout: string | false | undefined;
+  /** Layout exports the scan ignores, reported once by scanPages. */
+  warnings: Array<string>;
+};
+
+const LAYOUT_EXPORT: ReadonlySet<string> = new Set(['layout']);
+
+function mayExportLayout(source: string): boolean {
+  return source.includes('layout') || mayExportAll(source);
+}
+
+/** The first script block that declares a readable layout wins; warnings only apply when none does. */
+function componentLayout(source: string, filename: string): ComponentLayout {
+  if (!mayExportLayout(source)) {
+    return { layout: undefined, warnings: [] };
   }
+  let ignored: string | undefined;
+  let exportsAll = false;
   for (const script of scriptBlocks(source, filename)) {
-    if (!script.source.includes('layout')) {
+    if (!mayExportLayout(script.source)) {
       continue;
     }
-    const initializer = staticExportInitializers(
-      script.filename,
-      script.source,
-      new Set(['layout']),
-    ).get('layout');
+    const exports = readStaticExports(script.filename, script.source, LAYOUT_EXPORT);
+    const initializer = exports.initializers.get('layout');
     const value = staticLiteral(initializer);
     if (typeof value === 'string' || value === false) {
-      return value;
+      return { layout: value, warnings: [] };
     }
+    // `export let layout` in a Svelte instance script declares a prop of that name.
+    if (script.instance) {
+      continue;
+    }
+    exportsAll ||= exports.exportsAll;
+    if (exports.unreadable.has('layout')) {
+      ignored ??= `pages: layout in '${filename}' is ignored. Declare it in that file as \`export const layout = '<name>'\`; re-exported layouts and other export forms are not read.`;
+    } else if (initializer) {
+      ignored ??= `pages: layout in '${filename}' is ignored. It must be a string literal or \`false\`, such as \`export const layout = 'landing'\`.`;
+    }
+  }
+  if (ignored) {
+    return { layout: undefined, warnings: [ignored] };
+  }
+  if (exportsAll) {
+    return {
+      layout: undefined,
+      warnings: [
+        `pages: '${filename}' uses \`export * from\`. Void does not read a layout export through it, so declare layout in that file with \`export const\`.`,
+      ],
+    };
   }
-  return undefined;
+  return { layout: undefined, warnings: [] };
 }
 
 const TRANSPARENT_EXPRESSION_TYPES = new Set([
@@ -121,8 +178,58 @@ function readLiteral(node: AstNode | null | undefined): unknown {
   return isLiteral(node) ? node.value : undefined;
 }
 
+const PAGE_SETTINGS = ['revalidate', 'prerender', 'ssr'] as const;
+const PAGE_SETTING_SET: ReadonlySet<string> = new Set(PAGE_SETTINGS);
+const PAGE_SETTING_PLACEHOLDERS = {
+  revalidate: '<seconds>',
+  prerender: '<boolean>',
+  ssr: '<boolean>',
+} as const;
+
+/** Read revalidate, prerender and ssr from a page's server file, collecting warnings for values it cannot read. */
+function readPageSettings(
+  program: AstProgram,
+  filename: string,
+  metadata: PageServerMetadata,
+): void {
+  const settings = staticExports(program, PAGE_SETTING_SET);
+  for (const name of PAGE_SETTINGS) {
+    if (settings.unreadable.has(name)) {
+      metadata.warnings.push(
+        `pages: ${name} in '${filename}' is ignored. Declare it in that file as \`export const ${name} = ${PAGE_SETTING_PLACEHOLDERS[name]}\`; re-exported settings and other export forms are not read.`,
+      );
+      continue;
+    }
+    const initializer = settings.initializers.get(name);
+    if (!initializer) {
+      continue;
+    }
+    const value = readLiteral(initializer);
+    if (name === 'revalidate') {
+      if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
+        metadata.revalidate = value;
+      } else {
+        metadata.warnings.push(
+          `pages: revalidate in '${filename}' is ignored. It must be a nonnegative integer literal, such as \`export const revalidate = 3600\`.`,
+        );
+      }
+    } else if (typeof value === 'boolean') {
+      metadata[name] = value;
+    } else {
+      metadata.warnings.push(
+        `pages: ${name} in '${filename}' is ignored. It must be \`true\` or \`false\`.`,
+      );
+    }
+  }
+  if (settings.exportsAll) {
+    metadata.warnings.push(
+      `pages: '${filename}' uses \`export * from\`. Void does not see page exports through it, so export loader, action, actions and getPrerenderPaths by name, and declare revalidate, prerender and ssr in that file with \`export const\`.`,
+    );
+  }
+}
+
 function detectPageServerMetadata(source: string, filename: string): PageServerMetadata {
-  const metadata: PageServerMetadata = { methods: [] };
+  const metadata: PageServerMetadata = { methods: [], warnings: [] };
   let parsed: ReturnType<typeof parseSync>;
   try {
     parsed = parseSync(filename, source);
@@ -150,20 +257,6 @@ function detectPageServerMetadata(source: string, filename: string): PageServerM
             metadata.hasGetPrerenderPaths = true;
           }
         }
-        if (isIdentifier(variable.id) && variables.kind === 'const') {
-          const name = variable.id.name;
-          if (name === 'revalidate') {
-            const value = readLiteral(variable.init);
-            if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
-              metadata.revalidate = value;
-            }
-          } else if (name === 'prerender' || name === 'ssr') {
-            const value = readLiteral(variable.init);
-            if (typeof value === 'boolean') {
-              metadata[name] = value;
-            }
-          }
-        }
       }
     } else if (declaration?.type === 'FunctionDeclaration') {
       const functionName = (declaration as AstFunctionDeclaration).id;
@@ -187,6 +280,7 @@ function detectPageServerMetadata(source: string, filename: string): PageServerM
       }
     }
   }
+  readPageSettings(program, filename, metadata);
   return metadata;
 }
 
@@ -351,6 +445,7 @@ export async function scanPages(root: string, options?: PageScanOptions): Promis
         prerender = metadata.prerender;
         ssr = metadata.ssr;
         hasGetPrerenderPaths = metadata.hasGetPrerenderPaths;
+        warnPageSettings(pagesDir, metadata.warnings);
         break;
       }
     }
@@ -386,9 +481,11 @@ export async function scanPages(root: string, options?: PageScanOptions): Promis
         layout: extractFrontmatterLayout(source, matter),
       })));
     } else {
-      layout = deriveFromSource(join(pagesDir, file), 'page-layout', (source) =>
+      const component = deriveFromSource(join(pagesDir, file), 'page-layout', (source) =>
         componentLayout(source, file),
       );
+      layout = component.layout;
+      warnPageSettings(pagesDir, component.warnings);
     }
 
     pages.push({
diff --git a/packages/void/src/queues/scan.ts b/packages/void/src/queues/scan.ts
index 90663942b..02e31a8cc 100644
--- a/packages/void/src/queues/scan.ts
+++ b/packages/void/src/queues/scan.ts
@@ -1,7 +1,9 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'pathslash';
+import { voidWarn } from '../log.ts';
+import type { AstNode } from '../shared/ast.ts';
 import { listConventionFiles } from '../shared/convention-files.ts';
-import { staticExportInitializers, staticLiteral } from '../shared/static-exports.ts';
+import { mayExportAll, readStaticExports, staticLiteral } from '../shared/static-exports.ts';
 
 export type QueueDefinition = {
   /** Relative file path from queues/ */
@@ -29,6 +31,43 @@ function deriveQueueBindingName(name: string): string {
 }
 
 const OPTION_NAMES = ['maxBatchSize', 'maxBatchTimeout', 'maxRetries', 'retryDelay'] as const;
+const OPTION_NAME_SET: ReadonlySet<string> = new Set(OPTION_NAMES);
+
+/** Queue files already warned about `export *`; a dev server rescans queues on every change. */
+const warnedExportAll = new Set<string>();
+
+/**
+ * Consumer options configure Cloudflare before any queue code runs, so they are
+ * read from the source. Reject exports whose value the source does not show,
+ * instead of deploying Cloudflare's defaults.
+ */
+function readOptionInitializers(
+  absPath: string,
+  filePath: string,
+  source: string,
+): Map<string, AstNode> {
+  if (!OPTION_NAMES.some((option) => source.includes(option)) && !mayExportAll(source)) {
+    return new Map();
+  }
+  const exports = readStaticExports(absPath, source, OPTION_NAME_SET);
+  const unreadable = OPTION_NAMES.find((option) => exports.unreadable.has(option));
+  if (unreadable) {
+    throw new Error(
+      `queue: ${unreadable} in '${filePath}' must be declared in the queue file as \`export const ${unreadable} = <integer>\`. Re-exported options and other export forms are not read.`,
+    );
+  }
+  if (
+    exports.exportsAll &&
+    OPTION_NAMES.some((option) => !exports.initializers.has(option)) &&
+    !warnedExportAll.has(absPath)
+  ) {
+    warnedExportAll.add(absPath);
+    voidWarn(
+      `queue: '${filePath}' uses \`export * from\`. Void does not read consumer options through it, so declare them in the queue file with \`export const\`. Re-export other names individually to remove this warning.`,
+    );
+  }
+  return exports.initializers;
+}
 
 export function scanQueuesSync(queuesDir: string): Array<QueueDefinition> {
   const definitions = listConventionFiles(queuesDir)
@@ -37,9 +76,7 @@ export function scanQueuesSync(queuesDir: string): Array<QueueDefinition> {
       const absPath = join(queuesDir, filePath);
       const source = readFileSync(absPath, 'utf-8');
       const name = extractName(filePath);
-      const options = OPTION_NAMES.some((option) => source.includes(option))
-        ? staticExportInitializers(absPath, source, new Set(OPTION_NAMES))
-        : new Map();
+      const options = readOptionInitializers(absPath, filePath, source);
       const optionValue = (option: (typeof OPTION_NAMES)[number]): number | undefined => {
         const initializer = options.get(option);
         if (!initializer) {
diff --git a/packages/void/src/shared/ast.ts b/packages/void/src/shared/ast.ts
index af9b071d9..d6cc33e5e 100644
--- a/packages/void/src/shared/ast.ts
+++ b/packages/void/src/shared/ast.ts
@@ -74,6 +74,14 @@ export type AstExportNamedDeclaration = AstNode & {
   exportKind?: string;
 };
 
+export type AstExportAllDeclaration = AstNode & {
+  type: 'ExportAllDeclaration';
+  /** The namespace name in `export * as name from`; null for `export * from`. */
+  exported?: AstNode | null;
+  /** "type" for `export type * from`, "value" (or undefined) otherwise. */
+  exportKind?: string;
+};
+
 export type AstExportDefaultDeclaration = AstNode & {
   type: 'ExportDefaultDeclaration';
   declaration?: AstNode;
diff --git a/packages/void/src/shared/static-exports.ts b/packages/void/src/shared/static-exports.ts
index 4a27d3cfe..229d20928 100644
--- a/packages/void/src/shared/static-exports.ts
+++ b/packages/void/src/shared/static-exports.ts
@@ -1,40 +1,139 @@
 import { parseSync } from 'vite';
+import { bindingNames } from './ast-bindings.ts';
 import {
   isIdentifier,
+  moduleExportName,
+  type AstExportAllDeclaration,
   type AstExportNamedDeclaration,
   type AstNode,
   type AstProgram,
   type AstVariableDeclaration,
 } from './ast.ts';
 
-/** Read the initializer of directly exported constants without evaluating user code. */
-export function staticExportInitializers(
-  filename: string,
-  source: string,
-  names: ReadonlySet<string>,
-): Map<string, AstNode> {
-  const result = new Map<string, AstNode>();
-  const program = parseSync(filename, source).program as unknown as AstProgram;
+/** How a module exports some names, as far as its source shows without running it. */
+export type StaticExports = {
+  /** Initializers of `export const name = value` declarations. */
+  initializers: Map<string, AstNode>;
+  /**
+   * Names exported in a form whose value only running the module reveals: export
+   * lists and re-exports, `let` and `var`, destructuring, functions, classes and enums.
+   */
+  unreadable: Set<string>;
+  /** `export * from` may export any of the names. */
+  exportsAll: boolean;
+};
+
+const LINE_TERMINATORS = new Set(['\n', '\r', '\u2028', '\u2029']);
+
+/**
+ * Whether `export` is followed by `*` once whitespace and comments are skipped,
+ * so a comment between the two still counts. True only means the source needs
+ * parsing: the text may sit in a string or comment. This is a scan because a
+ * regular expression that skips repeated comments can backtrack exponentially.
+ */
+export function mayExportAll(source: string): boolean {
+  for (
+    let index = source.indexOf('export');
+    index !== -1;
+    index = source.indexOf('export', index + 1)
+  ) {
+    let cursor = index + 'export'.length;
+    while (cursor < source.length) {
+      if (/\s/.test(source[cursor]!)) {
+        cursor += 1;
+      } else if (source.startsWith('/*', cursor)) {
+        const end = source.indexOf('*/', cursor + 2);
+        cursor = end === -1 ? source.length : end + 2;
+      } else if (source.startsWith('//', cursor)) {
+        cursor += 2;
+        while (cursor < source.length && !LINE_TERMINATORS.has(source[cursor]!)) {
+          cursor += 1;
+        }
+      } else {
+        break;
+      }
+    }
+    if (source[cursor] === '*') {
+      return true;
+    }
+  }
+  return false;
+}
+
+const VALUE_DECLARATIONS = new Set([
+  'FunctionDeclaration',
+  'ClassDeclaration',
+  'TSEnumDeclaration',
+]);
+
+/** Read how a parsed module exports `names` without evaluating user code. Type-only exports are skipped. */
+export function staticExports(program: AstProgram, names: ReadonlySet<string>): StaticExports {
+  const result: StaticExports = {
+    initializers: new Map(),
+    unreadable: new Set(),
+    exportsAll: false,
+  };
+  const markUnreadable = (name: string | undefined): void => {
+    if (name !== undefined && names.has(name)) {
+      result.unreadable.add(name);
+    }
+  };
   for (const statement of program.body ?? []) {
+    if (statement.type === 'ExportAllDeclaration') {
+      const exported = statement as AstExportAllDeclaration;
+      if (exported.exportKind === 'type') {
+        continue;
+      }
+      if (exported.exported) {
+        markUnreadable(moduleExportName(exported.exported));
+      } else {
+        result.exportsAll = true;
+      }
+      continue;
+    }
     if (statement.type !== 'ExportNamedDeclaration') {
       continue;
     }
-    const declaration = (statement as AstExportNamedDeclaration).declaration;
-    if (
-      declaration?.type !== 'VariableDeclaration' ||
-      (declaration as AstVariableDeclaration).kind !== 'const'
-    ) {
+    const exported = statement as AstExportNamedDeclaration;
+    if (exported.exportKind === 'type') {
       continue;
     }
-    for (const variable of (declaration as AstVariableDeclaration).declarations ?? []) {
-      if (isIdentifier(variable.id) && names.has(variable.id.name) && variable.init) {
-        result.set(variable.id.name, variable.init);
+    for (const specifier of exported.specifiers ?? []) {
+      if (specifier.exportKind !== 'type') {
+        markUnreadable(moduleExportName(specifier.exported));
+      }
+    }
+    const declaration = exported.declaration;
+    if (declaration?.type === 'VariableDeclaration') {
+      const variables = declaration as AstVariableDeclaration;
+      for (const variable of variables.declarations ?? []) {
+        if (variables.kind === 'const' && isIdentifier(variable.id) && variable.init) {
+          if (names.has(variable.id.name)) {
+            result.initializers.set(variable.id.name, variable.init);
+          }
+          continue;
+        }
+        for (const name of bindingNames(variable.id)) {
+          markUnreadable(name);
+        }
       }
+    } else if (declaration && VALUE_DECLARATIONS.has(declaration.type)) {
+      const id = declaration.id as AstNode | undefined;
+      markUnreadable(isIdentifier(id) ? id.name : undefined);
     }
   }
   return result;
 }
 
+/** Parse a module and read how it exports `names` without evaluating user code. */
+export function readStaticExports(
+  filename: string,
+  source: string,
+  names: ReadonlySet<string>,
+): StaticExports {
+  return staticExports(parseSync(filename, source).program as unknown as AstProgram, names);
+}
+
 export function unwrapStaticExpression(node: AstNode | undefined): AstNode | undefined {
   while (
     node &&
diff --git a/packages/void/test/unit/pages-scan.test.ts b/packages/void/test/unit/pages-scan.test.ts
index edc505d96..b4cae53c9 100644
--- a/packages/void/test/unit/pages-scan.test.ts
+++ b/packages/void/test/unit/pages-scan.test.ts
@@ -1,7 +1,7 @@
 import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import * as tinyglobby from 'tinyglobby';
-import { describe, expect, it, beforeEach, afterEach, vi } from 'vite-plus/test';
+import { describe, expect, it, beforeEach, afterEach, vi, type MockInstance } from 'vite-plus/test';
 import { generateRouteTypes } from '../../src/codegen/route-types.ts';
 import { resolveLayoutIds } from '../../src/pages/layout-resolution.ts';
 import { generateComponentManifest } from '../../src/pages/manifest.ts';
@@ -303,11 +303,20 @@ export const ssr = true as const;`,
     expect(page.ssrMode).toBe('server');
   });
 
-  it('does not treat a computed revalidate expression as its leading literal', async () => {
-    writeFile('computed.vue', '<template><div>Computed</div></template>');
-    writeFile('computed.server.ts', 'export const revalidate = 60 + 1;');
+  it('ignores a computed revalidate expression with a warning instead of reading its leading literal', async () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      writeFile('computed.vue', '<template><div>Computed</div></template>');
+      writeFile('computed.server.ts', 'export const revalidate = 60 + 1;');
 
-    expect((await scanPages(TMP)).pages[0].revalidate).toBeUndefined();
+      expect((await scanPages(TMP)).pages[0].revalidate).toBeUndefined();
+      expect(log).toHaveBeenCalledOnce();
+      expect(log.mock.calls[0][0]).toContain(
+        "pages: revalidate in 'computed.server.ts' is ignored. It must be a nonnegative integer literal, such as `export const revalidate = 3600`.",
+      );
+    } finally {
+      log.mockRestore();
+    }
   });
 
   it('keeps detecting page methods declared with let or var', async () => {
@@ -1000,6 +1009,153 @@ const example = 'export const layout = "home"';
     });
   });
 
+  describe('ignored page settings', () => {
+    let log: MockInstance<typeof console.log>;
+
+    beforeEach(() => {
+      log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      log.mockRestore();
+    });
+
+    function warnings(): Array<string> {
+      return log.mock.calls.map(([message]) => String(message));
+    }
+
+    it.each([
+      ['revalidate', 're-exported', "export { revalidate } from './_shared';", 'reexported'],
+      ['revalidate', 'renamed', 'const ttl = 60;\nexport { ttl as revalidate };', 'renamed'],
+      ['prerender', 'let', 'export let prerender = false;', 'let-prerender'],
+      ['ssr', 'destructured', 'export const { ssr } = { ssr: false };', 'destructured-ssr'],
+    ] as const)(
+      'warns and ignores %s exported in a %s form',
+      async (name, _form, declaration, page) => {
+        writeFile(`${page}.vue`, '<template><div /></template>');
+        writeFile(`${page}.server.ts`, `${declaration}\nexport const loader = () => ({});`);
+
+        const [scanned] = (await scanPages(TMP)).pages;
+        expect(scanned[name]).toBeUndefined();
+        expect(scanned.methods).toEqual(['loader']);
+        expect(warnings()).toEqual([
+          expect.stringContaining(
+            `pages: ${name} in '${page}.server.ts' is ignored. Declare it in that file as \`export const ${name} = `,
+          ),
+        ]);
+      },
+    );
+
+    it('warns once and ignores render flags that are not boolean literals', async () => {
+      writeFile('flags.vue', '<template><div /></template>');
+      writeFile('flags.server.ts', "export const prerender = 'false';\nexport const ssr = !0;");
+
+      const [page] = (await scanPages(TMP)).pages;
+      await scanPages(TMP);
+      expect(page.prerenderMode).toBe('auto');
+      expect(page.ssrMode).toBe('auto');
+      expect(warnings()).toEqual([
+        expect.stringContaining("pages: prerender in 'flags.server.ts' is ignored. It must be"),
+        expect.stringContaining("pages: ssr in 'flags.server.ts' is ignored. It must be"),
+      ]);
+    });
+
+    it('keeps type-only exports of setting names silent', async () => {
+      writeFile('typed.vue', '<template><div /></template>');
+      writeFile(
+        'typed.server.ts',
+        "export type { revalidate } from './_types';\nexport const ssr = false;",
+      );
+
+      expect((await scanPages(TMP)).pages[0].ssr).toBe(false);
+      expect(warnings()).toEqual([]);
+    });
+
+    it('warns that page exports through export * are not seen', async () => {
+      writeFile('shared.island.vue', '<template><div /></template>');
+      writeFile('shared.server.ts', "export * from './_shared.server';");
+
+      await scanPages(TMP);
+      await scanPages(TMP);
+      expect(warnings()).toEqual([
+        expect.stringContaining(
+          "pages: 'shared.server.ts' uses `export * from`. Void does not see page exports through it",
+        ),
+      ]);
+    });
+
+    it.each([
+      ["export { layout } from './_shared';", 're-exported-layout.tsx', 'Declare it in that file'],
+      ['export const layout = 42;', 'numeric-layout.tsx', 'It must be a string literal or `false`'],
+      [
+        "export * from './_shared';",
+        'star-layout.tsx',
+        'uses `export * from`. Void does not read a layout export through it',
+      ],
+      [
+        "export /* shared */ * from './_shared';",
+        'commented-star-layout.tsx',
+        'uses `export * from`. Void does not read a layout export through it',
+      ],
+    ])('warns and keeps the default layouts for %s', async (declaration, file, message) => {
+      writeFile('layout.tsx', 'export default () => null;');
+      writeFile('_layouts/landing.tsx', 'export default () => null;');
+      writeFile(file, `${declaration}\nexport default () => null;`);
+
+      const result = await scanPages(TMP);
+      const page = result.pages.find((p) => p.componentPath === file)!;
+      expect(page.layout).toBeUndefined();
+      expect(warnings()).toEqual([expect.stringContaining(message)]);
+    });
+
+    it('reads a layout declared beside export * without a warning', async () => {
+      writeFile('_layouts/landing.tsx', 'export default () => null;');
+      writeFile(
+        'local-layout.tsx',
+        "export * from './_shared';\nexport const layout = 'landing';\nexport default () => null;",
+      );
+
+      expect((await scanPages(TMP)).pages[0].layout).toBe('landing');
+      expect(warnings()).toEqual([]);
+    });
+
+    it.each(['module', 'context="module"'])(
+      'reads a Svelte <script %s> layout after an instance prop named layout',
+      async (attribute) => {
+        const file = `prop-${attribute.length}.svelte`;
+        writeFile(
+          file,
+          `<script>\n  export let layout = 'prop';\n</script>\n<script ${attribute}>\n  export const layout = false;\n</script>\n<p>{layout}</p>`,
+        );
+
+        expect((await scanPages(TMP)).pages[0].layout).toBe(false);
+        expect(warnings()).toEqual([]);
+      },
+    );
+
+    it('treats exports of a Svelte instance script as component props', async () => {
+      writeFile(
+        'instance-prop.svelte',
+        "<script>\n  export let layout = 'prop';\n</script>\n<p>{layout}</p>",
+      );
+
+      expect((await scanPages(TMP)).pages[0].layout).toBeUndefined();
+      expect(warnings()).toEqual([]);
+    });
+
+    it('warns about an unreadable layout in a Svelte module script', async () => {
+      writeFile(
+        'module-let.svelte',
+        "<script module>\n  export let layout = 'landing';\n</script>\n<p />",
+      );
+
+      expect((await scanPages(TMP)).pages[0].layout).toBeUndefined();
+      expect(warnings()).toEqual([
+        expect.stringContaining("pages: layout in 'module-let.svelte' is ignored. Declare it"),
+      ]);
+    });
+  });
+
   describe('route clashes', () => {
     it('throws once, listing every route that more than one page file resolves to', async () => {
       writeFile('about.tsx', 'export default () => null;');
diff --git a/packages/void/test/unit/queue-scan.test.ts b/packages/void/test/unit/queue-scan.test.ts
index 849c80e16..8527da1c0 100644
--- a/packages/void/test/unit/queue-scan.test.ts
+++ b/packages/void/test/unit/queue-scan.test.ts
@@ -1,7 +1,7 @@
 import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { describe, expect, it, beforeEach, afterEach } from 'vite-plus/test';
+import { describe, expect, it, beforeEach, afterEach, vi } from 'vite-plus/test';
 import { scanQueuesSync } from '../../src/queues/scan.ts';
 
 describe('scanQueuesSync', () => {
@@ -58,6 +58,89 @@ export default async () => {};`,
     expect(() => scanQueuesSync(queuesDir)).toThrow('maxBatchSize');
   });
 
+  it.each([
+    ['a re-export', "export { maxRetries } from './_shared';"],
+    ['an imported binding', "import { maxRetries } from './_shared';\nexport { maxRetries };"],
+    ['a renamed local', 'const retries = 3;\nexport { retries as maxRetries };'],
+    ['let', 'export let maxRetries = 3;'],
+    ['destructuring', 'export const { maxRetries } = { maxRetries: 3 };'],
+  ])(
+    'rejects an option exported through %s instead of deploying the default',
+    (_form, declaration) => {
+      writeFileSync(join(queuesDir, 'jobs.ts'), `${declaration}\nexport default async () => {};`);
+      expect(() => scanQueuesSync(queuesDir)).toThrow(
+        "queue: maxRetries in 'jobs.ts' must be declared in the queue file as `export const maxRetries = <integer>`. Re-exported options and other export forms are not read.",
+      );
+    },
+  );
+
+  it('ignores type-only exports of option names', () => {
+    writeFileSync(
+      join(queuesDir, 'typed.ts'),
+      "export type { maxRetries } from './_types';\nexport const retryDelay = 5;\nexport default async () => {};",
+    );
+    expect(scanQueuesSync(queuesDir)).toMatchObject([{ maxRetries: undefined, retryDelay: 5 }]);
+  });
+
+  it('warns once that options are not read through export *', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      writeFileSync(
+        join(queuesDir, 'star.ts'),
+        "export * from './_options';\nexport const maxRetries = 5;\nexport default async () => {};",
+      );
+      expect(scanQueuesSync(queuesDir)).toMatchObject([{ maxRetries: 5, retryDelay: undefined }]);
+      scanQueuesSync(queuesDir);
+      expect(log).toHaveBeenCalledOnce();
+      expect(log.mock.calls[0][0]).toContain(
+        "queue: 'star.ts' uses `export * from`. Void does not read consumer options through it",
+      );
+    } finally {
+      log.mockRestore();
+    }
+  });
+
+  it.each([
+    ['block-comment', "export /* shared */ * from './_options';"],
+    ['line-comment', "export // shared\n* from './_options';"],
+    ['line-breaks', "export\n*\nfrom './_options';"],
+  ])(
+    'warns about export * spelled with %s when the file names no option',
+    (spelling, statement) => {
+      const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+      try {
+        writeFileSync(
+          join(queuesDir, `${spelling}.ts`),
+          `${statement}\nexport default async () => {};`,
+        );
+        scanQueuesSync(queuesDir);
+        expect(log).toHaveBeenCalledOnce();
+        expect(log.mock.calls[0][0]).toContain(`queue: '${spelling}.ts' uses \`export * from\`.`);
+      } finally {
+        log.mockRestore();
+      }
+    },
+  );
+
+  it('does not warn about export * when the queue file declares every option', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      writeFileSync(
+        join(queuesDir, 'complete.ts'),
+        `export * from './_helpers';
+export const maxBatchSize = 1;
+export const maxBatchTimeout = 2;
+export const maxRetries = 3;
+export const retryDelay = 4;
+export default async () => {};`,
+      );
+      expect(scanQueuesSync(queuesDir)).toMatchObject([{ maxBatchSize: 1, retryDelay: 4 }]);
+      expect(log).not.toHaveBeenCalled();
+    } finally {
+      log.mockRestore();
+    }
+  });
+
   it('normalizes nested paths while preserving binding derivation', () => {
     mkdirSync(join(root, 'queues', 'order'), { recursive: true });
     writeFileSync(