Tests / @ogygia/compiler

@ogygia/compiler

Version 0.14.0 latest
commit 620ddcca
2,212 test runs (2,212 tests, each run in Node, the browsers or both)
1.43× lines of test for each line of source (26,300 to 18,328) Only real test code counts: test files and their helpers, not fixtures, sample apps or benches. Blank lines are left out on both sides.
Exactly what is counted non-blank lines of test code across the repo (*.test.ts, *.test-d.ts, *.spec.ts, and the .ts helpers in test/ and e2e/ folders; no fixtures, fixture apps, stubs or benches), over non-blank lines of packages/*/src (no .d.ts or generated files)
97.9% of source lines run by the tests
  • 2,212Unit
  • 0Browser
  • 0End to end
  • 0Type tests
  • 0Lint rules
  • 0Failing

Coverage

  • 97.9%Lines
  • 89.2%Branches
  • 97.1%Functions
  • 96.2%Statements

Every test

2212 tests

TestKindNodeChromiumFirefoxWebKit
packages/compiler/test/analyses.test.ts
the analysis table > barrel_pure: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > barrel_pure: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > context_mark: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > context_mark: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > crosses_kit_wire: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > crosses_kit_wire: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > csr_true_degrade: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > csr_true_degrade: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > css_reach: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > css_reach: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > dollar_captures: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > dollar_captures: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > emit_gate: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > emit_gate: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > every oracle marker names an analysis in the tableUnitpassnot runnot runnot run
the analysis table > export_walk: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > export_walk: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > free_vars: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > free_vars: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > hole_reads_page: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > hole_reads_page: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > island_reads_page: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > island_reads_page: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > island_remotes: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > island_remotes: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > names each analysis onceUnitpassnot runnot runnot run
the analysis table > ownership_stamps: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > ownership_stamps: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > region_options: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > region_options: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > registry_reach: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > registry_reach: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > route_config: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > route_config: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > route_csr: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > route_csr: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > runtime_features: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > runtime_features: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > seed_keys: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > seed_keys: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > transportable: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > transportable: its function is where the table saysUnitpassnot runnot runnot run
the analysis table > wire_crossing: has an oracle, or a gap naming the issue for one, never bothUnitpassnot runnot runnot run
the analysis table > wire_crossing: its function is where the table saysUnitpassnot runnot runnot run
packages/compiler/test/as-region-namespace.test.ts
a region mark on a namespace import is refused > import { Card } from '$lib/index.ts' with { wake: 'load' }; binds the export it namesUnitpassnot runnot runnot run
a region mark on a namespace import is refused > import { Card as C } from '$lib/index.ts' with { wake: 'load' }; binds the export it namesUnitpassnot runnot runnot run
a region mark on a namespace import is refused > import Card from '$lib/Card.svelte' with { wake: 'load' }; binds the export it namesUnitpassnot runnot runnot run
a region mark on a namespace import is refused > in a .svelte hostUnitpassnot runnot runnot run
a region mark on a namespace import is refused > in a .ts moduleUnitpassnot runnot runnot run
packages/compiler/test/audit-fixes.test.ts
audit fixes — concurrency gate > never exceeds max concurrent runnersUnitpassnot runnot runnot run
audit fixes — head_node_key > keys Kit FOUC and Vite HMR styles by role, not content lengthUnitpassnot runnot runnot run
audit fixes — head_node_key > keys link/meta without full outerHTML when possibleUnitpassnot runnot runnot run
audit fixes — lake placeholder rewrite > rewrites default lake importsUnitpassnot runnot runnot run
audit fixes — lake placeholder rewrite > rewrites named lake imports and keeps siblingsUnitpassnot runnot runnot run
audit fixes — page seed serialize > escapes lt and falls back when data is non-serializableUnitpassnot runnot runnot run
audit fixes — rate limiter > charges after max and hard-caps map sizeUnitpassnot runnot runnot run
audit fixes — rate limiter > documents render-rate contract: junk must not call render limited()Unitpassnot runnot runnot run
audit fixes — rate limiter > evicts least-recently-used keys when over capUnitpassnot runnot runnot run
audit fixes — rate limiter > over() reports a spent budget and charges nothingUnitpassnot runnot runnot run
audit fixes — region endpoint allowlist > allows same-origin relative and absolute; rejects cross-originUnitpassnot runnot runnot run
audit fixes — region endpoint allowlist > resolves relative island entries against the document (not runtime module)Unitpassnot runnot runnot run
audit fixes — region id charset + default TTL constant > exports DEFAULT_REGION_TTL_SEC and REGION_ID_REUnitpassnot runnot runnot run
audit fixes — remote clear > clear_remote_seeds leaves live/query instance maps intactUnitpassnot runnot runnot run
audit fixes — remote clear > remote_cache is shared via globalThis across re-importsUnitpassnot runnot runnot run
audit fixes — spa cache policy > refuses private/no-store/no-cache and Set-CookieUnitpassnot runnot runnot run
audit fixes — transform contract > a preset speaks the standard keys when the app renames the import keys (#1177)#1177Unitpassnot runnot runnot run
audit fixes — transform contract > a preset's unknown key names every key a preset takes, keep among them (#1177)#1177Unitpassnot runnot runnot run
audit fixes — transform contract > allows a marked import used as a portable/dynamic bindingUnitpassnot runnot runnot run
audit fixes — transform contract > allows this={C} on svelte:componentUnitpassnot runnot runnot run
audit fixes — transform contract > errors on strategy-less presetUnitpassnot runnot runnot run
audit fixes — transform contract > errors when marked import is used as dotted Menu.ItemUnitpassnot runnot runnot run
audit fixes — transform contract > islandId normalizes windows path separatorsUnitpassnot runnot runnot run
audit fixes — transform contract > lake binding rewrite produces a portable lake wrapperUnitpassnot runnot runnot run
audit fixes — transform contract > rejects host children on defer (lakes belong inside the island component)Unitpassnot runnot runnot run
audit fixes — transform contract > rejects hydrate values with lone "(" as unknown (not media)Unitpassnot runnot runnot run
audit fixes — transform contract > strips unused hydrate:none import (no with{} left)Unitpassnot runnot runnot run
audit fixes — transform contract > unused marked import is stripped even when markup text mentions the local nameUnitpassnot runnot runnot run
packages/compiler/test/blank-styles.test.ts
blank_styles > a <style> inside an HTML comment is text, left aloneUnitpassnot runnot runnot run
blank_styles > a component whose SCSS the Svelte parser rejects parses once blanked, offsets intactUnitpassnot runnot runnot run
blank_styles > blanks only style content, keeps newlines, leaves a <style> string inside a script untouchedUnitpassnot runnot runnot run
packages/compiler/test/bom-source.test.ts
a byte-order-marked component > a host with a marked import, both legs: the island transform edits the right offsetsUnitpassnot runnot runnot run
a byte-order-marked component > strip_bom takes off exactly one leading markUnitpassnot runnot runnot run
a byte-order-marked component > the ownership stamps land on the tag name, not one character earlyUnitpassnot runnot runnot run
a byte-order-marked component > through the compiler’s transform, server leg: stamped and compilesUnitpassnot runnot runnot run
packages/compiler/test/build-cache.test.ts
BuildCache > a namespace whose directory cannot be made is no cache, and nothing throwsUnitpassnot runnot runnot run
BuildCache > a new project root is probed againUnitpassnot runnot runnot run
BuildCache > a root it cannot create is no cache, and nothing throwsUnitpassnot runnot runnot run
BuildCache > a torn or absent entry is a missUnitpassnot runnot runnot run
BuildCache > a value it cannot write is not kept, and nothing throwsUnitpassnot runnot runnot run
BuildCache > an entry is written beside its address and renamed into placeUnitpassnot runnot runnot run
BuildCache > lives in the configured project's node_modules/.ogygia, one directory per namespaceUnitpassnot runnot runnot run
packages/compiler/test/build-legs.test.ts
build legs > a build hook in an environment that never started is refusedUnitpassnot runnot runnot run
build legs > a hook with no environment runs in the one open legUnitpassnot runnot runnot run
build legs > a hook with no environment while two legs are open is refusedUnitpassnot runnot runnot run
build legs > a leg the bundler ends twice ends once, without a refusalUnitpassnot runnot runnot run
build legs > a second build (watch) starts every leg emptyUnitpassnot runnot runnot run
build legs > an end with no environment ends the one open leg; a dev close with two open ends noneUnitpassnot runnot runnot run
build legs > dev opens an environment’s leg on first use, and its start still runs the once workUnitpassnot runnot runnot run
build legs > one instance, ssr then client: the client emits into its own leg, never the server’sUnitpassnot runnot runnot run
packages/compiler/test/canary/kit-build.test.ts
Kit 2.70.2 > served from a build > honours `files.routes`, `outDir`, `appDir` and a zero `inlineStyleThreshold`, as the compiler reads themUnitpassnot runnot runnot run
Kit 2.70.2 > served from a build > keeps its client build while one route node is csr=true, as the compiler predictsUnitpassnot runnot runnot run
Kit 2.70.2 > served from a build > keys the remote results it seeds on a csr=true page with `create_remote_key`Unitpassnot runnot runnot run
Kit 2.70.2 > served from a build > links every route node's client stylesheets on a csr=false page, rendered or notUnitpassnot runnot runnot run
Kit 2.70.2 > served from a build whose every route node is csr=false > inlines the stylesheets under `inlineStyleThreshold`, as the compiler reads itUnitpassnot runnot runnot run
Kit 2.70.2 > served from a build whose every route node is csr=false > skips its client build, as the compiler predictsUnitpassnot runnot runnot run
Kit 2.70.2 > served from dev > a remote file's client module imports the remote functions client the compiler resolvesUnitpassnot runnot runnot run
Kit 3.0.1 > served from a build > honours `files.routes`, `outDir`, `appDir` and a zero `inlineStyleThreshold`, as the compiler reads themUnitpassnot runnot runnot run
Kit 3.0.1 > served from a build > keeps its client build while one route node is csr=true, as the compiler predictsUnitpassnot runnot runnot run
Kit 3.0.1 > served from a build > keys the remote results it seeds on a csr=true page with `create_remote_key`Unitpassnot runnot runnot run
Kit 3.0.1 > served from a build > links every route node's client stylesheets on a csr=false page, rendered or notUnitpassnot runnot runnot run
Kit 3.0.1 > served from a build whose every route node is csr=false > inlines the stylesheets under `inlineStyleThreshold`, as the compiler reads itUnitpassnot runnot runnot run
Kit 3.0.1 > served from a build whose every route node is csr=false > skips its client build, as the compiler predictsUnitpassnot runnot runnot run
Kit 3.0.1 > served from dev > a remote file's client module imports the remote functions client the compiler resolvesUnitpassnot runnot runnot run
packages/compiler/test/canary/kit-wire.test.ts
Kit 2.70.2 > exports every name ogygia:server/kit-wire re-exports, taking the parameters the contract typesUnitpassnot runnot runnot run
Kit 3.0.1 > exports every name ogygia:server/kit-wire re-exports, taking the parameters the contract typesUnitpassnot runnot runnot run
packages/compiler/test/canary/svelte-ast.test.ts
the Svelte AST the compiler walks, from the installed Svelte's parse > AnimateDirective has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > AttachTag has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > Attribute has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > AwaitBlock has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > BindDirective has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > Comment has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > Component has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > ConstTag has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > DebugTag has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > EachBlock has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > every template node type a walker names is in the table, so it has a canaryUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > ExpressionTag has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > Fragment has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > HtmlTag has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > IfBlock has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > KeyBlock has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > LetDirective has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > OnDirective has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > RegularElement has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > RenderTag has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > Root has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > Script has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SlotElement has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SnippetBlock has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SpreadAttribute has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > StyleDirective has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteBody has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteBoundary has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteComponent has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteDocument has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteElement has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteFragment has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteHead has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteSelf has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > SvelteWindow has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > Text has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > TitleElement has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > TransitionDirective has the fields ogygia readsUnitpassnot runnot runnot run
the Svelte AST the compiler walks, from the installed Svelte's parse > UseDirective has the fields ogygia readsUnitpassnot runnot runnot run
packages/compiler/test/canary/svelte-entries.test.ts
the Svelte entries the compiler names, in the installed Svelte's exports > svelteUnitpassnot runnot runnot run
the Svelte entries the compiler names, in the installed Svelte's exports > svelte/internal/clientUnitpassnot runnot runnot run
the Svelte entries the compiler names, in the installed Svelte's exports > svelte/serverUnitpassnot runnot runnot run
packages/compiler/test/client-secret-check.test.ts
the client bundle holds no signing secret > a chunk holding a signing module fails the buildUnitpassnot runnot runnot run
the client bundle holds no signing secret > a chunk holding the secret fails the buildUnitpassnot runnot runnot run
the client bundle holds no signing secret > a clean bundle passes; a missing or short secret is not looked forUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "café-signing-secret-0123456", written asciiUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "café-signing-secret-0123456", written jsonUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "café-signing-secret-0123456", written latinUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "café-signing-secret-0123456", written singleUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "café-signing-secret-0123456", written solidusUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "emoji-🔑-signing-secret-0123", written asciiUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "emoji-🔑-signing-secret-0123", written jsonUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "emoji-🔑-signing-secret-0123", written latinUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "emoji-🔑-signing-secret-0123", written singleUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "emoji-🔑-signing-secret-0123", written solidusUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "it's-a-signing-secret-0123", written asciiUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "it's-a-signing-secret-0123", written jsonUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "it's-a-signing-secret-0123", written latinUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "it's-a-signing-secret-0123", written singleUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "it's-a-signing-secret-0123", written solidusUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "pa\"ss\\word-0123456789", written asciiUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "pa\"ss\\word-0123456789", written jsonUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "pa\"ss\\word-0123456789", written latinUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "pa\"ss\\word-0123456789", written singleUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "pa\"ss\\word-0123456789", written solidusUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "sl/ash</script>-secret-0123", written asciiUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "sl/ash</script>-secret-0123", written jsonUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "sl/ash</script>-secret-0123", written latinUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "sl/ash</script>-secret-0123", written singleUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "sl/ash</script>-secret-0123", written solidusUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "tab\there-signing-secret-012", written asciiUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "tab\there-signing-secret-012", written jsonUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "tab\there-signing-secret-012", written latinUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "tab\there-signing-secret-012", written singleUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "tab\there-signing-secret-012", written solidusUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "two\nlines-signing-secret-01", written asciiUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "two\nlines-signing-secret-01", written jsonUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "two\nlines-signing-secret-01", written latinUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "two\nlines-signing-secret-01", written singleUnitpassnot runnot runnot run
the client bundle holds no signing secret > a secret the bundler wrote escaped still fails the build > "two\nlines-signing-secret-01", written solidusUnitpassnot runnot runnot run
the client bundle holds no signing secret > an asset holding the secret fails the buildUnitpassnot runnot runnot run
packages/compiler/test/client-secret-two-legs.test.ts
a client chunk holding the server leg's per-build key fails the build, with one plugin instance per legUnitpassnot runnot runnot run
packages/compiler/test/component-blocks.test.ts
a block is closed by its end tag > a script whose end tag never comes is no blockUnitpassnot runnot runnot run
blanking styles keeps every tag whole > a style whose attribute holds `>`Unitpassnot runnot runnot run
the CSS preprocess keeps the script it strips > `$$` in a TS script is written back as writtenUnitpassnot runnot runnot run
the CSS preprocess keeps the script it strips > a scss style comes out as CSS with its lang droppedUnitpassnot runnot runnot run
the module script of a component > a value that says module is notUnitpassnot runnot runnot run
the module script of a component > an unquoted context=module is the module scriptUnitpassnot runnot runnot run
the script regions of a component > a script inside a comment is not a blockUnitpassnot runnot runnot run
the script regions of a component > a style whose text names a script holds no scriptUnitpassnot runnot runnot run
the script regions of a component > a tag that only starts with `script` is not oneUnitpassnot runnot runnot run
the script regions of a component > a value holding `>` does not end the opening tagUnitpassnot runnot runnot run
which files hold JS regions > a content file is not a host: the markdown preprocessor owns itUnitpassnot runnot runnot run
which files hold JS regions > a JS or TS module is one region from its start, a query after its name includedUnitpassnot runnot runnot run
packages/compiler/test/config-surface.test.ts
an option ogygia() does not have fails the build, never silently does nothing > `content` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `continuity` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `devtools` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `freeze` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `plugins` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `preload` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `profiler` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `regions` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `regionTtl` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > `ttll` is an unknown option, named with the keys there areUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > every option it has is acceptedUnitpassnot runnot runnot run
an option ogygia() does not have fails the build, never silently does nothing > rejects barrels (now the @ogygia/barrels plugin), any valueUnitpassnot runnot runnot run
maxPageAge — the oldest cached page whose holes still come back > defaults to 8 daysUnitpassnot runnot runnot run
maxPageAge — the oldest cached page whose holes still come back > is capped at the prerender capability life (10 years)Unitpassnot runnot runnot run
maxPageAge — the oldest cached page whose holes still come back > never touches the hole URL life (ttl)Unitpassnot runnot runnot run
maxPageAge — the oldest cached page whose holes still come back > rejects anything but seconds ≥ 0Unitpassnot runnot runnot run
maxPageAge — the oldest cached page whose holes still come back > takes the app’s own number (a CDN that keeps pages longer)Unitpassnot runnot runnot run
presets — config-time validation > accepts the full legal vocabularyUnitpassnot runnot runnot run
presets — config-time validation > rejects an empty presetUnitpassnot runnot runnot run
presets — config-time validation > rejects unknown keys (closed vocabulary)Unitpassnot runnot runnot run
presets — config-time validation > takes `fetch`, a deferred hole's timing (0.10.0 rejected it: no deferred preset could be written)Unitpassnot runnot runnot run
router absorbs continuity > on by default with view transitions and forms; server delta only when writtenUnitpassnot runnot runnot run
router absorbs continuity > router: false and router: { forms: false } both accepted; forms is not a top-level keyUnitpassnot runnot runnot run
router absorbs continuity > router: false takes view transitions, forms and server delta with itUnitpassnot runnot runnot run
the region endpoint > rate limit: 60 a minute by default, clamped at 0 and 1 ms, off with falseUnitpassnot runnot runnot run
the region endpoint > session cookie: the name when one is written, else unboundUnitpassnot runnot runnot run
ttl — the capability lifetime > is read from ttl and clamped to [60, 86400]Unitpassnot runnot runnot run
packages/compiler/test/context-gating.test.ts
a provider is detected > detects import { Provide, createContext } from 'ogygia'; (multi-line clause)Unitpassnot runnot runnot run
a provider is detected > detects import { createContext } from 'ogygia'; (createContext)Unitpassnot runnot runnot run
a provider is detected > detects import { Provide } from 'ogygia'; (Provide)Unitpassnot runnot runnot run
a provider is detected > detects import { Region, setContext, preload } from "ogygia"; (among other named imports, dq)Unitpassnot runnot runnot run
a provider is detected > detects import { setContext } from 'ogygia'; (drop-in setContext)Unitpassnot runnot runnot run
a provider is detected > detects import { setContext as sc } from 'ogygia'; (aliased)Unitpassnot runnot runnot run
a provider is detected > detects import * as og from 'ogygia'; og.setContext('k', v); (namespace usage)Unitpassnot runnot runnot run
a provider is detected > detects import type { X } from 'ogygia'; import { setContext } from 'ogygia'; (after a type import)Unitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > counts a getContext read imported from ogygiaUnitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > counts a getContext read imported from svelteUnitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > dedupes repeated reads of the same keyUnitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > does NOT count a dynamic (non-literal) keyUnitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > does NOT count a getContext that is not imported from svelte/ogygiaUnitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > does NOT count a key that is not a string (a number, a template)Unitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > does NOT count a local function named getContextUnitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > does NOT count a method call on an unrelated objectUnitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > follows a namespace member (ns.getContext / ns.setContext)Unitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > follows an alias (getContext as gc)Unitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > follows an import named by a string ('getContext' as gc)Unitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > ignores the word in a comment or string (no import → no parse-time binding)Unitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > reads inside a Svelte component <script>Unitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > separates a setContext (from svelte) into sets, not readsUnitpassnot runnot runnot run
context_keys — follows the getContext/setContext import binding, no text matching > unparseable source is a clean empty (no throw, no false warning)Unitpassnot runnot runnot run
no provider, no bridge > ignores (empty file)Unitpassnot runnot runnot run
no provider, no bridge > ignores const setContext = 1; // just a name (the bare word without an ogygia import)Unitpassnot runnot runnot run
no provider, no bridge > ignores import { getContext } from 'ogygia'; (read-only getContext needs no bridge)Unitpassnot runnot runnot run
no provider, no bridge > ignores import { Region } from 'ogygia'; (a non-context ogygia import)Unitpassnot runnot runnot run
no provider, no bridge > ignores import { setContext } from 'svelte'; (svelte's setContext is same-root, not a bridge)Unitpassnot runnot runnot run
no provider, no bridge > ignores import * as og from 'ogygia'; og.preload(x); (namespace import, non-context member)Unitpassnot runnot runnot run
no provider, no bridge > ignores import type { setContext } from 'ogygia'; (a type-only import runs nothing)Unitpassnot runnot runnot run
resolveFeatures — the mark gates the feature > includes context only when the mark is setUnitpassnot runnot runnot run
resolveFeatures — the mark gates the feature > includes context under kitchen-sink (incomplete marks) — the safe defaultUnitpassnot runnot runnot run
packages/compiler/test/context-symbol-keys.test.ts
a symbol context key is seen at build > a getContext(Symbol.for(name)) read counts under the name the key crosses asUnitpassnot runnot runnot run
a symbol context key is seen at build > a one-off Symbol() key ogygia's setContext keeps off the page with options is not flaggedUnitpassnot runnot runnot run
a symbol context key is seen at build > a setContext(Symbol.for(name)) counts as a set, so an island setting its own is not flaggedUnitpassnot runnot runnot run
a symbol context key is seen at build > ogygia's setContext with a one-off Symbol() key is flagged, inline or through a constUnitpassnot runnot runnot run
a symbol context key is seen at build > Svelte's own setContext with a one-off Symbol() is same-root and is not flaggedUnitpassnot runnot runnot run
packages/compiler/test/csr-skip.test.ts
clientBuildWillSkip — chain-resolved csr (Kit parity) > a csr=true MID-LAYOUT re-scopes its subtree (chain override, both directions)Unitpassnot runnot runnot run
clientBuildWillSkip — chain-resolved csr (Kit parity) > all pages csr=false but the root LAYOUT NODE unset → Kit does NOT skip (node ≠ false)Unitpassnot runnot runnot run
clientBuildWillSkip — chain-resolved csr (Kit parity) > an option-file-only dir (bare `+layout.ts`, no .svelte) still scopes its childrenUnitpassnot runnot runnot run
clientBuildWillSkip — chain-resolved csr (Kit parity) > every node explicitly csr=false (layout AND pages) → skip (the adapters-fixture shape)Unitpassnot runnot runnot run
clientBuildWillSkip — chain-resolved csr (Kit parity) > missing routes dir → never predicts a skipUnitpassnot runnot runnot run
clientBuildWillSkip — chain-resolved csr (Kit parity) > one deep csr=true page under a csr=false root keeps the build aliveUnitpassnot runnot runnot run
clientBuildWillSkip — chain-resolved csr (Kit parity) > server option file beats nothing, universal beats server (Kit merge order)Unitpassnot runnot runnot run
clientBuildWillSkip — chain-resolved csr (Kit parity) > the fresh-app shape (issue #4): csr=false in the ROOT LAYOUT ONLY, option-less pages → skipUnitpassnot runnot runnot run
clientBuildWillSkip — chain-resolved csr (Kit parity) > the injected keepalive dir is invisible to the predictionUnitpassnot runnot runnot run
clientBuildWillSkip — symlinked route files and dirs (Kit follows links) > a dangling link is ignored, as Kit ignores itUnitpassnot runnot runnot run
clientBuildWillSkip — symlinked route files and dirs (Kit follows links) > a linked root +layout.ts (csr=false) + option-less pages → skipUnitpassnot runnot runnot run
clientBuildWillSkip — symlinked route files and dirs (Kit follows links) > a linked route DIRECTORY holding a csr=true page keeps the build aliveUnitpassnot runnot runnot run
read_csr — export shapes > a COMMENTED-OUT csr export does not win over the real one (regression)Unitpassnot runnot runnot run
read_csr — export shapes > reads the TS-annotated form `export const csr: boolean = false`Unitpassnot runnot runnot run
packages/compiler/test/csr-true-host-regions.test.ts
a csr=true route host hands its wake islands to Kit as plain components > drops a wake named import’s attributesUnitpassnot runnot runnot run
a csr=true route host hands its wake islands to Kit as plain components > drops the wake import’s attributes and keeps the hole beside itUnitpassnot runnot runnot run
a csr=true route host keeps the regions the server drives, as a shared component does > a deferred holeUnitpassnot runnot runnot run
a csr=true route host keeps the regions the server drives, as a shared component does > a held regionUnitpassnot runnot runnot run
a csr=true route host keeps the regions the server drives, as a shared component does > a lakeUnitpassnot runnot runnot run
a csr=true route host keeps the regions the server drives, as a shared component does > a live regionUnitpassnot runnot runnot run
a csr=true route host keeps the regions the server drives, as a shared component does > a named-import held regionUnitpassnot runnot runnot run
a csr=true route host keeps the regions the server drives, as a shared component does > a named-import holeUnitpassnot runnot runnot run
a csr=true route host keeps the regions the server drives, as a shared component does > a named-import lakeUnitpassnot runnot runnot run
packages/compiler/test/csr-true-host.test.ts
csr=true host: property over import blocks > strips exactly the imports that name a region key, and the output parsesUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > a host that does not parse is skipped once, with a warning that names itUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > drops the `with { wake }` clause and keeps the import itselfUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > drops the keys of every wake island: wake, and a preset that wakesUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > leaves imports without a region key alone, attributes and allUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > maps the output back to the source it was givenUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > reads the configured key names, not the default onesUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > refuses `asRegion(Comp, …)` as a csr=false page does, printing the import to writeUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > returns null for a host with no region import and no asRegionUnitpassnot runnot runnot run
csr=true host: region imports become plain imports > strips the mark off a named import tooUnitpassnot runnot runnot run
packages/compiler/test/definers.test.ts
mark_definer_calls > leaves a module alone that calls no definerUnitpassnot runnot runnot run
mark_definer_calls > leaves a module alone that does not parse (mid-edit)Unitpassnot runnot runnot run
mark_definer_calls > marks a module still in TypeScript the same, at the same offsetsUnitpassnot runnot runnot run
mark_definer_calls > marks a named, a renamed and a namespace definer call, and asks for the run onceUnitpassnot runnot runnot run
packages/compiler/test/dev-csr-change.test.ts
a page that becomes csr=false while dev runs is compiled again, with its regionsUnitpassnot runnot runnot run
a page that becomes csr=true while dev runs is compiled again, and lets its regions goUnitpassnot runnot runnot run
a page whose csr flips and flips back while dev runs has its regions againUnitpassnot runnot runnot run
a route change that leaves a host its csr compiles nothing againUnitpassnot runnot runnot run
an edit that leaves every route option as it was invalidates nothingUnitpassnot runnot runnot run
deleting the last route file while dev runs leaves no routes, and throws nothingUnitpassnot runnot runnot run
packages/compiler/test/dev-hmr.test.ts
derive_css_scope_owners > a root-level route file owns the empty scope; shared css lists every ownerUnitpassnot runnot runnot run
derive_css_scope_owners > a route file is an owner: the walk does not climb to its importers' scopesUnitpassnot runnot runnot run
derive_css_scope_owners > no route owner found → empty (client treats as shared)Unitpassnot runnot runnot run
derive_css_scope_owners > reaches route files through intermediate lib modules and dedupes scopesUnitpassnot runnot runnot run
derive_css_scope_owners > survives importer cyclesUnitpassnot runnot runnot run
derive_css_scope_owners > walks importers up to route files and reports their top-level scopesUnitpassnot runnot runnot run
dev_hmr_client_source > wires scoped soft CSS HMR and hard full-reload on vite:errorUnitpassnot runnot runnot run
island_vpaths_affected_by_file > ignores unrelated lib filesUnitpassnot runnot runnot run
island_vpaths_affected_by_file > matches deleted / renamed entry components (SiteNav → SideNav stale graph)Unitpassnot runnot runnot run
island_vpaths_affected_by_file > matches host renames that keep the same island id slotUnitpassnot runnot runnot run
needs_csr_false_full_reload > does not reload island / lib components by path alone (registry decides)Unitpassnot runnot runnot run
needs_csr_false_full_reload > does not reload standalone CSS (dev-hmr joins the client graph)Unitpassnot runnot runnot run
needs_csr_false_full_reload > reloads host route shells (SSR-only under csr=false)Unitpassnot runnot runnot run
needs_island_entry_full_reload > does not reload shared .ts deps or unrelated svelteUnitpassnot runnot runnot run
needs_island_entry_full_reload > reloads registered island entry .svelte filesUnitpassnot runnot runnot run
rewrite_island_sourcemap_sources > rewrites basename-only svelte sources to the virtual module idUnitpassnot runnot runnot run
same_module_path > compares absolute paths ignoring querystringsUnitpassnot runnot runnot run
packages/compiler/test/dev-maps.test.ts
install_dev_maps > a module's map is shifted by the runner's lines in front of its first lineUnitpassnot runnot runnot run
install_dev_page_keys > a helper the dev server cannot resolve is not followed, and the island still gets its keysUnitpassnot runnot runnot run
packages/compiler/test/dev-regions-reload.test.ts
a page's first idle region reloads the runtime entry, which then wakes itUnitpassnot runnot runnot run
a transform that registers the same regions again reloads nothingUnitpassnot runnot runnot run
packages/compiler/test/dev-scan-facts.test.ts
a router page module added while dev runs makes its components router CSS roots, as after a restartUnitpassnot runnot runnot run
a wire class added while dev runs is in the browser's wire loaders, as after a restartUnitpassnot runnot runnot run
an app's first remote file added while dev runs turns on Kit's codecs, as after a restartUnitpassnot runnot runnot run
an edit that removes the last wire class drops it from the wire loaders, as after a restartUnitpassnot runnot runnot run
packages/compiler/test/disclose-version.test.ts
another runtime's version joins the same SetUnitpassnot runnot runnot run
nothing is written without a defined version (a plain import of the module)Unitpassnot runnot runnot run
the plugin reads the installed package versionUnitpassnot runnot runnot run
the version the plugin defined joins window.__ogygia.vUnitpassnot runnot runnot run
packages/compiler/test/driver-emit.test.ts
emit: a region module per leg > a module of values only is free of side effects; a module that runs is notUnitpassnot runnot runnot run
emit: a region module per leg > a region descriptor: the server leg gets the signing one, the client metadata onlyUnitpassnot runnot runnot run
emit: a region module per leg > a wrapper: the client leg takes its lazy source, the server its real oneUnitpassnot runnot runnot run
emit: a region module per leg > the client leg points `$app` imports at the shims and drops each lake's JSUnitpassnot runnot runnot run
emit: a region module per leg > the foreign-hydrate exports never reach the server, and reach the client only when askedUnitpassnot runnot runnot run
resolve_id > a generated module's relative import resolves from its host, and joins the island graphUnitpassnot runnot runnot run
resolve_id > a region module id in any dev form resolves to its registered row and joins the island graphUnitpassnot runnot runnot run
resolve_id > island code imports the `$app` shims on the client, and Kit itself on the serverUnitpassnot runnot runnot run
resolve_id > island code's own imports join the island graph on the clientUnitpassnot runnot runnot run
resolve_id > the client binding stub and the CSS-only graph resolve to their own modulesUnitpassnot runnot runnot run
packages/compiler/test/driver-transform-module.test.ts
the driver, elsewhere > dev: a host's edit drops its rows, so nothing serves a region it no longer declaresUnitpassnot runnot runnot run
the driver, elsewhere > has_hydrate_regions: a lake alone is none, a hydrate island is oneUnitpassnot runnot runnot run
transform_module: ownership stamps > never a sub-request, generated glue, or an undeclared packageUnitpassnot runnot runnot run
transform_module: ownership stamps > the server leg stamps an app component's opaque elementsUnitpassnot runnot runnot run
transform_module: seed shaping > each module goes to the seed-shaping plugin by its query-less id, in the source form the transform gotUnitpassnot runnot runnot run
transform_module: seed shaping > without the plugin a page-store reader compiles as beforeUnitpassnot runnot runnot run
transform_module: the island graph is whole before the first module lowers > an island component transformed before its host still gets the `$app` shimUnitpassnot runnot runnot run
transform_module: which modules the region transform reads > a client build emits the entry of a hydrate region only a library host declaresUnitpassnot runnot runnot run
transform_module: which modules the region transform reads > a component's `<script module>` wire class is registered like a `.svelte.ts` oneUnitpassnot runnot runnot run
transform_module: which modules the region transform reads > a component's CSS sub-request is not its script: no region is lowered from itUnitpassnot runnot runnot run
transform_module: which modules the region transform reads > a portable snippet entry is authored markup: its marked imports become regionsUnitpassnot runnot runnot run
transform_module: which modules the region transform reads > a registry's client-leg variant is left exactly as emittedUnitpassnot runnot runnot run
transform_module: which modules the region transform reads > an installed `.svelte` is lowered when its package declares it, or when it carries a markUnitpassnot runnot runnot run
transform_module: which modules the region transform reads > generated glue is never lowered, in its dev `/@id/` form tooUnitpassnot runnot runnot run
transform_module: which modules the region transform reads > the server leg of a build records each module it transforms (the client leg's emit gate)Unitpassnot runnot runnot run
packages/compiler/test/driver.test.ts
a generated entry lowers against its real source file > a registry whose hosts loop back still lowersUnitpassnot runnot runnot run
a generated entry lowers against its real source file > an entry minted from another entry resolves its marked imports from the outermost hostUnitpassnot runnot runnot run
app_shim_for > an `$app` import the alias already sent into Kit finds its shim by where it wentUnitpassnot runnot runnot run
island_scan_entries > a component the dep scanner cannot parse is no entry; its host still isUnitpassnot runnot runnot run
the context-boundary warning > a dependency with marks but no `ogygia.files` is said once per moduleUnitpassnot runnot runnot run
the context-boundary warning > a first-party package imported without its plugin is said once a process, not once a legUnitpassnot runnot runnot run
the context-boundary warning > a key the island sets itself, within one root, is notUnitpassnot runnot runnot run
the context-boundary warning > a one-off Symbol() key handed to ogygia is said at prescanUnitpassnot runnot runnot run
the context-boundary warning > a script module in the island reads context tooUnitpassnot runnot runnot run
the context-boundary warning > an app that bridges context with ogygia is not warnedUnitpassnot runnot runnot run
the context-boundary warning > an island that reads a context key nothing in it sets is warned aboutUnitpassnot runnot runnot run
the island-closure walk > a closure the prescan marked is never read again when a later island shares itUnitpassnot runnot runnot run
the island-closure walk > dev: an island a later transform registers hands its new closure to the next drainUnitpassnot runnot runnot run
the prescan > a declared package file is scanned like app sourceUnitpassnot runnot runnot run
the prescan > a page module the walk did reach keeps what the walk read of itUnitpassnot runnot runnot run
the prescan > a page module the walks never reached still roots its importsUnitpassnot runnot runnot run
the prescan > a plugin reader gets each module by its identity: package-relative in a declared packageUnitpassnot runnot runnot run
the prescan > the feature hash names the runtime features the app usesUnitpassnot runnot runnot run
the region hosts plugins read (b.regions.hosts) > a host with no regions left is not listedUnitpassnot runnot runnot run
the region hosts plugins read (b.regions.hosts) > each host names the components its regions render and the modules minted for themUnitpassnot runnot runnot run
the server-router CSS roots > a build reads them once, after the scanUnitpassnot runnot runnot run
the server-router CSS roots > dev reads them again on each call: a page module joins while the server runsUnitpassnot runnot runnot run
the transform cache > registering a transform keeps it cached: the same source again is not transformed againUnitpassnot runnot runnot run
the transform cache > the server and client transforms of one module are cached apart: their output differsUnitpassnot runnot runnot run
packages/compiler/test/dynamic-region-import.test.ts
dynamic import() with a region key > a region import written in a comment or a string is not a callUnitpassnot runnot runnot run
dynamic import() with a region key > is left alone when no region key is named: import('./C.svelte', { [key]: { wake: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is left alone when no region key is named: import('./C.svelte', { other: { wake: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is left alone when no region key is named: import('./C.svelte', { with: { [key]: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is left alone when no region key is named: import('./C.svelte', { with: attrs })Unitpassnot runnot runnot run
dynamic import() with a region key > is left alone when no region key is named: import('./C.svelte', opts)Unitpassnot runnot runnot run
dynamic import() with a region key > is left alone when no region key is named: import('./C.svelte')Unitpassnot runnot runnot run
dynamic import() with a region key > is left alone when no region key is named: import('./data.json', { with: { type: 'json' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .svelte host: import('./C.svelte', { ...base, with: { ...more, wake: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .svelte host: import('./C.svelte', { 'with': { 'wake': 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .svelte host: import('./C.svelte', { assert: { wake: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .svelte host: import('./C.svelte', { with: { fetch: 'idle' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .svelte host: import('./C.svelte', { with: { preset: 'below' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .svelte host: import('./C.svelte', { with: { render: 'deferred' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .svelte host: import('./C.svelte', { with: { wake: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .svelte host: import('./H.ts', { with: { region: 'held' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .ts module: import('./C.svelte', { ...base, with: { ...more, wake: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .ts module: import('./C.svelte', { 'with': { 'wake': 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .ts module: import('./C.svelte', { assert: { wake: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .ts module: import('./C.svelte', { with: { fetch: 'idle' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .ts module: import('./C.svelte', { with: { preset: 'below' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .ts module: import('./C.svelte', { with: { render: 'deferred' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .ts module: import('./C.svelte', { with: { wake: 'load' } })Unitpassnot runnot runnot run
dynamic import() with a region key > is refused in a .ts module: import('./H.ts', { with: { region: 'held' } })Unitpassnot runnot runnot run
dynamic import() with a region key > names each key once, in the order writtenUnitpassnot runnot runnot run
dynamic import() with a region key > reads the configured key namesUnitpassnot runnot runnot run
packages/compiler/test/emit-gate.test.ts
island_host_loaded > an island with no recorded host (bridge-registered library island) is always emittedUnitpassnot runnot runnot run
island_host_loaded > emits an island whose host the server leg transformedUnitpassnot runnot runnot run
island_host_loaded > skips an island whose host nothing in the server bundle importsUnitpassnot runnot runnot run
island_host_loaded > without a handoff (standalone / client-only build) every prescanned island is emittedUnitpassnot runnot runnot run
the handoff file > lives under Kit outDir and round-trips the server leg's set and keyUnitpassnot runnot runnot run
the handoff file > reads as none when the server leg died mid-write (a torn handoff)Unitpassnot runnot runnot run
the handoff file > reads as none when the server leg wrote nothingUnitpassnot runnot runnot run
the handoff file > tolerates a malformed handoff (nothing gated, never a throw on shape)Unitpassnot runnot runnot run
packages/compiler/test/entry-locations.test.ts
by_code_unit > orders strings as a plain sort does, by UTF-16 code unit, not by localeUnitpassnot runnot runnot run
entry_location: the handoff read at render time > a handoff from before hashing (no entries), or a malformed one → null (the identity is served)Unitpassnot runnot runnot run
entry_location: the handoff read at render time > an identity the build mapped → its locationUnitpassnot runnot runnot run
entry_location: the handoff read at render time > the client leg knows no location; in dev the identity is the locationUnitpassnot runnot runnot run
Region writes the identity as `entry` and the location as `src` > a mapped island: `entry` stays its identity, `src` is its locationUnitpassnot runnot runnot run
Region writes the identity as `entry` and the location as `src` > an unmapped island (dev, old handoff): no `src` at all — the runtime loads the identityUnitpassnot runnot runnot run
Region writes the identity as `entry` and the location as `src` > no location in the handoff: no `src` (the browser finds it in the build’s location map)Unitpassnot runnot runnot run
Region writes the identity as `entry` and the location as `src` > the fingerprint is the identity’s: a new location (a new build) never changes itUnitpassnot runnot runnot run
the collector keys every map by IDENTITY, the location being a hashed file > an entry's own file is never listed as its own dependencyUnitpassnot runnot runnot run
the collector keys every map by IDENTITY, the location being a hashed file > js / css / page / remotes are keyed by the identity, never the hashed nameUnitpassnot runnot runnot run
the collector keys every map by IDENTITY, the location being a hashed file > the runtime's static imports ride under the runtime's identityUnitpassnot runnot runnot run
the collector keys every map by IDENTITY, the location being a hashed file > with entries given, a chunk that merely LOOKS like a stable name is not an entryUnitpassnot runnot runnot run
the collector keys every map by IDENTITY, the location being a hashed file > without entries (a bundle from before hashing): a stable-named facade is its own identity, as beforeUnitpassnot runnot runnot run
the document tail > an island's recorded JS closure leads with its location — the file the profiler weighsUnitpassnot runnot runnot run
the document tail > carries the locations it was told (first wins), and is not empty for them aloneUnitpassnot runnot runnot run
the driver: entries emitted by name, mapped, and shimmed > a second build in one process (watch) emits every island again and maps them allUnitpassnot runnot runnot run
the driver: entries emitted by name, mapped, and shimmed > every island and the runtime are emitted by NAME (hashed by the bundler), never a fixed file nameUnitpassnot runnot runnot run
the driver: entries emitted by name, mapped, and shimmed > identity → location for each, from the bundler’s final namesUnitpassnot runnot runnot run
the driver: entries emitted by name, mapped, and shimmed > no runtime emitted → no runtime location; a second emit starts cleanUnitpassnot runnot runnot run
the driver: entries emitted by name, mapped, and shimmed > our entries get a readable, content-hashed file name; every other chunk keeps the app’s namingUnitpassnot runnot runnot run
the driver: entries emitted by name, mapped, and shimmed > the location maps name every island entry; the handoff learns the hashed one’s path; no other fileUnitpassnot runnot runnot run
the driver: entries emitted by name, mapped, and shimmed > the runtime’s file names its features, like its stable name doesUnitpassnot runnot runnot run
the driver: entries emitted by name, mapped, and shimmed > two builds that emit the islands in another order write the same maps and handoff entries (#490)#490Unitpassnot runnot runnot run
the island graph's `s`: locations of entries no element carries > a graph script is written for locations alone (a page whose only entry is a snippet)Unitpassnot runnot runnot run
the island graph's `s`: locations of entries no element carries > malformed `s` entries are dropped, the rest kept; garbage decodes to nothingUnitpassnot runnot runnot run
the island graph's `s`: locations of entries no element carries > no locations → no `s` key (byte-identical to the format before)Unitpassnot runnot runnot run
the island graph's `s`: locations of entries no element carries > round-trips beside the graph, which is unchangedUnitpassnot runnot runnot run
the location maps: one map, named by its content and at the one fixed name > nothing to map, no fileUnitpassnot runnot runnot run
the location maps: one map, named by its content and at the one fixed name > resolved against where it is served, both sides land where the build put themUnitpassnot runnot runnot run
the location maps: one map, named by its content and at the one fixed name > the content-hashed map: each identity → its hashed file, both relative to the mapUnitpassnot runnot runnot run
the location maps: one map, named by its content and at the one fixed name > the current build’s map: at the one fixed name, beside Kit’s version.json, outside immutable/Unitpassnot runnot runnot run
the location maps: one map, named by its content and at the one fixed name > the same pairs in another order write byte-identical maps under the same names (#490)#490Unitpassnot runnot runnot run
the router's warm scan: identity and location off an open tag > reads each attribute exactly, never a longer name that ends the sameUnitpassnot runnot runnot run
the runtime bootstrap (server/entry-location.ts), shared by every document path > loads the location, with the runtime identity’s static imports preloadedUnitpassnot runnot runnot run
the runtime bootstrap (server/entry-location.ts), shared by every document path > no location (dev, a handoff from before hashing): the identity itselfUnitpassnot runnot runnot run
the runtime bootstrap (server/entry-location.ts), shared by every document path > the base / assets prefix applies to the location and every preloadUnitpassnot runnot runnot run
packages/compiler/test/exports-index.test.ts
a barrel’s map, name by name > a barrel built beside another build of its neighbour is served once, then rebuilt through the finished neighbourUnitpassnot runnot runnot run
a barrel’s map, name by name > a file added while a resolution is out: the resolution is asked again, and its answer is a pathUnitpassnot runnot runnot run
a barrel’s map, name by name > a name ambiguous inside a nested barrel stays on the barrelUnitpassnot runnot runnot run
a barrel’s map, name by name > a re-export of a query import (?raw) stays on the barrelUnitpassnot runnot runnot run
a barrel’s map, name by name > a ring of pure barrels is cached only once the walk that owns it closes itUnitpassnot runnot runnot run
a barrel’s map, name by name > a star into a module that does not parse leaves the map opaqueUnitpassnot runnot runnot run
a barrel’s map, name by name > an edit during a build makes its caller build again from the file as it is nowUnitpassnot runnot runnot run
a barrel’s map, name by name > an edit reported with forward slashes reaches ids a resolver spelled with backslashesUnitpassnot runnot runnot run
a barrel’s map, name by name > an edit to a module a star reached drops the barrel’s mapUnitpassnot runnot runnot run
a barrel’s map, name by name > an edit under a nested barrel during its build leaves the outer map served once, not keptUnitpassnot runnot runnot run
a barrel’s map, name by name > an explicit export wins over a star, two stars with different leaves make a name ambiguous, and a star never brings defaultUnitpassnot runnot runnot run
a barrel’s map, name by name > an id with a query is never a barrelUnitpassnot runnot runnot run
a barrel’s map, name by name > an impure nested module is a leaf in its own right (its code must run for the name)Unitpassnot runnot runnot run
the CSS walk over an export index > walks every root through one parse of a shared barrelUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > a file added in dev reaches a barrel that re-exported it before it existedUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > a file deleted in dev leaves no barrel pointing at itUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > a module that re-exports nothing is no barrel: null whatever the policy says of itUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > a ring of impure modules that star-export each other ends, with every nameUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > any graph of star exports ends, and every name a star reaches is foundUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > leaves a package star opaque unless the policy follows packagesUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > looks through a nested barrel unless the policy keeps itUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > maps an impure module only for a policy that forces itUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > parses each module and resolves each specifier once across policiesUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > re-parses only the edited file, and keeps its resolutionsUnitpassnot runnot runnot run
the export index: one graph, a policy per caller > says why a barrel is left: kept by the policy, or not a candidate (outside the project)Unitpassnot runnot runnot run
packages/compiler/test/exports-parse.test.ts
analyze_exports — shape + purity > a classic barrel is pure: named re-exports, default-as-name, star, star-as-namespace, type re-exportsUnitpassnot runnot runnot run
analyze_exports — shape + purity > a stray semicolon and a type-only export of a local type keep a barrel pureUnitpassnot runnot runnot run
analyze_exports — shape + purity > a syntax error is null, not a shapeUnitpassnot runnot runnot run
analyze_exports — shape + purity > an empty module and a comments-only module are pure with no exportsUnitpassnot runnot runnot run
analyze_exports — shape + purity > const a = 1; export { a }; → impure, own names ["a"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > export { a as "kebab-name" } from "./x"; console.log(1); → impure, own names []Unitpassnot runnot runnot run
analyze_exports — shape + purity > export { x } from "./x"; import.meta.glob("./*.svelte"); → impure, own names []Unitpassnot runnot runnot run
analyze_exports — shape + purity > export * from "./x"; globalThis.__registered = true; → impure, own names []Unitpassnot runnot runnot run
analyze_exports — shape + purity > export class C {} → impure, own names ["C"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > export const [x, , ...rest] = arr; → impure, own names ["x","rest"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > export const { a, ...rest } = o; → impure, own names ["a","rest"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > export const a = 1; → impure, own names ["a"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > export default 42; → impure, own names ["default"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > export default function () {} → impure, own names ["default"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > export function f() {} → impure, own names ["f"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > export let { a, b: c } = o; → impure, own names ["a","c"]Unitpassnot runnot runnot run
analyze_exports — shape + purity > if (x) {} → impure, own names []Unitpassnot runnot runnot run
analyze_exports — shape + purity > import "./polyfill"; export * from "./x"; → impure, own names []Unitpassnot runnot runnot run
analyze_exports — shape + purity > import "./theme.css"; export { default as Button } from "./Button.svelte"; → impure, own names []Unitpassnot runnot runnot run
analyze_exports — shape + purity > import * as setup from "./setup"; export { x } from "./x"; → impure, own names []Unitpassnot runnot runnot run
analyze_exports — shape + purity > import-then-export is a re-export through the binding (named, default, namespace)Unitpassnot runnot runnot run
analyze_exports — shape + purity > records string-literal export names verbatim (the rewriter skips them)Unitpassnot runnot runnot run
analyze_exports — shape + purity > sideEffect(); → impure, own names []Unitpassnot runnot runnot run
analyze_exports — shape + purity > type declarations do not make a module impure; enums doUnitpassnot runnot runnot run
analyze_imports > handles the cursed spellings: no semicolons, no spaces, comments inside, unicode, `default as`Unitpassnot runnot runnot run
analyze_imports > ignores dynamic imports and require calls (not declarations)Unitpassnot runnot runnot run
analyze_imports > keeps the verbatim import-attributes clause (with / assert) and its keys, semicolon or notUnitpassnot runnot runnot run
analyze_imports > reads every specifier kind with exact source rangesUnitpassnot runnot runnot run
analyze_imports > returns null on a syntax error (the real compiler reports it)Unitpassnot runnot runnot run
packages/compiler/test/fouc-css-compile.test.ts
compileFoucScopedCss > a preprocessed component that still fails to compile is reported; an unprocessed one is notUnitpassnot runnot runnot run
compileFoucScopedCss > a script Svelte cannot read: the markup is scoped without itUnitpassnot runnot runnot run
compileFoucScopedCss > a script with a top-level await compiles once, wholeUnitpassnot runnot runnot run
compileFoucScopedCss > a template that binds a script name compiles once, wholeUnitpassnot runnot runnot run
packages/compiler/test/fouc-css-ids.test.ts
a fouc id never names a file outside the project > ..Unitpassnot runnot runnot run
a fouc id never names a file outside the project > ../secret.svelteUnitpassnot runnot runnot run
a fouc id never names a file outside the project > ..%2F..%2Fetc%2FpasswdUnitpassnot runnot runnot run
a fouc id never names a file outside the project > /etc/passwdUnitpassnot runnot runnot run
a fouc id never names a file outside the project > \windows\win.iniUnitpassnot runnot runnot run
a fouc id never names a file outside the project > %2Fetc%2FpasswdUnitpassnot runnot runnot run
a fouc id never names a file outside the project > %5Cwindows%5Cwin.iniUnitpassnot runnot runnot run
a fouc id never names a file outside the project > c:/secret.svelteUnitpassnot runnot runnot run
a fouc id never names a file outside the project > C:\secret.svelteUnitpassnot runnot runnot run
a fouc id never names a file outside the project > src/..Unitpassnot runnot runnot run
a fouc id never names a file outside the project > src/.../A.svelte is a plain name, keptUnitpassnot runnot runnot run
a fouc id never names a file outside the project > src/../../secret.svelteUnitpassnot runnot runnot run
a fouc id never names a file outside the project > src/..a/A.svelte is a plain name, keptUnitpassnot runnot runnot run
a fouc id never names a file outside the project > src/a../A.svelte is a plain name, keptUnitpassnot runnot runnot run
a fouc id never names a file outside the project > src\..\..\secret.svelteUnitpassnot runnot runnot run
a fouc id never names a file outside the project > src%2F..%2F..%2Fsecret.svelteUnitpassnot runnot runnot run
fouc ids round-trip > a backslash path is written with slashesUnitpassnot runnot runnot run
fouc ids round-trip > another module of the same extension is not a fouc idUnitpassnot runnot runnot run
fouc ids round-trip > ogygia:region/fouc-css/src%2Flib%2FA.svelte.css decodes to nullUnitpassnot runnot runnot run
fouc ids round-trip > ogygia:region/fouc-scoped/bad%E0%A4%A.css decodes to bad%E0%A4%AUnitpassnot runnot runnot run
fouc ids round-trip > ogygia:region/fouc-scoped/src%2Flib%2FA.svelte.js decodes to nullUnitpassnot runnot runnot run
fouc ids round-trip > ogygia:region/other/src%2Flib%2FA.svelte.js decodes to nullUnitpassnot runnot runnot run
fouc ids round-trip > src/lib/a b%c.svelteUnitpassnot runnot runnot run
fouc ids round-trip > src/lib/A.svelteUnitpassnot runnot runnot run
fouc ids round-trip > src/routes/(app)/[slug]/+page.svelteUnitpassnot runnot runnot run
the unscoped fallback unwraps :global(…) > keeps the selector inside, nested parentheses and allUnitpassnot runnot runnot run
packages/compiler/test/fouc-css-reach.test.ts
a barrel brings the CSS of what is taken from it > a barrel with a star it cannot follow brings everything it reachesUnitpassnot runnot runnot run
a barrel brings the CSS of what is taken from it > a barrel's own code taken by name brings everything the barrel importsUnitpassnot runnot runnot run
a barrel brings the CSS of what is taken from it > a namespace import takes every nameUnitpassnot runnot runnot run
a barrel brings the CSS of what is taken from it > a namespace re-export taken by name brings the whole namespaceUnitpassnot runnot runnot run
a barrel brings the CSS of what is taken from it > a type-only name taken from a barrel brings nothing moreUnitpassnot runnot runnot run
a component's static imports > a style the markup parser cannot read does not lose the names takenUnitpassnot runnot runnot run
a component's static imports > markup that does not parse still yields its imports, every name takenUnitpassnot runnot runnot run
a module with code of its own > a dependency's own JavaScript is not walkedUnitpassnot runnot runnot run
a module with code of its own > a type-only import brings nothingUnitpassnot runnot runnot run
a module with code of its own > brings what it re-exports, by name, by star and by namespaceUnitpassnot runnot runnot run
the fouc module > a styled component outside the app root is left outUnitpassnot runnot runnot run
packages/compiler/test/fouc-css-win32.test.ts
a styled component on another drive than the root is left outUnitpassnot runnot runnot run
the same component on the root drive rides itUnitpassnot runnot runnot run
packages/compiler/test/fouc-css.test.ts
fouc-css collector > a module with code of its own brings every component it importsUnitpassnot runnot runnot run
fouc-css collector > a package barrel and a local barrel: the names taken, and only thoseUnitpassnot runnot runnot run
fouc-css collector > compileFoucScopedCss keeps filename-scoped outputUnitpassnot runnot runnot run
fouc-css collector > foucCssVirtualId normalizes separatorsUnitpassnot runnot runnot run
fouc-css collector > listStaticImports reads side-effect css imports and the names takenUnitpassnot runnot runnot run
fouc-css collector > raw-fallback CSS is valid: :global(...) is unwrapped, not left literalUnitpassnot runnot runnot run
fouc-css collector > walks child .svelte + plain css without emitting component JSUnitpassnot runnot runnot run
packages/compiler/test/fouc-scope-leak.test.ts
fouc-scoped CSS: a lake/island keeps Svelte scoping and never leaks global > a bare compile (no keepScript) of a store-referencing component is scoped tooUnitpassnot runnot runnot run
fouc-scoped CSS: a lake/island keeps Svelte scoping and never leaks global > a fallback that ships unscoped says so in the CSS, with the file name onlyUnitpassnot runnot runnot run
fouc-scoped CSS: a lake/island keeps Svelte scoping and never leaks global > BUG REPRO — bare compile of a <style lang="scss"> component ships UNSCOPEDUnitpassnot runnot runnot run
fouc-scoped CSS: a lake/island keeps Svelte scoping and never leaks global > FIX — keepScript compiles the same component to scoped selectorsUnitpassnot runnot runnot run
fouc-scoped CSS: a lake/island keeps Svelte scoping and never leaks global > FIX — preprocess (scss→css) + keepScript compiles to scoped selectorsUnitpassnot runnot runnot run
fouc-scoped CSS: a lake/island keeps Svelte scoping and never leaks global > the two scoped classes carry the SAME hash (one component, one scope)Unitpassnot runnot runnot run
fouc-scoped CSS: a lake/island keeps Svelte scoping and never leaks global > TypeScript in the MARKUP (a typed arrow) still compiles scopedUnitpassnot runnot runnot run
packages/compiler/test/free-vars-directives.test.ts
a portable snippet entry declares every name its markup reads from the host > import { act } from './act.ts'; used as <p use:act>x</p>Unitpassnot runnot runnot run
a portable snippet entry declares every name its markup reads from the host > import { fade } from 'svelte/transition'; used as <p transition:fade>x</p>Unitpassnot runnot runnot run
a portable snippet entry declares every name its markup reads from the host > import Comp from './Comp.svelte'; used as <svelte:component this={Comp} />Unitpassnot runnot runnot run
a portable snippet entry declares every name its markup reads from the host > let color = 'red'; used as <p style:color>x</p>Unitpassnot runnot runnot run
collectFreeIdentifiers > {(() => { class K {} return K; })()} → []Unitpassnot runnot runnot run
collectFreeIdentifiers > {(() => { for (const k in o) k; return k; })()} → ["k","o"]Unitpassnot runnot runnot run
collectFreeIdentifiers > {(() => { for (const q of qs) q; return q; })()} → ["q","qs"]Unitpassnot runnot runnot run
collectFreeIdentifiers > {(() => { for (let i = 0; i < n; i++); return i; })()} → ["i","n"]Unitpassnot runnot runnot run
collectFreeIdentifiers > {#each xs as x (x)}<p animate:flip>{x}</p>{/each} → ["flip","xs"]Unitpassnot runnot runnot run
collectFreeIdentifiers > {#each xs as x}<p use:act={x}>x</p>{/each} → ["act","xs"]Unitpassnot runnot runnot run
collectFreeIdentifiers > {class { m() { return t; } }} → ["t"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <p class:active>x</p> → ["active"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <p in:fly={{ y }} out:fade>x</p> → ["fade","fly","y"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <p style:color="red">x</p> → []Unitpassnot runnot runnot run
collectFreeIdentifiers > <p style:color={c}>x</p> → ["c"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <p style:color>x</p> → ["color"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <p transition:fade>x</p> → ["fade"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <p use:act={arg}>x</p> → ["act","arg"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <p use:act>x</p> → ["act"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <p use:lib.act>x</p> → ["lib"]Unitpassnot runnot runnot run
collectFreeIdentifiers > <svelte:component this={Comp} n={1} /> → ["Comp"]Unitpassnot runnot runnot run
packages/compiler/test/free-vars-patterns.test.ts
a portable snippet entry declares the names its patterns read > a {@debug} name from the host is capturedUnitpassnot runnot runnot run
a portable snippet entry declares the names its patterns read > a computed key in the snippet's own parameters, from the host, is capturedUnitpassnot runnot runnot run
a portable snippet entry declares the names its patterns read > a default in the snippet's own parameters, from an import, is importedUnitpassnot runnot runnot run
a portable snippet entry declares the names its patterns read > a pattern default in the snippet's own parameters, from the host, is capturedUnitpassnot runnot runnot run
a portable snippet entry declares the names its patterns read > an each default from an import is importedUnitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {(() => { try { f(); } catch ({ message = d }) { return message; } })()} → ["d","f"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {(() => { try { f(); } catch (e) { return e; } })()} → ["f"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {(() => { try { f(); } catch (e) {} return e; })()} → ["e","f"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {@const { k = d } = o}{k} → ["d","o"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {@debug x, y} → ["x","y"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {#await p then { v = d }}{v}{/await} → ["d","p"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {#each xs as [a = dflt, { b: [c = more] }]}{a}{c}{/each} → ["dflt","more","xs"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {#each xs as { [key]: v }}{v}{/each} → ["key","xs"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {#each xs as { a = dflt }}{a}{/each} → ["dflt","xs"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {#snippet row({ a = d })}{a}{/snippet} → ["d"]Unitpassnot runnot runnot run
collectFreeIdentifiers: names read by patterns, tags and clauses > {#snippet row(item, f = fmt)}{f(item)}{/snippet} → ["fmt"]Unitpassnot runnot runnot run
packages/compiler/test/free-vars-scopes.test.ts
collectCaptureInfo: a name in a non-reading position is no capture > {(() => { a: for (;;) break a; })()} → []Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {(() => { const z = 1; return z; })()} → []Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {({ [k]: v })} → ["k","v"]Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {({ k })} → ["k"]Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {({ k: v })} → ["v"]Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {(class { m() {} x = 1; [k]() {} })} → ["k"]Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {(class { static { class Q {} Q; } })} → []Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {(class { static { const q = 1; q; } })} → []Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {(class K {})} → []Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {(function f(p) { return f(p); })} → []Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {#each xs as act}<p use:act>x</p>{/each} → ["xs"]Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {a.b} → ["a"]Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {a[b]} → ["a","b"]Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > {import.meta.env} → []Unitpassnot runnot runnot run
collectCaptureInfo: a name in a non-reading position is no capture > <script lang="ts"></script>{(x as Foo)}{(y!)}{((z: Bar): Baz => z)}{f<T>(w)} → ["f","w","x","y"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { { const q = 1; } return q; })()} → ["q"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { { var q = 1; } return q; })()} → []Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { class K { static { class Q {} } } return Q; })()} → ["Q"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { class K { static { const q = 1; } } return q; })()} → ["q"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { class K { static { var q = 1; } } return q; })()} → ["q"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { class K {} return K; })()} → []Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { const C = class K {}; return K; })()} → ["K"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { f(); function f() {} })()} → []Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { for (var i = 0; ; ) {} for (var k in o) {} while (c) { var w; } do { var dw; } while (c); try { var t; } catch { var h; } finally { var fi; } switch (c) { case 1: var sw; } lbl: { var lb; } return [i, k, w, dw, t, h, fi, sw, lb]; })()} → ["c","o"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { if (c) { var v = 1; } return v; })()} → ["c"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { switch (a) { case 1: let s = 1; } return s; })()} → ["a","s"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(() => { switch (a) { case 1: let s = 1; s; } })()} → ["a"]Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > {(class K { m() { return K; } })} → []Unitpassnot runnot runnot run
collectCaptureInfo: a scope binds its names before any is read > a program binds its imports, exports, declarations and every `var`, however deepUnitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > {#each xs as x}<input bind:value={x} />{/each} → []Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > {#snippet sn(p)}<button onclick={() => p++}>x</button>{/snippet} → []Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > <button onclick={() => ([p, q] = r)}>x</button> → ["p","q"]Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > <button onclick={() => ({ s, t: [u = 1], ...w } = r)}>x</button> → ["s","u","w"]Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > <button onclick={() => (a.b = 1)}>x</button> → ["a"]Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > <button onclick={() => { let n = 0; n++; }}>x</button> → []Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > <button onclick={() => count++}>x</button> → ["count"]Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > <input bind:value={o.k} /> → ["o"]Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > <input bind:value={v} /> → ["v"]Unitpassnot runnot runnot run
collectCaptureInfo: a write into a capture is a mutation > a bound name is read as well as writtenUnitpassnot runnot runnot run
collectCaptureInfo: every `$store` read site is kept > a bound `$name` is no store readUnitpassnot runnot runnot run
collectCaptureInfo: every `$store` read site is kept > a free `$name` is a store read at each siteUnitpassnot runnot runnot run
collectCaptureInfo: every `$store` read site is kept > a plain name is no store readUnitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {@const c = 1}{c} → []Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {@html h} → ["h"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {@render s()}{#snippet s()}{n}{/snippet} → ["n"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {#await p}{w}{:then v}{v}{:catch err}{err}{/await} → ["p","w"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {#each xs as x (k)}{x}{/each} → ["k","xs"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {#each xs as x, i (i)}{x}{/each} → ["xs"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {#each xs as x}{x}{:else}{e}{/each} → ["e","xs"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {#each xs as x}<x.Y />{/each} → ["xs"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {#key k}{c}{/key} → ["c","k"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > {#snippet s()}{n}{/snippet}{@render s()} → ["n"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <C let:item={[a = 1]}>{a}</C> → ["C"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <C let:item={[a = a]}>{a}</C> → ["C"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <C let:item={[a = d]}>{a}</C> → ["C","d"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <C let:item={[a, ...rest]}>{a}{rest}</C> → ["C"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <C let:item={{ [k]: v }}>{v}</C> → ["C","k"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <C let:item={{ x: [b = d] }}>{b}</C> → ["C","d"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <C let:item>{item}</C> → ["C"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <Foo.Bar /> → ["Foo"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <p {...rest}>x</p> → ["rest"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <p hidden>x</p> → []Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <p on:click={h}>x</p> → ["h"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <p title="a {t} b">x</p> → ["t"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <p title={t}>x</p> → ["t"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <svelte:boundary>{b}</svelte:boundary> → ["b"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <svelte:element this={tag} /> → ["tag"]Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <svelte:fragment let:item>{item}</svelte:fragment> → []Unitpassnot runnot runnot run
collectCaptureInfo: the template binds and reads > <svelte:head><title>{t}</title></svelte:head> → ["t"]Unitpassnot runnot runnot run
packages/compiler/test/fs-seam.test.ts
the compiler reads an app through its fs seam > a prescan of an app that exists only in memory registers its region and its closureUnitpassnot runnot runnot run
the compiler reads an app through its fs seam > an edit to a file in memory is seen once the watcher tells the route readerUnitpassnot runnot runnot run
the compiler reads an app through its fs seam > memory_fs lists a directory sorted, with no entry for a removed fileUnitpassnot runnot runnot run
the compiler reads an app through its fs seam > route worlds and route config come from the seam, and each file system has its ownUnitpassnot runnot runnot run
the compiler reads app files only through its fs seamUnitpassnot runnot runnot run
packages/compiler/test/ids-browser-safe.test.ts
@ogygia/compiler/ids > reaches only its own import-free modules, never core or the compiler’s messagesUnitpassnot runnot runnot run
packages/compiler/test/injected-import-consumer-resolve.test.ts
ogygia injected imports resolve to ogygia's own files, without this.resolve > does not depend on the importer (same result from the app root)Unitpassnot runnot runnot run
ogygia injected imports resolve to ogygia's own files, without this.resolve > ogygia/internal from a sub-package host resolves directlyUnitpassnot runnot runnot run
ogygia injected imports resolve to ogygia's own files, without this.resolve > ogygia/internal/server likewiseUnitpassnot runnot runnot run
ogygia injected imports resolve to ogygia's own files, without this.resolve > resolves even when `root` is unset (throwaway instance whose configResolved never ran)Unitpassnot runnot runnot run
ogygia injected imports resolve to ogygia's own files, without this.resolve > the resolved file actually exists on diskUnitpassnot runnot runnot run
packages/compiler/test/island-closure-alias.test.ts
island closure walk follows app aliases > a helper reached through a `kit.alias` import is island code after prescanUnitpassnot runnot runnot run
island closure walk follows app aliases > a RegExp alias (Kit’s shape for `key/*`) is followed tooUnitpassnot runnot runnot run
island closure walk follows app aliases > the marked script helper leaves the client transform importing the SHIM, not Kit’s `$app/state`Unitpassnot runnot runnot run
packages/compiler/test/island-deps-handoff-emit.test.ts
emit_island_deps_handoff > a chunk that cannot be read is skipped, and the next one is still patchedUnitpassnot runnot runnot run
emit_island_deps_handoff > a server folder that cannot be listed is skipped, and the chunks beside it are still patchedUnitpassnot runnot runnot run
emit_island_deps_handoff > a server output that is a file, not a folder: the handoff is still written, and nothing throwsUnitpassnot runnot runnot run
emit_island_deps_handoff > a slotted chunk that cannot be written is left as it was, and nothing throwsUnitpassnot runnot runnot run
emit_island_deps_handoff > inlines into every slotted server chunk, nested, in either quote styleUnitpassnot runnot runnot run
emit_island_deps_handoff > leaves chunks without the slot, and other files, as they wereUnitpassnot runnot runnot run
emit_island_deps_handoff > with no server output yet, still writes the handoffUnitpassnot runnot runnot run
emit_island_deps_handoff > writes the handoff and the server copyUnitpassnot runnot runnot run
packages/compiler/test/island-deps.test.ts
collect_inline_css > keeps the text of sheets under the threshold, keyed by their public hrefUnitpassnot runnot runnot run
collect_inline_css > over the threshold, not an asset, missing, or able to close its own <style>: linked, not inlinedUnitpassnot runnot runnot run
collect_inline_css > the threshold is Kit’s unit (String.length, strictly smaller), and 0 / absent means never inlineUnitpassnot runnot runnot run
collect_inline_css > the virtual module exposes region_css_inline on every leg (null where nothing is kept)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > collects CSS from the facade + dep chunks (viteMetadata.importedCss)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > dedupes cycles and skips the facade itselfUnitpassnot runnot runnot run
collectIslandDepModulepreloads > ignores assets; the runtime is recorded only under its EXACT name (a phantom import skipped)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > a chunk’s heaviest named modules with their bytes, a package summed, and the chunk totalUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > a pnpm package is named by its last node_modules segmentUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > an await in the markup is a value that lands after the wake (a live query, a promise)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > counts handlers / state / effects / binds / actions across the closure, one file onceUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > every chunk the build emitted is summarized, not only the ones islands pullUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > no reader → no facts; a pure-markup island reads as zero everywhereUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > state another island can change: a context read, a rune module importUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > the contents the collector keeps name the heaviest module firstUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > the lines that draw differently in the browser: the app's and the site kit's, never another package'sUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > what is inside each chunk: app files first, packages named, the runtimes plainly, cappedUnitpassnot runnot runnot run
collectIslandDepModulepreloads > interactivity > with the bundler’s sizes, the heaviest are named first (a big file is never hidden in "+N more")Unitpassnot runnot runnot run
collectIslandDepModulepreloads > only a chunk named like a facade is an island entryUnitpassnot runnot runnot run
collectIslandDepModulepreloads > page-keys map > a dynamically-imported page reader contributes its keys to the parent seedUnitpassnot runnot runnot run
collectIslandDepModulepreloads > page-keys map > a non-reader has no page_keys entry; query suffixes are stripped for the lookupUnitpassnot runnot runnot run
collectIslandDepModulepreloads > page-keys map > a reader whose keys no module recorded → null (the page reached through unseen code)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > page-keys map > an island that reads the page ONLY through a dynamic import still asks for the seedUnitpassnot runnot runnot run
collectIslandDepModulepreloads > page-keys map > an unpinned dynamically-imported reader ships all (fail-open, like a static one)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > page-keys map > keys union across the facade and a dep chunk, sortedUnitpassnot runnot runnot run
collectIslandDepModulepreloads > page-keys map > one unpinned module → null (ship all)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > page-reader map > module ids with a query suffix or Windows separators still matchUnitpassnot runnot runnot run
collectIslandDepModulepreloads > page-reader map > no reader files given → every entry false (the map still lists it)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > page-reader map > no shim anywhere in the closure → does not read (false, present in the map)Unitpassnot runnot runnot run
collectIslandDepModulepreloads > page-reader map > shim in a transitive dep chunk → readsUnitpassnot runnot runnot run
collectIslandDepModulepreloads > page-reader map > shim in the facade itself → readsUnitpassnot runnot runnot run
collectIslandDepModulepreloads > records the runtime chunk’s static imports (not its lazy chunks) under its URLUnitpassnot runnot runnot run
collectIslandDepModulepreloads > walks transitive static imports for og-region facadesUnitpassnot runnot runnot run
collectIslandDepModulepreloads > with entries given, every map is keyed by the identity, never the hashed fileUnitpassnot runnot runnot run
islandDepsHandoffPath > is under Kit outDir (`.svelte-kit` by default, whatever the app configured otherwise)Unitpassnot runnot runnot run
one module, two copies > a package file by its source and its build, or two installed versions, is one key; the copies say where they came fromUnitpassnot runnot runnot run
one module, two copies > only a key with two ids is a duplicate; small copies are left out; the heaviest firstUnitpassnot runnot runnot run
remotes map > a non-island chunk that imports a remote adds nothing to any islandUnitpassnot runnot runnot run
remotes map > a phantom (non-emitted) import is skipped, a cycle terminatesUnitpassnot runnot runnot run
remotes map > at scale: 3 000 chunks, 300 facades, 60 remote modules, shared + dynamic + cyclic edges — exact vs a naive reference, fastUnitpassnot runnot runnot run
remotes map > kit_remote_hash / remote_hash_of — Kit parity > .remote.js / .mjs / .cjs / .mts count; anything else is not a remoteUnitpassnot runnot runnot run
remotes map > kit_remote_hash / remote_hash_of — Kit parity > a `?query` suffix and Windows separators do not change the hashUnitpassnot runnot runnot run
remotes map > kit_remote_hash / remote_hash_of — Kit parity > a remote module id hashes by its path relative to cwd, posixUnitpassnot runnot runnot run
remotes map > kit_remote_hash / remote_hash_of — Kit parity > vectors observed on a real Kit build (`internals.id` = `${hash}/${name}`)Unitpassnot runnot runnot run
remotes map > no remote anywhere in the closure → [] (present in the map: a known entry that calls nothing)Unitpassnot runnot runnot run
remotes map > no resolver given → every entry [] (the map still lists it)Unitpassnot runnot runnot run
remotes map > remote behind a DYNAMIC import → listed (still this island’s call), not preloadedUnitpassnot runnot runnot run
remotes map > remote in a transitive STATIC dep chunk → listedUnitpassnot runnot runnot run
remotes map > remote in the facade itself → listedUnitpassnot runnot runnot run
remotes map > several remotes → every one, deduped and sorted (byte-stable handoff)Unitpassnot runnot runnot run
remotes map > the virtual module off the production server > dev links a region by its module url, always seeds the page, and an identity is its own locationUnitpassnot runnot runnot run
remotes map > the virtual module off the production server > the client leg answers none for every readerUnitpassnot runnot runnot run
remotes map > the virtual module’s region_remotes > client leg → null (unused there)Unitpassnot runnot runnot run
remotes map > the virtual module’s region_remotes > dev → null (fail-open: no chunk closure to consult)Unitpassnot runnot runnot run
remotes map > the virtual module’s region_remotes > prod SSR → reads the handoff’s `remotes` map, null for a missing map or unknown entryUnitpassnot runnot runnot run
the virtual module’s handoff read > a handoff that does not parse is said, and not kept: the next read finds the fixed oneUnitpassnot runnot runnot run
the virtual module’s handoff read > an inlined handoff has no problemUnitpassnot runnot runnot run
the virtual module’s handoff read > no handoff anywhere: its problem names every path it triedUnitpassnot runnot runnot run
packages/compiler/test/island-entry-recover.test.ts
island_entry_source — the foreign-hydrate contract > __og_hydrate takes options and hands them to the producer’s helper with this componentUnitpassnot runnot runnot run
island_entry_source — the foreign-hydrate contract > still exports the unmounter and the component default; the foreign exports sit after the markUnitpassnot runnot runnot run
island_entry_source — the foreign-hydrate contract > the helper forwards recover:false to svelte, nothing otherwise, and re-checks the envelope every callUnitpassnot runnot runnot run
packages/compiler/test/island-graph.test.ts
island graph — a placed island > an island with no chunks of its own (dev) carries no graph scriptUnitpassnot runnot runnot run
island graph — a placed island > wake (min-width: 600px): graph data, no modulepreload tagUnitpassnot runnot runnot run
island graph — a placed island > wake idle: graph data, no modulepreload tagUnitpassnot runnot runnot run
island graph — a placed island > wake interaction: graph data, no modulepreload tagUnitpassnot runnot runnot run
island graph — a placed island > wake load: graph data, no modulepreload tagUnitpassnot runnot runnot run
island graph — a placed island > wake visible: graph data, no modulepreload tagUnitpassnot runnot runnot run
island graph — encode / decode > malformed text decodes to nothing, never throwsUnitpassnot runnot runnot run
island graph — encode / decode > round-trips, naming each shared chunk onceUnitpassnot runnot runnot run
island graph — encode / decode > the script cannot be broken out ofUnitpassnot runnot runnot run
island graph — the document tail > one script for the page, one list per entry (first wins)Unitpassnot runnot runnot run
preload is gone > the key is an unknown option, a build errorUnitpassnot runnot runnot run
preload is gone > the minted virtual module no longer exports a policyUnitpassnot runnot runnot run
packages/compiler/test/island-ownership.test.ts
server-island host legs (the compiler contract the registry depends on) > already-transformed output does not conjure a phantom island from the fallback snippetUnitpassnot runnot runnot run
server-island host legs (the compiler contract the registry depends on) > csr=false CLIENT leg: stub import (never the wrapper), island still carries wrapper sourceUnitpassnot runnot runnot run
server-island host legs (the compiler contract the registry depends on) > SSR leg: wrapper import + island registered WITH wrapper sourceUnitpassnot runnot runnot run
packages/compiler/test/island-scan-entries.test.ts
island_scan_entries — crawl roots for Vite’s own dep scanner > a lake and a server island are not entries — neither is client codeUnitpassnot runnot runnot run
island_scan_entries — crawl roots for Vite’s own dep scanner > entries are real, absolute, existing source files — never a bare package, query or virtual idUnitpassnot runnot runnot run
island_scan_entries — crawl roots for Vite’s own dep scanner > every hydrate island’s component file AND its host file are entriesUnitpassnot runnot runnot run
island_scan_entries — crawl roots for Vite’s own dep scanner > is sorted and free of duplicates, so the optimizer config is stable run to runUnitpassnot runnot runnot run
packages/compiler/test/island-sourcemaps.test.ts
island_sourcemaps_plugin > an entry with no combined map, or an empty one, keeps what it hasUnitpassnot runnot runnot run
island_sourcemaps_plugin > drops a wrapper's mapUnitpassnot runnot runnot run
island_sourcemaps_plugin > keeps sources content a map already hasUnitpassnot runnot runnot run
island_sourcemaps_plugin > leaves a module that is not an island aloneUnitpassnot runnot runnot run
island_sourcemaps_plugin > points an entry's map at its virtual id and carries the generated sourceUnitpassnot runnot runnot run
packages/compiler/test/keep-client-worker.test.ts
a worker thread's build (Kit's analyse and prerender) neither injects the keep-client route nor sweeps itUnitpassnot runnot runnot run
packages/compiler/test/kit-absent.test.ts
no Kit resolves from the app root > a Kit that does not resolve (its manifest not exported) has none of Kit's pathsUnitpassnot runnot runnot run
no Kit resolves from the app root > a Kit whose package.json does not parse has no major versionUnitpassnot runnot runnot run
packages/compiler/test/kit-dirs.test.ts
kit.files.routes / kit.outDir > a compile context holds the dirs it was given, and the defaults when given noneUnitpassnot runnot runnot run
kit.files.routes / kit.outDir > a svelte.config.js that throws as it loads: the defaults, and kit_config_unreadable says whyUnitpassnot runnot runnot run
kit.files.routes / kit.outDir > defaults to src/routes + .svelte-kit without a config, or with a config that sets neitherUnitpassnot runnot runnot run
kit.files.routes / kit.outDir > Kit's inlineStyleThreshold is read for the region CSS too; none, or a value that is not a positive number, is 0Unitpassnot runnot runnot run
kit.files.routes / kit.outDir > off Kit's own plugin: Kit 3's options at the top (vite.config only), Kit 2's under `kit`Unitpassnot runnot runnot run
kit.files.routes / kit.outDir > reads both from svelte.config.js and resolves them against the rootUnitpassnot runnot runnot run
kit.files.routes / kit.outDir > the app's universal and client hooks are found as .ts or .jsUnitpassnot runnot runnot run
kit.files.routes / kit.outDir > the SSR deps reader falls back to the configured outDir under cwd, not `.svelte-kit`Unitpassnot runnot runnot run
packages/compiler/test/late-island.test.ts
async twins > async mode is read off vite-plugin-svelte’s resolved optionsUnitpassnot runnot runnot run
async twins > each plain one compiles without async mode; each awaiting one needs itUnitpassnot runnot runnot run
async twins > Region imports each plain one, by the path the plugin redirectsUnitpassnot runnot runnot run
async twins > the redirect: only Region’s twin imports, to the awaiting file beside that copy of RegionUnitpassnot runnot runnot run
packages/compiler/test/lazy-entry.test.ts
wake island — the wrapper is leg-split, the client leg is lazy > a stamp with a quote in the entry cannot break out of the selectorUnitpassnot runnot runnot run
wake island — the wrapper is leg-split, the client leg is lazy > keep + strategy attributes ride the client wrapper exactly as the SSR oneUnitpassnot runnot runnot run
wake island — the wrapper is leg-split, the client leg is lazy > mints a client wrapper that imports the LAZY module, never the component or the entryUnitpassnot runnot runnot run
wake island — the wrapper is leg-split, the client leg is lazy > the lazy id is an ogygia-owned island path (resolved + shimmed like the other glue)Unitpassnot runnot runnot run
wake island — the wrapper is leg-split, the client leg is lazy > the lazy module reads the ONE csr fact + the rendered stamp, top-level-awaits the entry, and exports an on-demand loadUnitpassnot runnot runnot run
packages/compiler/test/lazy-files.test.ts
lazy_files > hands a loader that reads part of its module its own chunk, and leaves the rest outUnitpassnot runnot runnot run
lazy_files > hands a loader that reads part of its module its own chunk, and leaves the rest out (minified)Unitpassnot runnot runnot run
lazy_files > hands a module that shares a chunk with others no file (its chunk is not its own)Unitpassnot runnot runnot run
lazy_files > hands each loader its own chunk, relative to the loader's moduleUnitpassnot runnot runnot run
lazy_files > hands each loader its own chunk, relative to the loader's module (minified)Unitpassnot runnot runnot run
lazy_files on the dev server > a call that already names its file (three arguments) is left as writtenUnitpassnot runnot runnot run
lazy_files on the dev server > a package loader is handed its file's dev URL; a virtual module has noneUnitpassnot runnot runnot run
packages/compiler/test/live-partial.test.ts
region() — awaitable dual partial > a binding without __renderHtml (mis-wired) is not awaitableUnitpassnot runnot runnot run
region() — awaitable dual partial > awaiting a dual renders its HTML and resolves to a non-thenable dualUnitpassnot runnot runnot run
region() — awaitable dual partial > un-awaited dual carries no html and is not enumerable-thenableUnitpassnot runnot runnot run
transform — SSR binding renders HTML, client leg stays metadata-only > SSR leg renders through the one shared helper and exposes __renderHtmlUnitpassnot runnot runnot run
transport — HTML rides the wire > a re-serialized deferred partial passes its html throughUnitpassnot runnot runnot run
transport — HTML rides the wire > an un-awaited dual encodes WITHOUT html (renders inline where it lands)Unitpassnot runnot runnot run
transport — HTML rides the wire > encode bakes html + signs url; decode rebuilds a deferred partial with htmlUnitpassnot runnot runnot run
packages/compiler/test/macros-need-plugin.test.ts
a plugin macro without its plugin > a marker in a string or comment is no call; an unknown macro is not this errorUnitpassnot runnot runnot run
a plugin macro without its plugin > bake() without @ogygia/bake fails the build, and its function never runsUnitpassnot runnot runnot run
a plugin macro without its plugin > fails the build naming the package and the pluginUnitpassnot runnot runnot run
a plugin macro without its plugin > with the plugin listed, its handler compiles the callUnitpassnot runnot runnot run
packages/compiler/test/macros-own-source.test.ts
module macros: the app’s own source only > a bake() in an installed file fails the build with a code, and its function never runsUnitpassnot runnot runnot run
module macros: the app’s own source only > a file a package declares in ogygia.files, and the app’s own, are rewrittenUnitpassnot runnot runnot run
module macros: the app’s own source only > a marker named only in a string or a comment of an installed file is left aloneUnitpassnot runnot runnot run
module macros: the app’s own source only > a plugin macro in an installed file fails the build, and its handler never runsUnitpassnot runnot runnot run
module macros: the app’s own source only > a store-shaped export is auto-branded in app source only, never in an installed file or ogygiaUnitpassnot runnot runnot run
module macros: the app’s own source only > the $ macro in an installed file fails the same wayUnitpassnot runnot runnot run
module macros: the app’s own source only > the source macro in an installed file fails the same wayUnitpassnot runnot runnot run
module macros: the app’s own source only > the store macro in an installed file fails the same wayUnitpassnot runnot runnot run
module macros: the app’s own source only > the wire macro in an installed file fails the same wayUnitpassnot runnot runnot run
packages/compiler/test/macros-pipeline.test.ts
a macro its plugin brings > a profiled build counts each run of oneUnitpassnot runnot runnot run
a macro its plugin brings > one whose plugin is not listed fails the build, naming the package to listUnitpassnot runnot runnot run
the core passes > a module with no marker is untouchedUnitpassnot runnot runnot run
the core passes > a store factory is branded in the app's source onlyUnitpassnot runnot runnot run
the core passes > og.source in an installed file fails the buildUnitpassnot runnot runnot run
the core passes > og.source is rewritten in the app, stamped by its root-relative fileUnitpassnot runnot runnot run
the core passes > og.store in an installed file fails the buildUnitpassnot runnot runnot run
the core passes > og.store is rewritten in the appUnitpassnot runnot runnot run
the core passes > one module through every pass: each feeds the nextUnitpassnot runnot runnot run
the plugins' macros > a macro that rewrites nothing leaves the module untouchedUnitpassnot runnot runnot run
the plugins' macros > each runs only when its marker is present, in plugin order, on what the last one madeUnitpassnot runnot runnot run
the plugins' macros > one that would rewrite an installed file fails the build, by its nameUnitpassnot runnot runnot run
packages/compiler/test/markup-host-binding.test.ts
a markup route host links the client binding stub > csr=false markdown page, client leg of a build → the stubUnitpassnot runnot runnot run
a markup route host links the client binding stub > the server leg, a csr=true page and dev keep the real bindingUnitpassnot runnot runnot run
packages/compiler/test/messages.test.ts
a server bundle: worded in dev and while prerendering > a production server prints the link alone; a prerender, the wording and the linkUnitpassnot runnot runnot run
a tombstone (a code that only points at a removed spelling) names the release that deletes it > the 0.14 tombstones go in 0.15Unitpassnot runnot runnot run
a tombstone (a code that only points at a removed spelling) names the release that deletes it > the build breaks once the version reaches a tombstone’s release, so it is deleted thenUnitpassnot runnot runnot run
OgygiaError and warn > an empty or missing argument stays out of the link; a long one is cut to 300 charactersUnitpassnot runnot runnot run
OgygiaError and warn > dev: the wording, then the link with the argumentsUnitpassnot runnot runnot run
OgygiaError and warn > warn: the arguments are the plain object after the code; what follows rides alongUnitpassnot runnot runnot run
OgygiaError and warn > without the table (a production build): the link aloneUnitpassnot runnot runnot run
prose > joins a paragraph into one line, a blank line starts the next, an empty one is droppedUnitpassnot runnot runnot run
prose > keeps the space before a value, and the value as it isUnitpassnot runnot runnot run
the tables > a build report prints through line(), never warn()Unitpassnot runnot runnot run
the tables > a code is in one table only (one namespace across the runtime, server and build)Unitpassnot runnot runnot run
the tables > each code's page reads as plain sentences: no { } or < outside backticks (the docs render it)Unitpassnot runnot runnot run
the tables > every message the source prints comes from a tableUnitpassnot runnot runnot run
the tables > no code is both an error and a warningUnitpassnot runnot runnot run
packages/compiler/test/morph-feature-defer.test.ts
morph feature — deferred holes > a deferred hole selects morph (so #apply can keep a live fallback)Unitpassnot runnot runnot run
morph feature — deferred holes > a plain load-hydrated app (no defer, no live/morph/router) still ships neitherUnitpassnot runnot runnot run
morph feature — deferred holes > morph and frames travel together for a deferred hole (same streamed HTML)Unitpassnot runnot runnot run
morph feature — deferred holes > the existing legs are unchanged: live / morph / router each still select morphUnitpassnot runnot runnot run
the features a region streaming HTML needs > a page of lakes streams HTML: it ships the frame storeUnitpassnot runnot runnot run
the features a region streaming HTML needs > the wire-class loader ships only with a transportable classUnitpassnot runnot runnot run
packages/compiler/test/named-region-imports.fuzz.test.ts
generated region-import shapes match the model > every generated caseUnitpassnot runnot runnot run
TypeScript organizeImports never changes the regions a file has > generated files: same regions and the same code lines before and afterUnitpassnot runnot runnot run
TypeScript organizeImports never changes the regions a file has > organizeImports keeps a marked import apart from a plain one (TS 6.0.3)Unitpassnot runnot runnot run
packages/compiler/test/named-region-imports.test.ts
a marked binding used as anything but a component > .svelte: {@html} → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: {@render} → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: a spread attribute → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: a store → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: a tagged template → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: a template string → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: a transition → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: an action → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: an attachment → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: an event handler → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: an event handler on svelte:element → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: an event handler on svelte:window → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: await → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: called → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: constructed → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: each → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: read as a member (computed) → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: read as a member → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: read as a member in markup → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: spread → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: spread into an array → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: text → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .svelte: typeof (a value) → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: a string-named import reads its export by that nameUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: a template string → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: called → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: constructed → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: read as a member → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: spread → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: the message names the line and column of the misuseUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: typeof (a value) → region_binding_not_componentUnitpassnot runnot runnot run
a marked binding used as anything but a component > .ts: values, exports, region() and type positions stay legalUnitpassnot runnot runnot run
a marked binding used as anything but a component > a merged import: the helper that rode along is named, with its own lineUnitpassnot runnot runnot run
a marked binding used as anything but a component > the default form is held to the same ruleUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > `void X` (kept referenced, never placed) and `!X` are not misusesUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > a binding the file never uses is dropped; the used one is still a regionUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > a component prop whose name starts with "on" is a prop, not an event handlerUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > a default and a named binding in one declaration are both regionsUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > a marked binding handed on as a value stays legal (region(), a prop, this=)Unitpassnot runnot runnot run
a marked named import in a .svelte host is a region > a marked binding typed with `typeof` in a type position is legalUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > a named default (`{ default as X }`) is the default exportUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > a preset resolves on a named importUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > a shadowing local of the same name is never read as a misuseUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > an alias binds the local name; identity still keys on the export nameUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > every mode works on a named import: { region: 'raw' }Unitpassnot runnot runnot run
a marked named import in a .svelte host is a region > every mode works on a named import: { render: 'deferred', fetch: 'load' }Unitpassnot runnot runnot run
a marked named import in a .svelte host is a region > every mode works on a named import: { wake: 'none' }Unitpassnot runnot runnot run
a marked named import in a .svelte host is a region > one `with` covers every binding in the declaration: two exports, two regionsUnitpassnot runnot runnot run
a marked named import in a .svelte host is a region > the entry imports the named export; identity keys on spec#Export; <H/> staysUnitpassnot runnot runnot run
a marked named import in a .ts module is a region > a .ts file that re-exports a marked named binding exports the regionUnitpassnot runnot runnot run
a marked named import in a .ts module is a region > aliases and several bindings: one binding import eachUnitpassnot runnot runnot run
a marked named import in a .ts module is a region > render: deferred on a named import is a holeUnitpassnot runnot runnot run
a marked named import in a .ts module is a region > the binding imports the named export; identity keys on spec#ExportUnitpassnot runnot runnot run
import.meta.og.asRegion is a build error that prints the replacement > a default import keeps the default form; same-name skips the aliasUnitpassnot runnot runnot run
import.meta.og.asRegion is a build error that prints the replacement > anywhere: nested, in markup, in a csr=true host, in <script module>Unitpassnot runnot runnot run
import.meta.og.asRegion is a build error that prints the replacement > in a .svelte host: a named import with the same options, aliased to the constUnitpassnot runnot runnot run
import.meta.og.asRegion is a build error that prints the replacement > in a .ts moduleUnitpassnot runnot runnot run
option errors on a named import are the default form’s errors > .svelte: with { region: 'cooked' }Unitpassnot runnot runnot run
option errors on a named import are the default form’s errors > .svelte: with { render: 'sometimes' }Unitpassnot runnot runnot run
option errors on a named import are the default form’s errors > .svelte: with { wake: 'load', margin: '10px' }Unitpassnot runnot runnot run
option errors on a named import are the default form’s errors > .svelte: with { wake: 'whenever' }Unitpassnot runnot runnot run
option errors on a named import are the default form’s errors > .ts: with { region: 'cooked' }Unitpassnot runnot runnot run
option errors on a named import are the default form’s errors > .ts: with { render: 'sometimes' }Unitpassnot runnot runnot run
option errors on a named import are the default form’s errors > .ts: with { wake: 'load', margin: '10px' }Unitpassnot runnot runnot run
option errors on a named import are the default form’s errors > .ts: with { wake: 'whenever' }Unitpassnot runnot runnot run
shapes a region mark cannot carry > .svelte: import '@acme/ui' with { wake: 'load' }; → region_import_bareUnitpassnot runnot runnot run
shapes a region mark cannot carry > .svelte: import { type Card, Badge } from '@acme/ui' with { wake: 'load' }; → region_import_type_onlyUnitpassnot runnot runnot run
shapes a region mark cannot carry > .svelte: import {} from '@acme/ui' with { wake: 'load' }; → region_import_bareUnitpassnot runnot runnot run
shapes a region mark cannot carry > .svelte: import * as UI from '@acme/ui' with { wake: 'load' }; → region_import_namespaceUnitpassnot runnot runnot run
shapes a region mark cannot carry > .svelte: import Card, * as UI from './Card.svelte' with { wake: 'load' }; → region_import_namespaceUnitpassnot runnot runnot run
shapes a region mark cannot carry > .svelte: import type { Card } from '@acme/ui' with { wake: 'load' }; → region_import_type_onlyUnitpassnot runnot runnot run
shapes a region mark cannot carry > .ts: import '@acme/ui' with { wake: 'load' }; → region_import_bareUnitpassnot runnot runnot run
shapes a region mark cannot carry > .ts: import { type Card, Badge } from '@acme/ui' with { wake: 'load' }; → region_import_type_onlyUnitpassnot runnot runnot run
shapes a region mark cannot carry > .ts: import {} from '@acme/ui' with { wake: 'load' }; → region_import_bareUnitpassnot runnot runnot run
shapes a region mark cannot carry > .ts: import * as UI from '@acme/ui' with { wake: 'load' }; → region_import_namespaceUnitpassnot runnot runnot run
shapes a region mark cannot carry > .ts: import Card, * as UI from './Card.svelte' with { wake: 'load' }; → region_import_namespaceUnitpassnot runnot runnot run
shapes a region mark cannot carry > .ts: import type { Card } from '@acme/ui' with { wake: 'load' }; → region_import_type_onlyUnitpassnot runnot runnot run
packages/compiler/test/og-constructs-stress.test.ts
.svelte multi-script-block interactions > a <script> tag whose attribute contains a > (generics) extracts correctlyUnitpassnot runnot runnot run
misuse-error QUALITY — build-voice, file:line, explains the fix > 2-arg wire(a,b) → exactly one argumentUnitpassnot runnot runnot run
misuse-error QUALITY — build-voice, file:line, explains the fix > arg-less wire() → codec requiredUnitpassnot runnot runnot run
misuse-error QUALITY — build-voice, file:line, explains the fix > non-static member named wire → build-voiceUnitpassnot runnot runnot run
misuse-error QUALITY — build-voice, file:line, explains the fix > static member with the WRONG name → names the required `wire`Unitpassnot runnot runnot run
misuse-error QUALITY — build-voice, file:line, explains the fix > wire as a bare value → [ogygia] + line + names the legal positionUnitpassnot runnot runnot run
misuse-error QUALITY — build-voice, file:line, explains the fix > wire as an object property → build-voiceUnitpassnot runnot runnot run
misuse-error QUALITY — build-voice, file:line, explains the fix > wire spread into a call → build-voiceUnitpassnot runnot runnot run
packages/compiler/test/og-dollar.test.ts
og.$ as the UNIVERSAL boundary mark (non-function values) > a non-function value rewrites to a boundary assertion at the marked siteUnitpassnot runnot runnot run
og.$ as the UNIVERSAL boundary mark (non-function values) > mixed fn + value marks in one module import both runtimesUnitpassnot runnot runnot run
og.$ captures: what the far side would read > a class expression's own name, read inside it, is no capture (#1634)#1634Unitpassnot runnot runnot run
og.$ captures: what the far side would read > a class method name is no captureUnitpassnot runnot runnot run
og.$ captures: what the far side would read > a class static block's names stay in the block: a read after the class is captured (#1634)#1634Unitpassnot runnot runnot run
og.$ captures: what the far side would read > a global name the module binds (an import) is captured, never read as the globalUnitpassnot runnot runnot run
og.$ captures: what the far side would read > a name a block shadows is still captured where the block does not reachUnitpassnot runnot runnot run
og.$ captures: what the far side would read > an inner function's parameter shadows only inside that functionUnitpassnot runnot runnot run
og.$ captures: what the far side would read > BUILD ERROR: a $() inside another $()Unitpassnot runnot runnot run
og.$ captures: what the far side would read > import.meta is no captureUnitpassnot runnot runnot run
og.$ end-to-end (transform output executed against the real runtime) > the rewritten expression returns a live, correctly-bound functionUnitpassnot runnot runnot run
og.$ fn manifest > is the same whatever order the modules transformed inUnitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > a declare and an overload#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > a definite assignment#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > a local type alias and interface#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > a parameter annotation and a return type#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > a this parameter#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > a type-only namespace#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > a typed markup mark hoists plain JS#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > a typed value mark asserts the plain expression#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > an angle-bracket assertion#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > an instantiation expression#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > an optional parameter#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > as, satisfies and a non-null !#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > class modifiers, abstract members and implements#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > generics on the function and on a call#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > TS with runtime meaning (a namespace with values) fails the build at its line#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > TS with runtime meaning (a parameter property) fails the build at its line#1556Unitpassnot runnot runnot run
og.$ in a typed module hoists plain JS (#1556) > TS with runtime meaning (an enum) fails the build at its line#1556Unitpassnot runnot runnot run
og.$ in TEMPLATE expressions (props in markup) > a markup mark inside another markup mark fails the buildUnitpassnot runnot runnot run
og.$ in TEMPLATE expressions (props in markup) > a markup mark with no <script> to take its import fails the buildUnitpassnot runnot runnot run
og.$ in TEMPLATE expressions (props in markup) > a markup mark with no argument, or one that does not parse, fails the buildUnitpassnot runnot runnot run
og.$ in TEMPLATE expressions (props in markup) > a script mark that opens a call is rewritten once, by the script passUnitpassnot runnot runnot run
og.$ in TEMPLATE expressions (props in markup) > a value prop becomes a boundary assertion; imports merge with script-pass injectionUnitpassnot runnot runnot run
og.$ in TEMPLATE expressions (props in markup) > an inline fn prop hoists with captures from the component scopeUnitpassnot runnot runnot run
og.$ in TEMPLATE expressions (props in markup) > markup that names the marker outside an expression, or a longer member, is left aloneUnitpassnot runnot runnot run
og.$ module shape > a module that does not parse mid-edit is left as writtenUnitpassnot runnot runnot run
og.$ module shape > every platform global a body reads passes through uncapturedUnitpassnot runnot runnot run
og.$ module shape > the injected import keeps every line where it wasUnitpassnot runnot runnot run
og.$ server-only capture rejection > BUILD ERROR: capturing a $env/dynamic/private importUnitpassnot runnot runnot run
og.$ server-only capture rejection > BUILD ERROR: capturing a $env/static/private importUnitpassnot runnot runnot run
og.$ server-only capture rejection > BUILD ERROR: capturing from a .server module or $app/serverUnitpassnot runnot runnot run
og.$ server-only capture rejection > public env and normal imports still capture fineUnitpassnot runnot runnot run
og.$ transform > a capture-free fn hoists with empty paramsUnitpassnot runnot runnot run
og.$ transform > a non-function argument is a BOUNDARY ASSERTION, not an error (universal mark)Unitpassnot runnot runnot run
og.$ transform > BUILD ERROR: bare access / aliasingUnitpassnot runnot runnot run
og.$ transform > BUILD ERROR: zero or two argumentsUnitpassnot runnot runnot run
og.$ transform > captures: locals bind; params/inner declarations/globals do notUnitpassnot runnot runnot run
og.$ transform > marker inside a string is never rewrittenUnitpassnot runnot runnot run
og.$ transform > member properties and object keys are not capturesUnitpassnot runnot runnot run
og.$ transform > multiple marks in one module get sequential tagsUnitpassnot runnot runnot run
og.$ transform > no marker → same reference back, zero hoistsUnitpassnot runnot runnot run
og.$ transform > rewrites the mark to __og_$(tag, [captures], factory) and injects the importUnitpassnot runnot runnot run
og.$ transform > works inside a .svelte script blockUnitpassnot runnot runnot run
packages/compiler/test/og-store.test.ts
__og_store runtime (the corpus C9 round-trip) > a branded factory store crosses the wire with its methods REBUILTUnitpassnot runnot runnot run
__og_store runtime (the corpus C9 round-trip) > a revived store is itself branded — it can cross a further boundaryUnitpassnot runnot runnot run
__og_store runtime (the corpus C9 round-trip) > registration happens at __og_store call time — decode works without ever calling the wrapped factoryUnitpassnot runnot runnot run
auto-brand tier (zero-authoring provable factories) > a block body with no return is no proofUnitpassnot runnot runnot run
auto-brand tier (zero-authoring provable factories) > auto-branded factory round-trips through the store kind with methodsUnitpassnot runnot runnot run
auto-brand tier (zero-authoring provable factories) > brands: block body where EVERY return is provableUnitpassnot runnot runnot run
auto-brand tier (zero-authoring provable factories) > brands: direct writable() with the svelte/store import; injects the runtime importUnitpassnot runnot runnot run
auto-brand tier (zero-authoring provable factories) > brands: expression body returning an object literal with subscribeUnitpassnot runnot runnot run
auto-brand tier (zero-authoring provable factories) > nested functions returns do not count as the factory returnUnitpassnot runnot runnot run
auto-brand tier (zero-authoring provable factories) > only svelte/store’s writable is proof, under any local nameUnitpassnot runnot runnot run
auto-brand tier (zero-authoring provable factories) > SKIPS the ambiguous: call-result returns, mixed returns, local writable, non-exportUnitpassnot runnot runnot run
og_derived — a derived that RESUMES across the boundary > a PLAIN derived still freezes (the contrast the classifier warns about)Unitpassnot runnot runnot run
og_derived — a derived that RESUMES across the boundary > crosses ALIVE: bump the reunified source, every island's derived followsUnitpassnot runnot runnot run
og_derived — a derived that RESUMES across the boundary > multi-source recipe resumes tooUnitpassnot runnot runnot run
og.store transform > a module that does not parse mid-edit is left as writtenUnitpassnot runnot runnot run
og.store transform > a returned name is never judged, only a literal non-storeUnitpassnot runnot runnot run
og.store transform > accepts an identifier argument; sequential tags per moduleUnitpassnot runnot runnot run
og.store transform > BUILD ERRORS: arg count, non-function arg, bare accessUnitpassnot runnot runnot run
og.store transform > quiet when returns are dynamic or store-shaped; nested fn returns are theirsUnitpassnot runnot runnot run
og.store transform > rewrites the mark to __og_store(tag, factory) and injects the importUnitpassnot runnot runnot run
og.store transform > WARNS (not errors) on a provably non-store return; the wrap still happensUnitpassnot runnot runnot run
og.store transform > works in a .svelte script block; no marker → same referenceUnitpassnot runnot runnot run
robustness floor (SSR-guard factories, frozen stores) > a frozen store cannot carry the brand — warns with the tag, still crosses genericUnitpassnot runnot runnot run
robustness floor (SSR-guard factories, frozen stores) > decode floor: a factory that returns nothing on this side degrades to writable(seed)Unitpassnot runnot runnot run
robustness floor (SSR-guard factories, frozen stores) > mark_store passes non-objects through untouched — no defineProperty detonationUnitpassnot runnot runnot run
robustness floor (SSR-guard factories, frozen stores) > wrapped SSR-guard factory: undefined product passes through, ONE warning per tagUnitpassnot runnot runnot run
packages/compiler/test/og-transform-stress.test.ts
og_js_regions — script extraction torture > a `</script>` sequence inside a JS string does not end the block earlyUnitpassnot runnot runnot run
og_js_regions — script extraction torture > a script tag with a `>` inside an attribute valueUnitpassnot runnot runnot run
og_js_regions — script extraction torture > no script blocks at all → empty region list (not null)Unitpassnot runnot runnot run
og_js_regions — script extraction torture > offsets map back correctly for a construct deep in the second blockUnitpassnot runnot runnot run
og_js_regions — script extraction torture > uppercase <SCRIPT> is still found (case-insensitive)Unitpassnot runnot runnot run
robustness — never throws a low-level error, only build-voice or clean output > junk #0 either rewrites cleanly or throws a build-voice error (never a raw crash)Unitpassnot runnot runnot run
robustness — never throws a low-level error, only build-voice or clean output > junk #1 either rewrites cleanly or throws a build-voice error (never a raw crash)Unitpassnot runnot runnot run
robustness — never throws a low-level error, only build-voice or clean output > junk #2 either rewrites cleanly or throws a build-voice error (never a raw crash)Unitpassnot runnot runnot run
robustness — never throws a low-level error, only build-voice or clean output > junk #3 either rewrites cleanly or throws a build-voice error (never a raw crash)Unitpassnot runnot runnot run
robustness — never throws a low-level error, only build-voice or clean output > junk #4 either rewrites cleanly or throws a build-voice error (never a raw crash)Unitpassnot runnot runnot run
robustness — never throws a low-level error, only build-voice or clean output > junk #5 either rewrites cleanly or throws a build-voice error (never a raw crash)Unitpassnot runnot runnot run
robustness — never throws a low-level error, only build-voice or clean output > junk #6 either rewrites cleanly or throws a build-voice error (never a raw crash)Unitpassnot runnot runnot run
scanner fallback — when the AST bails on an unparseable tail > wire: a half-typed member (no closing paren) neither throws nor editsUnitpassnot runnot runnot run
scanner fallback — when the AST bails on an unparseable tail > wire: a marker at a template-literal boundary is not rewritten by the fallbackUnitpassnot runnot runnot run
scanner fallback — when the AST bails on an unparseable tail > wire: a marker inside a REGEX literal is not rewritten by the fallbackUnitpassnot runnot runnot run
scanner fallback — when the AST bails on an unparseable tail > wire: still rewrites the valid member, comment/string markers untouchedUnitpassnot runnot runnot run
wire — byte-offset integrity (multi-byte unicode / CRLF / BOM before the construct) > a leading BOM does not shift offsetsUnitpassnot runnot runnot run
wire — byte-offset integrity (multi-byte unicode / CRLF / BOM before the construct) > astral-plane chars (𝕏, 👨‍👩‍👧) before and inside the codec stay intactUnitpassnot runnot runnot run
wire — byte-offset integrity (multi-byte unicode / CRLF / BOM before the construct) > CRLF line endings before the constructUnitpassnot runnot runnot run
wire — byte-offset integrity (multi-byte unicode / CRLF / BOM before the construct) > multi-byte emoji BEFORE the construct does not shift the spliceUnitpassnot runnot runnot run
wire — demented shapes that must FAIL LOUDLY > a NON-static member named wireUnitpassnot runnot runnot run
wire — demented shapes that must FAIL LOUDLY > assigned to an object propertyUnitpassnot runnot runnot run
wire — demented shapes that must FAIL LOUDLY > spread into a callUnitpassnot runnot runnot run
wire — demented shapes that must FAIL LOUDLY > two argumentsUnitpassnot runnot runnot run
wire — demented shapes that must FAIL LOUDLY > two wire members in ONE class (only one codec per class is coherent) — still rewrites both, stays balancedUnitpassnot runnot runnot run
wire — demented shapes that must FAIL LOUDLY > used as a computed KEY directly (the impossible TS form) is caught as misuseUnitpassnot runnot runnot run
wire — demented shapes that must still WORK > a .svelte with TWO script blocks — only the one with the class rewritesUnitpassnot runnot runnot run
wire — demented shapes that must still WORK > a comment sitting between `static` and `wire`Unitpassnot runnot runnot run
wire — demented shapes that must still WORK > a nested class INSIDE the codec that has its OWN wire memberUnitpassnot runnot runnot run
wire — demented shapes that must still WORK > a template literal with `${}` interpolation inside the codecUnitpassnot runnot runnot run
wire — demented shapes that must still WORK > minified: everything on one line, no spacesUnitpassnot runnot runnot run
wire — demented shapes that must still WORK > no trailing semicolon (ASI)Unitpassnot runnot runnot run
wire — demented shapes that must still WORK > the codec spans many lines with nested braces and a trailing commaUnitpassnot runnot runnot run
wire — demented shapes that must still WORK > two transportable classes in one moduleUnitpassnot runnot runnot run
wire — demented shapes that must still WORK > unicode / non-ASCII inside the codec stringsUnitpassnot runnot runnot run
wire — inputs that must be LEFT ALONE > a look-alike longer identifier (import.meta.og.wireTap) is not the markerUnitpassnot runnot runnot run
wire — inputs that must be LEFT ALONE > a non-construct-host extension (.css) is never touchedUnitpassnot runnot runnot run
wire — inputs that must be LEFT ALONE > markdown PROSE mentioning the marker (a .svelte with no script) stays literalUnitpassnot runnot runnot run
wire — inputs that must be LEFT ALONE > marker only ever in a comment → unchanged referenceUnitpassnot runnot runnot run
wire — inputs that must be LEFT ALONE > marker only ever in a string → unchanged referenceUnitpassnot runnot runnot run
packages/compiler/test/og-wire.test.ts
a default-exported wire class is registered under `#default` (#1169) > a default export of something else is not taken for a class#1169Unitpassnot runnot runnot run
a default-exported wire class is registered under `#default` (#1169) > a plain default-exported class is not registered#1169Unitpassnot runnot runnot run
a default-exported wire class is registered under `#default` (#1169) > an anonymous default class with no wire codec is left alone#1169Unitpassnot runnot runnot run
a default-exported wire class is registered under `#default` (#1169) > an anonymous default wire class is a build error that asks for a name#1169Unitpassnot runnot runnot run
a default-exported wire class is registered under `#default` (#1169) > class Cart; export default Cart#1169Unitpassnot runnot runnot run
a default-exported wire class is registered under `#default` (#1169) > export default class Cart#1169Unitpassnot runnot runnot run
a default-exported wire class is registered under `#default` (#1169) > export default class Cart, raw spelling#1169Unitpassnot runnot runnot run
appendTransportRegistrations — inject ONLY for wire classes > a PLAIN exported class is NOT registered (no ogygia import dragged in)Unitpassnot runnot runnot run
appendTransportRegistrations — inject ONLY for wire classes > a wire class (pre-rewrite blessed spelling) IS registered tooUnitpassnot runnot runnot run
appendTransportRegistrations — inject ONLY for wire classes > a wire class (rewritten computed-symbol form) IS registeredUnitpassnot runnot runnot run
appendTransportRegistrations — inject ONLY for wire classes > mixed module: only the wire class is registered, the plain one is skippedUnitpassnot runnot runnot run
prescan detection — raw source (pre-rewrite) > a class with the blessed spelling is detected as transportableUnitpassnot runnot runnot run
prescan detection — raw source (pre-rewrite) > a REWRITTEN computed member is still detectedUnitpassnot runnot runnot run
rewrite_wire — strictness (build errors, file:line) > rejects a bare value useUnitpassnot runnot runnot run
rewrite_wire — strictness (build errors, file:line) > rejects a call outside a static class memberUnitpassnot runnot runnot run
rewrite_wire — strictness (build errors, file:line) > rejects a computed member, even one keyed by a name `wire`Unitpassnot runnot runnot run
rewrite_wire — strictness (build errors, file:line) > rejects a wrongly-named static memberUnitpassnot runnot runnot run
rewrite_wire — strictness (build errors, file:line) > rejects an arg-less call (codec required)Unitpassnot runnot runnot run
rewrite_wire — strictness (build errors, file:line) > reports the correct line for a deep misuseUnitpassnot runnot runnot run
rewrite_wire — the strict compile construct > a codec containing parens/strings/regex survives verbatimUnitpassnot runnot runnot run
rewrite_wire — the strict compile construct > AST path: a marker in a comment or string is NOT rewritten (and not judged as misuse)Unitpassnot runnot runnot run
rewrite_wire — the strict compile construct > consumes the member and mints the symbol keyUnitpassnot runnot runnot run
rewrite_wire — the strict compile construct > returns the same reference when there is nothing to doUnitpassnot runnot runnot run
rewrite_wire — the strict compile construct > rewrites inside a .svelte <script module> block only — markup prose is untouchedUnitpassnot runnot runnot run
rewrite_wire — the strict compile construct > scanner fallback (unparseable source) still rewrites the legal memberUnitpassnot runnot runnot run
rewrite_wire — the strict compile construct > scanner fallback leaves a wire call that is not a static wire member as writtenUnitpassnot runnot runnot run
runtime — explicit codec round-trip > one instance mints one wire id (identity memo)Unitpassnot runnot runnot run
runtime — explicit codec round-trip > round-trips through encode/decode and rebuilds a REAL instanceUnitpassnot runnot runnot run
packages/compiler/test/one-kit-copy.test.ts
one Kit > the plugin dedupes @sveltejs/kit, in dev and in a buildUnitpassnot runnot runnot run
packages/compiler/test/own-package-ids.test.ts
dep-scan entries > an app island is, posix and glob-escapedUnitpassnot runnot runnot run
dep-scan entries > ogygia's own islands are never an entry — on either separatorUnitpassnot runnot runnot run
own-package ids > a Windows root is the forward-slash prefix of the ids inside itUnitpassnot runnot runnot run
own-package ids > one trailing slash, with or without one given; a sibling package is not insideUnitpassnot runnot runnot run
own-package ids > the package root and its precomputed module ids are posix, slash-terminatedUnitpassnot runnot runnot run
packages/compiler/test/own-package.test.ts
own package identity > counts an installed @ogygia/core as ogygia's runtime in a chunk summaryUnitpassnot runnot runnot run
own package identity > knows its files: the ogygia package, @ogygia/core, a checkout of either, either separatorUnitpassnot runnot runnot run
own package identity > names both packages, and their subpathsUnitpassnot runnot runnot run
own package identity > reads a context provider and a held region imported under either nameUnitpassnot runnot runnot run
packages/compiler/test/own-reach.test.ts
a context provider is found in every form that reaches it > a dynamic import destructures setContextUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a dynamic import in a componentUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a dynamic import is kept wholeUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a dynamic import reads createContext off the moduleUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a local barrel re-exports Provide under another nameUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a local barrel re-exports setContextUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a local barrel star-exports ogygiaUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a local barrel star-exports ogygia as a namespaceUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a namespace import is handed onUnitpassnot runnot runnot run
a context provider is found in every form that reaches it > a namespace names Provide in markupUnitpassnot runnot runnot run
a form that reaches no provider ships no bridge > a barrel re-exports only getContextUnitpassnot runnot runnot run
a form that reaches no provider ships no bridge > a dynamic import destructures only getContextUnitpassnot runnot runnot run
a form that reaches no provider ships no bridge > a namespace import reads only getContextUnitpassnot runnot runnot run
a form that reaches no provider ships no bridge > the word aloneUnitpassnot runnot runnot run
a form the walk cannot narrow reaches every export > a default import of ogygia reaches every exportUnitpassnot runnot runnot run
a form the walk cannot narrow reaches every export > a file that names ogygia but will not parse reaches every exportUnitpassnot runnot runnot run
a form the walk cannot narrow reaches every export > a namespace handed on reaches every exportUnitpassnot runnot runnot run
a form the walk cannot narrow reaches every export > a property named like the namespace is not a read of itUnitpassnot runnot runnot run
a region or content value on Kit's wire is found in every form > a barrel of non-wire ogygia names does not crossUnitpassnot runnot runnot run
a region or content value on Kit's wire is found in every form > a barrel re-exports the content packageUnitpassnot runnot runnot run
a region or content value on Kit's wire is found in every form > a dynamic import of the content packageUnitpassnot runnot runnot run
a region or content value on Kit's wire is found in every form > a dynamic import reads siteUnitpassnot runnot runnot run
a region or content value on Kit's wire is found in every form > a local barrel re-exports regionUnitpassnot runnot runnot run
a region or content value on Kit's wire is found in every form > a local barrel star-exports ogygiaUnitpassnot runnot runnot run
a region or content value on Kit's wire is found in every form > a namespace import is handed onUnitpassnot runnot runnot run
packages/compiler/test/own-source-registrations.test.ts
an app wire class gets its registration; the same class in ogygia's own source does notUnitpassnot runnot runnot run
packages/compiler/test/ownership-stamps.test.ts
stamp_opaque > a custom element whose children Svelte walks is NOT stampedUnitpassnot runnot runnot run
stamp_opaque > a custom element with only static children is stamped; its own dynamic attributes are fineUnitpassnot runnot runnot run
stamp_opaque > a style Svelte cannot parse does not stop the stampsUnitpassnot runnot runnot run
stamp_opaque > an {@html} beside other content: the parent stays walked, stamped data-og-html for its child elementsUnitpassnot runnot runnot run
stamp_opaque > an each block's fallback is searched tooUnitpassnot runnot runnot run
stamp_opaque > an element whose only child is {@html} (whitespace aside) is stampedUnitpassnot runnot runnot run
stamp_opaque > bind:innerHTML / textContent / innerText are stampedUnitpassnot runnot runnot run
stamp_opaque > nested inside blocks and components’ children; outermost wins; never stamped twiceUnitpassnot runnot runnot run
stamp_opaque > nothing to stamp, or unparsable → nullUnitpassnot runnot runnot run
packages/compiler/test/oxc-parse.test.ts
parse_module > a module that imports the parser without parsing never loads viteUnitpassnot runnot runnot run
parse_module > a source the parser refuses outright (a read that came back null) is a failed parse, never a throwUnitpassnot runnot runnot run
parse_module > is null, never a throw, on a syntax errorUnitpassnot runnot runnot run
parse_module > reads TypeScript, with every span exact against the sourceUnitpassnot runnot runnot run
packages/compiler/test/package-files-edges.test.ts
discover_package_files over a partial install > a dangling symlink a glob matches is no file to listUnitpassnot runnot runnot run
discover_package_files over a partial install > a dependency not installed and one whose manifest does not parse declare nothingUnitpassnot runnot runnot run
discover_package_files over a partial install > a file a glob listed and that is gone before it is read is no file to listUnitpassnot runnot runnot run
packages/compiler/test/package-files-realpath.test.ts
ogygia.files: the package boundary > a glob through a symlink leading out of the package lists no outside fileUnitpassnot runnot runnot run
ogygia.files: the package boundary > a symlinked directory leading out of the package is not compile surfaceUnitpassnot runnot runnot run
packages/compiler/test/package-files.test.ts
CompileCtx gates > a sibling package whose root is a STRING prefix does not leak into matchesUnitpassnot runnot runnot run
CompileCtx gates > in_declared_pkg: declared file + files under declared dirs; nothing elseUnitpassnot runnot runnot run
CompileCtx gates > pkg_identity: install-independent `<name>/<rel>` under the declared rootUnitpassnot runnot runnot run
discover_package_files > finds ONLY declared packages, expands dirs/globs/files, skips missing entriesUnitpassnot runnot runnot run
discover_package_files > rejects a declaration that escapes the packageUnitpassnot runnot runnot run
discover_package_files > rejects a malformed declaration loudlyUnitpassnot runnot runnot run
discover_package_files: what counts as a declaration > every glob form expands: braces and classes as well as starsUnitpassnot runnot runnot run
discover_package_files: what counts as a declaration > ogygia's own packages are never read through the fieldUnitpassnot runnot runnot run
undeclared-marks warning > a dependency .ts with marks but NO declaration warns loudly (was silent death)Unitpassnot runnot runnot run
undeclared-marks warning > a dependency that only MENTIONS a mark (comment, string, error text) does not warnUnitpassnot runnot runnot run
undeclared-marks warning > ogygia's OWN modules are exempt (compiler sources CONTAIN `with { wake` as strings)Unitpassnot runnot runnot run
packages/compiler/test/package-mark-resolve.test.ts
unresolvable marked package specifier > relative imports from a generated module keep the quiet null fall-throughUnitpassnot runnot runnot run
unresolvable marked package specifier > resolveId throws an actionable [ogygia] error for the re-emitted specifierUnitpassnot runnot runnot run
packages/compiler/test/page-data-reads.test.ts
the page-data reads relocation > a chunk without the placeholder is left aloneUnitpassnot runnot runnot run
the page-data reads relocation > a component is found under the graph's id for it, a query or backslashes includedUnitpassnot runnot runnot run
the page-data reads relocation > a reader anywhere in the tree (a dynamic import too) → true; none (a cycle too) → falseUnitpassnot runnot runnot run
the page-data reads relocation > an unpinnable read (`unknown`) counts; a component the graph does not know looks upUnitpassnot runnot runnot run
the page-data reads relocation > unpatched (a build that never reached renderChunk), it is unknown: nullUnitpassnot runnot runnot run
the page-data reads relocation > without a seed-shaping plugin it is unknown: null, so every hole looks upUnitpassnot runnot runnot run
the page-data relocation: a page reader seed shaping could not read > a hole reading $app/stores, or importing $app/state on demand, looks up page.dataUnitpassnot runnot runnot run
the page-data relocation: a page reader seed shaping could not read > a hole reading the page through a $lib re-export looks up page.dataUnitpassnot runnot runnot run
the page-data relocation: a page reader seed shaping could not read > a page reader whose keys were read (none of page.data) does notUnitpassnot runnot runnot run
the page-data relocation: a page reader seed shaping could not read > Kit's page module importing its own halves is not a reader of the pageUnitpassnot runnot runnot run
packages/compiler/test/page-mark.test.ts
foreign regions > a federated app ships what a peer's regions need, with no region of its own needing itUnitpassnot runnot runnot run
foreign regions > an app with no deferred region of its own does not ship the frame storeUnitpassnot runnot runnot run
foreign regions > foreign needs every feature a peer region can need, for every combination of region marksUnitpassnot runnot runnot run
page mark > `$app/navigation` reaches the navigation handleUnitpassnot runnot runnot run
page mark > `$app/state` anywhere in the closure is a readerUnitpassnot runnot runnot run
page mark > `$env` and generated modules read no page, and the walk follows them no furtherUnitpassnot runnot runnot run
page mark > a directory import is followed into its index file, so it is not an unresolved oneUnitpassnot runnot runnot run
page mark > a federated or plugin-woken island is a reader the walk never sawUnitpassnot runnot runnot run
page mark > a module the walk does not read (markdown) fails openUnitpassnot runnot runnot run
page mark > a package the walk cannot follow fails openUnitpassnot runnot runnot run
page mark > an import the walk cannot resolve fails openUnitpassnot runnot runnot run
page mark > an island importing only Svelte, local helpers and assets reads no pageUnitpassnot runnot runnot run
packages/compiler/test/partial-transform.test.ts
an import attribute ogygia does not know, on a component import, fails the build > a bad key beside a good one on one import is named by its code in a .ts module tooUnitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > a bad key beside a good one on one unused import is named by its code: { wake: 'load', partial: 'x' }Unitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > a bad key beside a good one on one used import is named by its code: { partial: 'load', region: 'raw' }Unitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > a bad key beside a good one on one used import is named by its code: { wake: 'load', partial: 'x' }Unitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > a bad key beside a good one on one used import is named by its code: { wake: 'visible', wkae: 'load' }Unitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > a misspelt key, alone on a .svelte import, is named with the keys there areUnitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > an attribute on an import that is not a component is left aloneUnitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > in a .ts module too, and a json import there is left aloneUnitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > the retired `partial:` key is one of them, beside a live region import or aloneUnitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > the standard `type` attribute on a component import is not ogygia’sUnitpassnot runnot runnot run
an import attribute ogygia does not know, on a component import, fails the build > with renamed keys, a default name given up to another tool is left alone, and a typo lists the renamed keysUnitpassnot runnot runnot run
transformHost — held region in .svelte (region: raw) > registers a server descriptor and rewrites the import to the binding moduleUnitpassnot runnot runnot run
transformHost — held region in .svelte (region: raw) > rejects a region value other than 'raw'Unitpassnot runnot runnot run
transformHost — held region in .svelte (region: raw) > rejects region combined with another import attributeUnitpassnot runnot runnot run
transformTsRegions — a marked named import (barrel / named in .ts) > a `{ default as X }` import is the default exportUnitpassnot runnot runnot run
transformTsRegions — a marked named import (barrel / named in .ts) > a NAMED barrel import → a mountable held binding (same record as a .ts wake mark)Unitpassnot runnot runnot run
transformTsRegions — a marked named import (barrel / named in .ts) > region: raw on a named import → a bare held descriptor with the named importUnitpassnot runnot runnot run
transformTsRegions — a marked named import (barrel / named in .ts) > two named exports of one barrel → two distinct islandsUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > a .svelte region:raw and a .ts region:raw of the same component share one idUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > a held-region import inside a JSDoc @example COMMENT is left alone (regression: ogygia src/index.ts)Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > a held-region import that is only TEXT inside a template literal is left aloneUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > a hole with both fetch and wake fails on its wakeUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > a lone fetch is refused (it is a deferred hole’s timing)Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > a real import AFTER a backtick inside a string is still rewritten (AST guard, not backtick count)Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > region: raw registers a no-schedule descriptor and strips the attributeUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > rejects an unknown wake valueUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > render: deferred → a .ts server island; import rewritten to the WRAPPERUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > render: deferred accepts fetch: interaction (an on-demand hole) and rejects noneUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > render: deferred takes `fetch` as its timing (+ margin on visible)Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > render: live is rejected on a .ts import (svelte-only)Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > returns null when no held import is presentUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > wake on a render: deferred import fails the build, naming the fetch to writeUnitpassnot runnot runnot run
transformTsRegions — held region in .ts > wake: '(max-width: 500px)' → a mountable held binding (__hydrate (max-width: 500px))Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > wake: 'idle' → a mountable held binding (__hydrate idle)Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > wake: 'load' → a mountable held binding (__hydrate load)Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > wake: 'visible' → a mountable held binding (__hydrate visible)Unitpassnot runnot runnot run
transformTsRegions — held region in .ts > wake: visible bakes a hydrate margin (from ctx.visibleMargin)Unitpassnot runnot runnot run
transformTsRegions — the module rules > a .ts hole's client wrapper never imports its component or entryUnitpassnot runnot runnot run
transformTsRegions — the module rules > a .ts wake: 'none' is refused: a lake lives in a hostUnitpassnot runnot runnot run
transformTsRegions — the module rules > a declared package keys its .ts regions by package, not by install pathUnitpassnot runnot runnot run
transformTsRegions — the module rules > a module that does not parse is left to the bundler (null)Unitpassnot runnot runnot run
transformTsRegions — the module rules > region beside another key, or render beside a key it does not take, is a mixed marker setUnitpassnot runnot runnot run
transformTsRegions — the module rules > render: 'live' is refused in a .ts module with its own codeUnitpassnot runnot runnot run
packages/compiler/test/plugin-hooks-dev.test.ts
plugin hooks in dev (#251), loaded by ssrLoadModule > two edits of a plugin: only its current run answers and hears; the other plugin hears once#251Unitpassnot runnot runnot run
plugin hooks in dev (#251), loaded by the ssr environment's runner > two edits of a plugin: only its current run answers and hears; the other plugin hears once#251Unitpassnot runnot runnot run
packages/compiler/test/plugin-session.test.ts
the plugin session > a hook before the build is resolved is refused, naming the hook and the stateUnitpassnot runnot runnot run
the plugin session > a plugin shared across environments, resolved again with no config, keeps its buildUnitpassnot runnot runnot run
the plugin session > a second build (config again) gets its own compilerUnitpassnot runnot runnot run
the plugin session > resolving makes the compiler the hooks get; config may run more than once firstUnitpassnot runnot runnot run
the plugin session > the plugin refuses a transform before configResolved with the codeUnitpassnot runnot runnot run
packages/compiler/test/plugins.test.ts
a plugin is a Vite plugin, found beside ogygia() > a plugin that needs another fails the build while the app does not list it, naming the line to addUnitpassnot runnot runnot run
a plugin is a Vite plugin, found beside ogygia() > definePlugin returns a Vite plugin carrying its definitionUnitpassnot runnot runnot run
a plugin is a Vite plugin, found beside ogygia() > finds definitions in the Vite list: nested arrays, promises, other plugins skipped, in orderUnitpassnot runnot runnot run
a plugin is a Vite plugin, found beside ogygia() > listed without ogygia(), it fails the build saying what to addUnitpassnot runnot runnot run
a plugin is a Vite plugin, found beside ogygia() > names the uncalled factoryUnitpassnot runnot runnot run
a plugin is a Vite plugin, found beside ogygia() > ogygia() and its plugins come before sveltekit()Unitpassnot runnot runnot run
a plugin is a Vite plugin, found beside ogygia() > refuses a plugin listed twice, a nameless one, and non-JSON optionsUnitpassnot runnot runnot run
a plugin's warnings > are said once each, and 10,000 distinct ones keep at most 1024 (#438)#438Unitpassnot runnot runnot run
facts > are per request, made on first touch; the first per-visitor reason sticksUnitpassnot runnot runnot run
ogygia:server/server-plugins > imports each server realm statically, with its name and options (server only)Unitpassnot runnot runnot run
ogygia:server/server-plugins > is an empty list on the client and for an app without server realmsUnitpassnot runnot runnot run
realms, named by the plugin > `b.pageModules` collects importer specifiers and absolute files, once eachUnitpassnot runnot runnot run
realms, named by the plugin > `b.routeConfig` collects keys, once each; a key that is not an identifier is refusedUnitpassnot runnot runnot run
realms, named by the plugin > `b.transform` collects stage transforms in plugin order; outside ogygia() the seams fail loudlyUnitpassnot runnot runnot run
realms, named by the plugin > `enforce` orders plugins: pre, the rest, postUnitpassnot runnot runnot run
realms, named by the plugin > a built client realm (`export { client as default }`, as the bundler writes it) has its hooks readUnitpassnot runnot runnot run
realms, named by the plugin > a client realm is read through casts and parentheses; a const that names itself is no answerUnitpassnot runnot runnot run
realms, named by the plugin > a client realm that does not parse, or whose defineClient spreads, cannot be readUnitpassnot runnot runnot run
realms, named by the plugin > a client realm whose plugin object, or its hooks, sit in a named const has its hooks readUnitpassnot runnot runnot run
realms, named by the plugin > a macro or a route config key two plugins both claim is refused, naming the firstUnitpassnot runnot runnot run
realms, named by the plugin > a name that is not a package the app resolves fails loudlyUnitpassnot runnot runnot run
realms, named by the plugin > a plugin may not name a macro core defines (`wire`, `$`, `source`, `store`)Unitpassnot runnot runnot run
realms, named by the plugin > a plugin naming its `server` gets that module wired, options carriedUnitpassnot runnot runnot run
realms, named by the plugin > a realm that is not a file, or not a location, fails loudlyUnitpassnot runnot runnot run
realms, named by the plugin > events: one plugin measuring from boot outranks another asking only from the launcherUnitpassnot runnot runnot run
realms, named by the plugin > macros run in plugin order, a `last` one after every other, whatever its placeUnitpassnot runnot runnot run
realms, named by the plugin > no realm named, none wired: a package export called `./server` means nothingUnitpassnot runnot runnot run
realms, named by the plugin > seed shaping is off without a plugin, one plugin answers it, and a second claim fails loudlyUnitpassnot runnot runnot run
realms, named by the plugin > the runtime hooks a client realm subscribes to are read from its file, and nothing else passesUnitpassnot runnot runnot run
realms, named by the plugin > without ogygia() a plugin reading the region table is told soUnitpassnot runnot runnot run
route config > a programmatic router that claims the path wins; then the Kit page; else undefinedUnitpassnot runnot runnot run
route config > the virtual module is server-only and empty without claimed keysUnitpassnot runnot runnot run
shared hooks — notify / ask > ask: one that throws is skipped when another answers, and thrown when none does (#198)#198Unitpassnot runnot runnot run
shared hooks — notify / ask > nobody implementing: notify does nothing, ask answers undefinedUnitpassnot runnot runnot run
shared hooks — notify / ask > notify runs every implementation; ask takes the first answerUnitpassnot runnot runnot run
startPlugin — a server realm without a server > runs setup, registers shared hooks, and hands out request contextsUnitpassnot runnot runnot run
packages/compiler/test/portable-snippet-block-bound.test.ts
a crossing snippet bound to a block name stays native > a body reading only host values crosses at the rootUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > a body reading only host values crosses inside an awaitUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > a body reading only host values crosses inside an eachUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > a const tagUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > a snippet declared below the rootUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > an await errorUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > an await valueUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > an await value destructuredUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > an each indexUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > an each itemUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > an each item destructuredUnitpassnot runnot runnot run
a crossing snippet bound to a block name stays native > an enclosing snippet's parameterUnitpassnot runnot runnot run
packages/compiler/test/portable-snippet-const-tag.test.ts
portable snippet — a body opening with {@const} > a body without one is written at the template root as beforeUnitpassnot runnot runnot run
portable snippet — a body opening with {@const} > keeps its snippet around the body, and the entry compilesUnitpassnot runnot runnot run
packages/compiler/test/portable-snippet-host-declarations.test.ts
a host value a crossing snippet reads reaches its synth > class a {}Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > const [...a] = arr;Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > const [[a]] = [arr];Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > const [a = 1] = arr;Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > const [a] = arr;Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > const { ...a } = obj;Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > const { a } = obj;Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > const { a = 1 } = obj;Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > const { k: a } = obj;Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > export const a = 1;Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > function a() { return 1; }Unitpassnot runnot runnot run
a host value a crossing snippet reads reaches its synth > let a = 1;Unitpassnot runnot runnot run
packages/compiler/test/portable-snippet-imports.test.ts
portable snippet — captured imports from one statement > hoists the shared import ONCE, not once per captured nameUnitpassnot runnot runnot run
packages/compiler/test/portable-snippet-origin.test.ts
portable snippet — a relative marked import inside the snippet resolves against the REAL origin > './' sibling of the host (same directory)Unitpassnot runnot runnot run
portable snippet — a relative marked import inside the snippet resolves against the REAL origin > a snippet NESTED inside a portable snippet inherits the real origin (two re-process hops)Unitpassnot runnot runnot run
portable snippet — a relative marked import inside the snippet resolves against the REAL origin > hydrate-ISLAND site, PARAMETERIZED snippet (any arity crosses there)Unitpassnot runnot runnot run
portable snippet — a relative marked import inside the snippet resolves against the REAL origin > plain site, 0-arg snippet, '../' (the reported build failure)Unitpassnot runnot runnot run
portable snippet — the missing-origin case is LOUD, not a silent phantom path > a generated host "\u0000ogygia:region/entry/x.svelte" has no directory eitherUnitpassnot runnot runnot run
portable snippet — the missing-origin case is LOUD, not a silent phantom path > a generated host "\u0000virtual:other/x.svelte" has no directory eitherUnitpassnot runnot runnot run
portable snippet — the missing-origin case is LOUD, not a silent phantom path > a generated host "virtual:other/x.svelte" has no directory eitherUnitpassnot runnot runnot run
portable snippet — the missing-origin case is LOUD, not a silent phantom path > re-processing under a virtual id with no origin threaded throws a named [ogygia] errorUnitpassnot runnot runnot run
portable snippet — what already worked keeps working, and identity is stable > `$lib/…` and package specifiers inside the snippet are untouched (host-independent)Unitpassnot runnot runnot run
portable snippet — what already worked keeps working, and identity is stable > the portable entry identity does not depend on the machine (no absolute path in the hash input)Unitpassnot runnot runnot run
portable snippet — what already worked keeps working, and identity is stable > the SAME island placed directly and inside the snippet dedupes to ONE id (relative form)Unitpassnot runnot runnot run
packages/compiler/test/portable-snippet-scope.test.ts
portable snippet — every name its body reads reaches the synth > a root snippet that writes host state keeps the body nativeUnitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > a snippet that writes only its own parameter crosses; one that writes host state stays nativeUnitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > captures a host name a legacy `let:` default reads inside the snippet (#1633)#1633Unitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > captures a host name read after a class whose static block declares the same name (#1634)#1634Unitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > captures a legacy `$:` declarationUnitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > captures an exported instance declarationUnitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > carries a template-root snippet (parameterized, using an import and a host value) and those it rendersUnitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > leaves a body reading a destructured legacy `let:` slot prop a plain snippet (no synth)Unitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > leaves a body reading a legacy `let:` slot prop a plain snippet (no synth)Unitpassnot runnot runnot run
portable snippet — every name its body reads reaches the synth > re-imports a <script module> import and captures a <script module> valueUnitpassnot runnot runnot run
packages/compiler/test/portable-snippet-store-subs.test.ts
portable snippet — store auto-subscriptions cross as VALUE snapshots > captures $store reads (props, template literals, member chains) and rewrites the bodyUnitpassnot runnot runnot run
portable snippet — store auto-subscriptions cross as VALUE snapshots > errors loudly when a crossing snippet reads $$propsUnitpassnot runnot runnot run
portable snippet — store auto-subscriptions cross as VALUE snapshots > hoists an unresolvable $name too, and warns that it could not be verifiedUnitpassnot runnot runnot run
portable snippet — store auto-subscriptions cross as VALUE snapshots > leaves plain captures untouched next to store capturesUnitpassnot runnot runnot run
portable snippet — store auto-subscriptions cross as VALUE snapshots > warns when a host-declared store crosses as an OBJECT (it cannot serialize)Unitpassnot runnot runnot run
packages/compiler/test/portable-snippet-style-scope.test.ts
portable snippet — the host <style> travels into the synth (scope threading) > a host with no <style> yields a synth with no <style>, and still compilesUnitpassnot runnot runnot run
portable snippet — the host <style> travels into the synth (scope threading) > copies the host <style> into the synth entryUnitpassnot runnot runnot run
portable snippet — the host <style> travels into the synth (scope threading) > scopes the snippet markup to the rule that styles it (one shared hash)Unitpassnot runnot runnot run
packages/compiler/test/preset-options.test.ts
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge -1 is refusedUnitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge "1500ms" → defer:load:ttl:1Unitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge "1h" → defer:load:ttl:3600Unitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge "30" → defer:load:ttl:30Unitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge "500ms" → defer:loadUnitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge "5m" → defer:load:ttl:300Unitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge "soon" is refusedUnitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge 0 → defer:loadUnitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge 30 → defer:load:ttl:30Unitpassnot runnot runnot run
a deferred preset: maxAge is an HTTP max-age in seconds > maxAge false is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"maxAge":-1} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"maxAge":"5d"} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"maxAge":"soon"} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"maxAge":1500,"onExpire":"fetch"} → lake:swr:when:load:maxAge:1500:onExpire:fetchUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"maxAge":null} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"maxAge":true} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"onExpire":"later"} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"revalidate":"idle"} → lake:swr:when:idleUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"revalidate":"sometimes"} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"revalidate":false,"maxAge":10,"onExpire":"empty"} → lake:cache:maxAge:10:onExpire:emptyUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"revalidate":false,"onExpire":"fetch"} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"revalidate":false} → lake:cacheUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"revalidate":true} is refusedUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {"wake":"visible"} → lake:swr:when:visible:margin:0pxUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > {} → lake:swr:when:loadUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge " 2S " is 2000 msUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge "1.5s" is 1500 msUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge "10" is 10 msUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge "1h" is 3600000 msUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge "30s" is 30000 msUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge "500ms" is 500 msUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge "5m" is 300000 msUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge 0 is 0 msUnitpassnot runnot runnot run
a live preset: remount from revalidate, maxAge (ms) and onExpire > maxAge 1500.9 is 1500 msUnitpassnot runnot runnot run
preset keys > {"margin":"10px"} is refusedUnitpassnot runnot runnot run
preset keys > {"render":"deferred","fetch":"interaction","prefetch":"idle"} → defer:interaction:prefetch:idleUnitpassnot runnot runnot run
preset keys > {"render":"deferred","fetch":"visible","margin":"20px"} → defer:visible:margin:20pxUnitpassnot runnot runnot run
preset keys > {"render":"deferred","stitch":"cdn"} is refusedUnitpassnot runnot runnot run
preset keys > {"render":"deferred","stitch":"edge"} → defer:load:stitch:edgeUnitpassnot runnot runnot run
preset keys > {"render":"deferred","stitch":"serve"} → defer:load:stitch:serveUnitpassnot runnot runnot run
preset keys > {"render":"deferred","stitch":false} is refusedUnitpassnot runnot runnot run
preset keys > {"render":"deferred","stitch":true} → defer:load:stitch:serveUnitpassnot runnot runnot run
preset keys > {"wake":"load","color":"red"} is refusedUnitpassnot runnot runnot run
preset keys > {"wake":"load","keep":"player"} → hydrate:load:keep:playerUnitpassnot runnot runnot run
preset keys > {"wake":"load","margin":null} → hydrate:loadUnitpassnot runnot runnot run
preset keys > {"wake":"load","stitch":"serve"} is refusedUnitpassnot runnot runnot run
preset keys > {"wake":"visible","margin":"30px"} → hydrate:visible:margin:30pxUnitpassnot runnot runnot run
preset keys > an unknown preset names the ones there are, or says there are noneUnitpassnot runnot runnot run
packages/compiler/test/program.test.ts
a fresh program ships only what its options ask for > no wire decoder, no remote seeding, no live runtimeUnitpassnot runnot runnot run
a fresh program ships only what its options ask for > the router ships whenever the option is on, with no `<Router/>` seenUnitpassnot runnot runnot run
a registration turns on what its regions need > a defer region marks its fetch timing; a hydrate region its wake strategyUnitpassnot runnot runnot run
a registration turns on what its regions need > a file that crosses live content into a region ships the wire decoderUnitpassnot runnot runnot run
a registration turns on what its regions need > a held region ships live and client morph; a plain wake binding does notUnitpassnot runnot runnot run
a registration turns on what its regions need > a lake ships the lake runtime and a never-waking scheduleUnitpassnot runnot runnot run
packages/compiler/test/property-host-transform.test.ts
host transform properties (ssr: false) > rewrites every marked import, keeps the rest, parses, and is deterministicUnitpassnot runnot runnot run
host transform properties (ssr: true) > rewrites every marked import, keeps the rest, parses, and is deterministicUnitpassnot runnot runnot run
packages/compiler/test/queries.test.ts
queries > a chain of answers a hundred thousand deep is checked after an edit without a stack overflowUnitpassnot runnot runnot run
queries > a query that reads itself throws as a cycle even when the bound lets it go while it runsUnitpassnot runnot runnot run
queries > a query that reads itself throws, and the database still answers afterUnitpassnot runnot runnot run
queries > a reader of an answer the bound let go runs again, and answers rightUnitpassnot runnot runnot run
queries > a recompute that reads fewer answers than before forgets the restUnitpassnot runnot runnot run
queries > an answer is computed once, and again only after what it read changedUnitpassnot runnot runnot run
queries > an answer that comes out the same stops there: its readers keep theirsUnitpassnot runnot runnot run
queries > an answer that now throws has moved, for a watcher and for answers_changed_sinceUnitpassnot runnot runnot run
queries > an answer whose first run threw is not heldUnitpassnot runnot runnot run
queries > an answer whose run threw runs again when next read, even if nothing it read movedUnitpassnot runnot runnot run
queries > an answer, not an input, cannot be setUnitpassnot runnot runnot run
queries > an input given its value only by set keeps it past the bound (#1545)#1545Unitpassnot runnot runnot run
queries > answers let go past the bound are computed again, rightUnitpassnot runnot runnot run
queries > answers run deeper than the bound still answer right after an editUnitpassnot runnot runnot run
queries > past the bound, the answer used longest ago goes first: a read in a later revision is a use; inputs stayUnitpassnot runnot runnot run
queries > refresh reads an input again only when something read itUnitpassnot runnot runnot run
queries > reread reads every input again; answers_changed_since tells whether an answer movedUnitpassnot runnot runnot run
queries > same: structure, Maps and Sets in orderUnitpassnot runnot runnot run
queries > setting an input to the value it has is no new revisionUnitpassnot runnot runnot run
queries > the bound never lets an input go while an answer read it: refresh says it changed (#1545)#1545Unitpassnot runnot runnot run
queries > the bound never lets an input go while an answer read it: reread sees the change (#1545)#1545Unitpassnot runnot runnot run
route answers in dev match a cold start > after any run of edits, each told to the reader as the watcher tells itUnitpassnot runnot runnot run
route answers in dev match a cold start > touch says false for an edit that leaves every route answer as it wasUnitpassnot runnot runnot run
packages/compiler/test/read-csr-kit.test.ts
read_csr against Kit’s reader, over generated option files > agrees wherever Kit can read a valueUnitpassnot runnot runnot run
read_csr reads csr like Kit > /* export const csr = true */ export const csr = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > // export const csr = true export const csr = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > const csr = false; → undefinedUnitpassnot runnot runnot run
read_csr reads csr like Kit > const csr = false; export { csr } from "./options"; → undefinedUnitpassnot runnot runnot run
read_csr reads csr like Kit > const csr = false; export { csr }; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > const s = "export const csr = true"; export const csr = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > const s = `export const csr = true`; export const csr = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > const u = "/*"; export const csr = false; const v = "*/"; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > const x = false; export { x as 'csr' }; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > const x = false; export { x as csr }; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export { csr } from "./options"; → undefinedUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = → undefinedUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = !0; → undefinedUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = 'false'; → undefinedUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = (false); → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = <boolean>false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = false as boolean; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = false satisfies boolean; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = false; const x = <div>; → undefinedUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = false!; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr = true; → trueUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csr: boolean = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const csrf = true; export const csr = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const prerender = true; → undefinedUnitpassnot runnot runnot run
read_csr reads csr like Kit > export const ssr = true, csr = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export let csr = false; → falseUnitpassnot runnot runnot run
read_csr reads csr like Kit > export var csr = false; → falseUnitpassnot runnot runnot run
packages/compiler/test/region-emit.test.ts
the held binding > bakes a rootMargin only beside a baked scheduleUnitpassnot runnot runnot run
the held binding > renders through the shared helper and tells it whether the region wakesUnitpassnot runnot runnot run
the island entry > an export named 'default' imports the default, any other name imports that exportUnitpassnot runnot runnot run
the island entry > cut at the foreign-hydrate mark, the entry imports nothing of the runtimeUnitpassnot runnot runnot run
the island entry > registers the transportable codecs before the component, so a prop decodes without its classUnitpassnot runnot runnot run
the island wrapper > hands children to Region as a prop, so a childless call site passes no slotUnitpassnot runnot runnot run
the lake wrapper > only an swr lake carries an endpoint schedule and its margin; every lake hands Region its propsUnitpassnot runnot runnot run
the lake wrapper > the placeholder rewrite matches a named import by its local name, not its exported oneUnitpassnot runnot runnot run
the server-region wrapper > a deferred region that hydrates carries its module and its hydrate marginUnitpassnot runnot runnot run
the server-region wrapper > carries the stitch mode to the holeUnitpassnot runnot runnot run
the server-region wrapper > its client leg imports no component: a hole ships no JSUnitpassnot runnot runnot run
the wake binding > bakes a margin only for the visible scheduleUnitpassnot runnot runnot run
the wake binding > its client leg is metadata only: no component, no signer, no server importUnitpassnot runnot runnot run
packages/compiler/test/region-host-order.test.ts
a deleted component leaves no claim on its region: the next host to mark it names itselfUnitpassnot runnot runnot run
a region a page and its layout share names the same host whichever registers lastUnitpassnot runnot runnot run
a region whose first host lets go names the host that still holds itUnitpassnot runnot runnot run
packages/compiler/test/region-id-salt.test.ts
a region id is salted with idSalt > a .svelte hostUnitpassnot runnot runnot run
a region id is salted with idSalt > a .svelte host: an empty salt is no saltUnitpassnot runnot runnot run
a region id is salted with idSalt > a .ts hostUnitpassnot runnot runnot run
a region id is salted with idSalt > a .ts host: an empty salt is no saltUnitpassnot runnot runnot run
packages/compiler/test/region-identity-canonical.test.ts
a lang='ts' host and a plain one share the region's wrapper, byte for byte > ssr falseUnitpassnot runnot runnot run
a lang='ts' host and a plain one share the region's wrapper, byte for byte > ssr trueUnitpassnot runnot runnot run
one component, one region id, however the host names it > a relative pathUnitpassnot runnot runnot run
one component, one region id, however the host names it > a root-absolute pathUnitpassnot runnot runnot run
one component, one region id, however the host names it > an app aliasUnitpassnot runnot runnot run
packages/compiler/test/region-mac.test.ts
encode_region_props (SWR / defer mint bound) > encodes plain propsUnitpassnot runnot runnot run
encode_region_props (SWR / defer mint bound) > freezes a bare function prop to a static region snippet (the boundary law) and encodesUnitpassnot runnot runnot run
encode_region_props (SWR / defer mint bound) > returns null for genuinely non-serializable props (symbols)Unitpassnot runnot runnot run
encode_region_props (SWR / defer mint bound) > returns null when b64 payload exceeds MAX_REGION_PROPS_LENUnitpassnot runnot runnot run
islandId salt (P1-ID) > diverges when salt is setUnitpassnot runnot runnot run
islandId salt (P1-ID) > matches unsalted legacy when salt is emptyUnitpassnot runnot runnot run
kit bootstrap detection > detects a real Kit assignment bootstrapUnitpassnot runnot runnot run
kit bootstrap detection > ignores __sveltekit_ reflected inside ogygia side-channelsUnitpassnot runnot runnot run
kit bootstrap detection > strips type=application/ogygia-* even without data attrsUnitpassnot runnot runnot run
RuntimeSession lake_cache (SPA reset) > reset clears lake_cache and initialized_lakesUnitpassnot runnot runnot run
RuntimeSession lake_cache (SPA reset) > SWR refresh replaces an entry without growing the mapUnitpassnot runnot runnot run
verify > rejects non-hex signatures before compareUnitpassnot runnot runnot run
packages/compiler/test/region-mark-refusals.test.ts
a region mark refused > a marked import with no specifier in a .ts moduleUnitpassnot runnot runnot run
a region mark refused > a preset beside another attributeUnitpassnot runnot runnot run
a region mark refused > an import key that is no JavaScript nameUnitpassnot runnot runnot run
packages/compiler/test/region-wrapper-contract.test.ts
each wrapper's settings, field by field > a hole hands Region the id its endpoint is minted for, its component, its css and every fetch settingUnitpassnot runnot runnot run
each wrapper's settings, field by field > a hole's client leg hands Region its id and schedule, and imports nothingUnitpassnot runnot runnot run
each wrapper's settings, field by field > a lake hands Region its id, remount, max age (zero included), expiry and an swr scheduleUnitpassnot runnot runnot run
each wrapper's settings, field by field > a lake renders its component inside Region with the props it was givenUnitpassnot runnot runnot run
each wrapper's settings, field by field > an island hands Region its mode, wake, entry url, component and the component its css comes fromUnitpassnot runnot runnot run
each wrapper's settings, field by field > an island's client leg hands Region its lazy component and its loader, never the component itselfUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > holeUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > hole client legUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > hole with every settingUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > island client leg, wake visible with a margin, keptUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > island, wake idleUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > island, wake loadUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > island, wake on a media query, keptUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > island, wake visible with a marginUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > lakeUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > lake, max age zeroUnitpassnot runnot runnot run
every wrapper the compiler writes hands Region only what Region reads > lake, swr with every settingUnitpassnot runnot runnot run
the compiled wrappers, rendered on the server through Region > a hole renders its shell with its fallback, its endpoint minted for its idUnitpassnot runnot runnot run
the compiled wrappers, rendered on the server through Region > a lake in an island with a max age of zero and an expiry writes both on its elementUnitpassnot runnot runnot run
the compiled wrappers, rendered on the server through Region > an island renders its component's HTML inside its element, which names its entry url and wakeUnitpassnot runnot runnot run
packages/compiler/test/registry-reach.test.ts
registry reach walk > a csr=false page's option module shares its page's worldUnitpassnot runnot runnot run
registry reach walk > a package's internals are not walked, even toward a registryUnitpassnot runnot runnot run
registry reach walk > a registry behind a plain helper resolves to the client-leg variantUnitpassnot runnot runnot run
registry reach walk > a remote, server-only or rune module never forks, registry or notUnitpassnot runnot runnot run
registry reach walk > a wide fan-out over a deep shared chain reads each module once, and stays sharedUnitpassnot runnot runnot run
registry reach walk > cycles: the far side reaching a registry wins from either entry; a dead cycle stays negativeUnitpassnot runnot runnot run
registry reach walk > each edge is resolved once a build, and a resolver that refuses one forks nothingUnitpassnot runnot runnot run
packages/compiler/test/registry-stub.test.ts
export_names > a module with no exports yields nothingUnitpassnot runnot runnot run
export_names > declarations, export lists (aliased), defaultUnitpassnot runnot runnot run
imported_names > named (with alias → exported name) + default, only for the given specUnitpassnot runnot runnot run
registry_client_source > a marked named import blanks every name it binds; a plain import of the same module staysUnitpassnot runnot runnot run
registry_client_source > a registry with no marks is returned unchanged; an unparsable one is nullUnitpassnot runnot runnot run
registry_client_source > blanks marked imports, keeps plain ones, re-exports and style imports byte-for-byteUnitpassnot runnot runnot run
registry_client_source > import.meta.og.regions(glob) blanks to an empty registryUnitpassnot runnot runnot run
registry_client_source > renamed region keys are honoured (importKeys)Unitpassnot runnot runnot run
registry_client_source > variant id round-trips the real pathUnitpassnot runnot runnot run
static_script_specs > unparsable → nullUnitpassnot runnot runnot run
static_script_specs > value imports, side-effect imports and re-exports; never type-only or dynamicUnitpassnot runnot runnot run
stub id + source > no names → an empty moduleUnitpassnot runnot runnot run
stub id + source > round-trips the names through the id; source declares each as undefinedUnitpassnot runnot runnot run
packages/compiler/test/relocations-build.test.ts
relocations in a real build > a csr=false client build (minify: false) leaves nothing unpatchedUnitpassnot runnot runnot run
relocations in a real build > a csr=false client build (minify: true) leaves nothing unpatchedUnitpassnot runnot runnot run
packages/compiler/test/relocations.test.ts
relocate > a browser leg leaves the server-only page-data reads aloneUnitpassnot runnot runnot run
relocate > a chunk without a token is left aloneUnitpassnot runnot runnot run
relocate > a late server region's loader imports its chunk by its path from the chunk being finishedUnitpassnot runnot runnot run
relocate > a lazy loader's file token is its module's own chunk from the chunk being finished, or nullUnitpassnot runnot runnot run
relocate > a minifier that re-quoted a file token still has it replaced wholeUnitpassnot runnot runnot run
relocate > a server map's JSON is escaped for the quote its literal was givenUnitpassnot runnot runnot run
relocate > every token in a chunk is replaced and countedUnitpassnot runnot runnot run
relocate > no token is a comment, which the bundler drops before renderChunkUnitpassnot runnot runnot run
relocate > only a mapped relocation's patch hands on a map (the others keep the chunk's as given)Unitpassnot runnot runnot run
unpatched > a browser leg is not held to a server-only tokenUnitpassnot runnot runnot run
unpatched > a token left in the output is saidUnitpassnot runnot runnot run
written relocations > a leg does not patch the written ones at its own endUnitpassnot runnot runnot run
written relocations > the client leg's island deps go into the server file's slot, escaped for either quoteUnitpassnot runnot runnot run
packages/compiler/test/render-id.test.ts
renderId > another component, or another export of the same file, is another render identityUnitpassnot runnot runnot run
renderId > is the component alone: schedule, preset settings and salt never change itUnitpassnot runnot runnot run
renderId > posix whatever the OS separator, 12 hex, never a region id of the same componentUnitpassnot runnot runnot run
the server manifest maps render identities > each id → its render identity; each render identity → one entry rendering it (the smallest id)Unitpassnot runnot runnot run
the server manifest maps render identities > each id → the url its CSS is keyed by, and its component nameUnitpassnot runnot runnot run
the server manifest maps render identities > the browser leg carries none of itUnitpassnot runnot runnot run
the server manifest maps render identities > the islands’ loaders live one dynamic import away (Kit links CSS one import deep)Unitpassnot runnot runnot run
packages/compiler/test/route-config-kit.test.ts
page_route_config — Kit’s merge > a layout sets the key, children inherit it, a page overrides it; unset is absentUnitpassnot runnot runnot run
page_route_config — Kit’s merge > a layout turns a subtree off and a page below turns itself back onUnitpassnot runnot runnot run
page_route_config — Kit’s merge > a redirect-only route (a `+page.server.ts` with no component) is a page tooUnitpassnot runnot runnot run
page_route_config — Kit’s merge > a route-file change is seen after its file event (the dev watcher)Unitpassnot runnot runnot run
page_route_config — Kit’s merge > at one level the server module beats the universal module, as in KitUnitpassnot runnot runnot run
page_route_config — Kit’s merge > baked values answer at run time by Kit route.id (groups and all); unset = undefinedUnitpassnot runnot runnot run
page_route_config — Kit’s merge > strips (group) segments so the id matches Kit route.id normalizationUnitpassnot runnot runnot run
page_route_config — Kit’s merge > the merge is per key: a deeper config without the key keeps the outer valueUnitpassnot runnot runnot run
read_route_config — export shapes > a claimed key with a computed value is a build error naming the file and keyUnitpassnot runnot runnot run
read_route_config — export shapes > a regular expression or a bigint is no plain literal: a build error tooUnitpassnot runnot runnot run
read_route_config — export shapes > nothing is stripped: the route module stays exactly what Kit readsUnitpassnot runnot runnot run
read_route_config — export shapes > reads the claimed key out of the object, typed or not; absent everywhere elseUnitpassnot runnot runnot run
packages/compiler/test/route-csr.test.ts
csrTrueRouteIds + cache > a file event picks up new declarations AND new pagesUnitpassnot runnot runnot run
csrTrueRouteIds + cache > root page maps to "/", groups stripped, multiple entriesUnitpassnot runnot runnot run
errorCsrTrueRouteIds / rootLayoutCsrTrue — the layout branch decides > a new layout declaration is picked up after its file eventUnitpassnot runnot runnot run
errorCsrTrueRouteIds / rootLayoutCsrTrue — the layout branch decides > csr=false declared on the layout chain turns the error pages off tooUnitpassnot runnot runnot run
errorCsrTrueRouteIds / rootLayoutCsrTrue — the layout branch decides > deepest LAYOUT declaration wins, page files ignored, groups strippedUnitpassnot runnot runnot run
errorCsrTrueRouteIds / rootLayoutCsrTrue — the layout branch decides > THE BUG: csr=false pages under a default (csr=true) layout — pages off, their error pages ONUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > a csr=false layout whose every page turns csr back on strips: the pages decide, not its chainUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > a layout with no pages below falls back to its own chainUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > a nested layout whose subtree is pure csr=true strips even under a csr=false rootUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > a redirect-only route (no page component) renders nothing, so it counts in no worldUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > all pages Kit-hydrated → the layout stripsUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > every page below csr=false (declared at various depths) → island worldUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > mixed subtree → shared world; runtime set carries exactly the true pagesUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > NESTED layouts are each judged by their OWN subtreeUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > root csr=false with a deeper csr=true override — layout goes sharedUnitpassnot runnot runnot run
layout world — derived from pages, never its own chain > sibling-prefix dirs do not leak into a layout fold (docs vs docs-old)Unitpassnot runnot runnot run
layout world — derived from pages, never its own chain > THE REGRESSION: csr=false only in a deep catch-all still islands the root layoutUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > a universal csr = false beats a server csr = true on one node, like KitUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > a universal csr = true beats a server csr = false on one node, like Kit (+layout.server.ts, +layout.ts)Unitpassnot runnot runnot run
page world — option-file chain, deepest wins > a universal csr = true beats a server csr = false on one node, like Kit (+page.server.ts, +page.ts)Unitpassnot runnot runnot run
page world — option-file chain, deepest wins > csr=false in root-level +layout.js reaches the pageUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > csr=false in root-level +layout.server.ts reaches the pageUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > csr=false in root-level +layout.ts reaches the pageUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > csr=false in root-level +page.js reaches the pageUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > csr=false in root-level +page.server.ts reaches the pageUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > csr=false in root-level +page.ts reaches the pageUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > deepest declaration wins across a false → true → false chainUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > group-segment option files participate in the chainUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > non-route files and files outside routesDir are never route hostsUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > rest/optional param dirs are ordinary chain segmentsUnitpassnot runnot runnot run
page world — option-file chain, deepest wins > the page's own option file beats every layout above itUnitpassnot runnot runnot run
read_csr — declaration forms > commented-out declarations never winUnitpassnot runnot runnot run
read_csr — declaration forms > plain false / true / absentUnitpassnot runnot runnot run
read_csr — declaration forms > typed form `csr: boolean`Unitpassnot runnot runnot run
route components in any extension > a markdown page has its own world and counts for its layoutUnitpassnot runnot runnot run
route components in any extension > option scripts are not componentsUnitpassnot runnot runnot run
transform seam — route_csr tri-state on a layout host > island world (false) and shared world (undefined) keep the chrome islandsUnitpassnot runnot runnot run
transform seam — route_csr tri-state on a layout host > strip world (true) hands the component to Kit as plainUnitpassnot runnot runnot run
packages/compiler/test/route-tree-kit.test.ts
a dev edit to a route file changes the route answers > a new +page.md is a new routeUnitpassnot runnot runnot run
a dev edit to a route file changes the route answers > a new +page.svelte is a new routeUnitpassnot runnot runnot run
a dev edit to a route file changes the route answers > a new [email protected] is a new routeUnitpassnot runnot runnot run
a layout with a layout reset > skips the options of the layouts between it and the reset targetUnitpassnot runnot runnot run
a page with a layout reset > a csr = false `[email protected]` is a csr=false routeUnitpassnot runnot runnot run
a page with a layout reset > a csr = true `[email protected]` is a csr=true routeUnitpassnot runnot runnot run
a page with a layout reset > resets to a named ancestor segment, groups includedUnitpassnot runnot runnot run
a page with a layout reset > skips the options of the layouts between it and the reset targetUnitpassnot runnot runnot run
a page with a layout reset > takes route config from the layouts it uses onlyUnitpassnot runnot runnot run
a route file with a layout reset is a route component > +layout.svelte is not a page componentUnitpassnot runnot runnot run
a route file with a layout reset is a route component > [email protected] is a layoutUnitpassnot runnot runnot run
a route file with a layout reset is a route component > +layout@(app).md is a layoutUnitpassnot runnot runnot run
a route file with a layout reset is a route component > +page.server.ts is not a page componentUnitpassnot runnot runnot run
a route file with a layout reset is a route component > +page.ts is not a page componentUnitpassnot runnot runnot run
a route file with a layout reset is a route component > [email protected] is a pageUnitpassnot runnot runnot run
a route file with a layout reset is a route component > [email protected] is not a page componentUnitpassnot runnot runnot run
a route file with a layout reset is a route component > +page@(group).svelte is a pageUnitpassnot runnot runnot run
a route file with a layout reset is a route component > [email protected] is a pageUnitpassnot runnot runnot run
a route file with a layout reset is a route component > +pages.svelte is not a page componentUnitpassnot runnot runnot run
the route tree against Kit’s, over generated route trees > every page’s csr, its error page’s csr and the client-build skip agree with KitUnitpassnot runnot runnot run
the route tree against Kit’s, over generated route trees > every page’s merged route config agrees with Kit’s get_configUnitpassnot runnot runnot run
packages/compiler/test/router-css-dev-preprocess.test.ts
a router page's scss component: dev's router CSS is what the build compilesUnitpassnot runnot runnot run
packages/compiler/test/router-css-dev.test.ts
router page CSS in dev (#249), loaded by ssrLoadModule > an edit to the page style: the next render links the edited CSS#249Unitpassnot runnot runnot run
router page CSS in dev (#249), loaded by ssrLoadModule > one failed read of the registry: the next render links the page CSS#249Unitpassnot runnot runnot run
router page CSS in dev (#249), loaded by the ssr environment's runner > an edit to the page style: the next render links the edited CSS#249Unitpassnot runnot runnot run
router page CSS in dev (#249), loaded by the ssr environment's runner > one failed read of the registry: the next render links the page CSS#249Unitpassnot runnot runnot run
packages/compiler/test/router-css.test.ts
router_css_module — the generated virtual > collects a plain .css import (the profiler.css shared-sheet pattern)Unitpassnot runnot runnot run
router_css_module — the generated virtual > dev: a plain stylesheet in a preprocessor dialect is left out (it loads once built)Unitpassnot runnot runnot run
router_css_module — the generated virtual > dev: inlines compiled scoped css (transitively, through child components)Unitpassnot runnot runnot run
router_css_module — the generated virtual > emits an inert module for zero rootsUnitpassnot runnot runnot run
router_css_module — the generated virtual > keys are stable and posixUnitpassnot runnot runnot run
router_css_module — the generated virtual > prod: a link is the base plus the handoff href, claimed by the raw href (a held region linking it dedupes)Unitpassnot runnot runnot run
router_css_module — the generated virtual > prod: registers each root with a handoff thunk (region_css key + Kit's configured base)Unitpassnot runnot runnot run
router_css_roots — the component closure of router modules > collects direct .svelte importsUnitpassnot runnot runnot run
router_css_roots — the component closure of router modules > follows barrels (re-exports) to their .svelte leavesUnitpassnot runnot runnot run
router_css_roots — the component closure of router modules > no router modules → no rootsUnitpassnot runnot runnot run
router_css_roots — the component closure of router modules > resolves extensionless + index barrelsUnitpassnot runnot runnot run
router_css_roots — the component closure of router modules > skips package imports and survives import cyclesUnitpassnot runnot runnot run
runtime registry > dev path registration resolves through svelte dev FILENAME symbol (no component import)Unitpassnot runnot runnot run
runtime registry > registers by identity, resolves via the thunk, tolerates a throwing thunkUnitpassnot runnot runnot run
packages/compiler/test/runtime-boot-svelte-free.test.ts
island-side modules reach the runtime only through its handles > app.ts imports no boot moduleUnitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > Kit’s transport really does share the registry (so it is the allowed exception, not a loophole)Unitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > lazy chunk hydrate-core.ts imports no boot module beyond what Kit's transport sharesUnitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > lazy chunk interaction-replay.ts imports no boot module beyond what Kit's transport sharesUnitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > lazy chunk router-nav.ts imports no boot module beyond what Kit's transport sharesUnitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > shims/app-navigation.ts imports no boot moduleUnitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > shims/app-state.svelte.ts imports no boot moduleUnitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > shims/app-stores.ts imports no boot moduleUnitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > shims/kit-remote/client-stub.ts imports no boot moduleUnitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > the boot set follows the bundled packages too (the machine the boot runs on)Unitpassnot runnot runnot run
island-side modules reach the runtime only through its handles > the check is not vacuous: the boot set holds the router and the slots registryUnitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > boot-phase feature "forms" (form-continuity.js)Unitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > boot-phase feature "frames" (frames.js)Unitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > boot-phase feature "interaction" (interaction.js)Unitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > boot-phase feature "lakes" (lakes.js)Unitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > boot-phase feature "morph" (morph.js)Unitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > boot-phase feature "mpa-nav" (nav-handle.js)Unitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > boot-phase feature "router" (router.js)Unitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > boot-phase feature "wire-classes" (wire-classes.js)Unitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > core.tsUnitpassnot runnot runnot run
the browser runtime boot never statically reaches Svelte > the walker is not vacuous: the lazy hydrate core DOES reach SvelteUnitpassnot runnot runnot run
the compiler splits features into two static phases > hydrate-phase features are exactly context, live, page, wire, remote-seedsUnitpassnot runnot runnot run
the compiler splits features into two static phases > the boot entry never imports a hydrate-phase feature, even when the app uses all of themUnitpassnot runnot runnot run
the compiler splits features into two static phases > the hydrate-phase module imports exactly the hydrate features the marks selectUnitpassnot runnot runnot run
packages/compiler/test/runtime-flags.test.ts
runtime flags > FRAMES is the frames feature: on wherever a region streams HTMLUnitpassnot runnot runnot run
runtime flags > incomplete marks and dev keep every flag onUnitpassnot runnot runnot run
runtime flags > the codec is imported on use only where the wire feature is out of the buildUnitpassnot runnot runnot run
packages/compiler/test/runtime-hash.test.ts
the runtime hash > an unbuilt runtime directory adds nothingUnitpassnot runnot runnot run
the runtime hash > is the content hash of its inputs, the same however often it is computedUnitpassnot runnot runnot run
the runtime hash > moves when any input changes; a missing input changes nothingUnitpassnot runnot runnot run
the runtime hash > takes in every .js file of the runtime directory, and nothing else thereUnitpassnot runnot runnot run
packages/compiler/test/runtime-interaction-feature.test.ts
the interaction feature > not for a page of lakes only, nor a page with no islandsUnitpassnot runnot runnot run
the interaction feature > ships for any island that hydratesUnitpassnot runnot runnot run
packages/compiler/test/runtime-marks-late.test.ts
a lake first registered after the runtime entry was built is reported, naming its hostUnitpassnot runnot runnot run
a lake registered before the runtime entry loads ships in it, and is not reportedUnitpassnot runnot runnot run
a region registered after the runtime entry that needs nothing new is not reportedUnitpassnot runnot runnot run
packages/compiler/test/scan-differential.test.ts
find_og_calls finds what a parser finds > in any program of these piecesUnitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a call inside a template's interpolation is found#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a call spread into an array or a call is found#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a marker as a property name is no call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a marker inside a block comment after a value is no call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after a block, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after a with statement's condition#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after await, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after case, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after delete, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after do, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after else, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after for await, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after for, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after if, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after in, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after instanceof, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after new, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after of, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after return, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after throw, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after typeof, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after void, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after while, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > a regex after yield, on the same line as a call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > match_close is not cut short by a keyword's regex#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a division after a name that ends in a non-ASCII letter#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a division after a non-ASCII name#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a nested template holding a quote#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a postfix increment before a division#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a postfix increment before a division, on the same line as the call#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a regex after a non-ASCII space#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a regex after an if's condition#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a regex after typeof#1441Unitpassnot runnot runnot run
find_og_calls keeps its place (#1441) > past a regex holding a quote after return#1441Unitpassnot runnot runnot run
match_close > the paren that closes, past strings, comments and a regex char classUnitpassnot runnot runnot run
split_first_string > refuses a name, an interpolation, and a literal inside an expressionUnitpassnot runnot runnot run
split_first_string > the first literal, any quote, escapes kept, and the restUnitpassnot runnot runnot run
packages/compiler/test/scan-facts.test.ts
scan facts > a deleted file leaves every fold, and has() says soUnitpassnot runnot runnot run
scan facts > after any run of fact changes, every fold equals a fresh one fed the final factsUnitpassnot runnot runnot run
scan facts > setting a file the facts it has moves no foldUnitpassnot runnot runnot run
packages/compiler/test/script-request.test.ts
is_script_request > /a/Foo.svelte → trueUnitpassnot runnot runnot run
is_script_request > /a/Foo.svelte?lang.mts → trueUnitpassnot runnot runnot run
is_script_request > /a/Foo.svelte?svelte&lang.css → falseUnitpassnot runnot runnot run
is_script_request > /a/Foo.svelte?svelte&type=script&lang.ts → trueUnitpassnot runnot runnot run
is_script_request > /a/Foo.svelte?svelte&type=style → falseUnitpassnot runnot runnot run
is_script_request > /a/Foo.svelte?svelte&type=style&lang.css → falseUnitpassnot runnot runnot run
is_script_request > /a/Foo.svelte?t=1&og-region → trueUnitpassnot runnot runnot run
is_script_request > /a/Foo.svelte?v=123 → trueUnitpassnot runnot runnot run
is_script_request > /a/x.ts?direct → falseUnitpassnot runnot runnot run
is_script_request > /a/x.ts?inline → falseUnitpassnot runnot runnot run
is_script_request > /a/x.ts?raw → falseUnitpassnot runnot runnot run
is_script_request > /a/x.ts?raw=1 → falseUnitpassnot runnot runnot run
is_script_request > /a/x.ts?sharedworker → falseUnitpassnot runnot runnot run
is_script_request > /a/x.ts?url → falseUnitpassnot runnot runnot run
is_script_request > /a/x.ts?v=1#&raw → trueUnitpassnot runnot runnot run
is_script_request > /a/x.ts?worker → falseUnitpassnot runnot runnot run
packages/compiler/test/second-build.test.ts
a second build in one process > reads a csr flipped between the builds, like a cold buildUnitpassnot runnot runnot run
a second build in one process > sees a region added between the builds, like a cold buildUnitpassnot runnot runnot run
packages/compiler/test/seed-shaping-report.test.ts
report_seed_shaping > an island keyed by its identity is blamed through its emitted file's closureUnitpassnot runnot runnot run
report_seed_shaping > returns each unpinned island's blamed modules, root-relative, from its own closure onlyUnitpassnot runnot runnot run
packages/compiler/test/server-manifest-late-order.test.ts
the server leg's maps, loaders and late loaders are the same whichever host registered lastUnitpassnot runnot runnot run
packages/compiler/test/server-manifest-order.test.ts
the server manifest lists its regions the same whichever host registered lastUnitpassnot runnot runnot run
packages/compiler/test/server-region-late.test.ts
a deferred region in a library host only the server bundle reached has its styles built by the client legUnitpassnot runnot runnot run
a deferred region in a library host the scan never saw is in the built server manifest, with its loaderUnitpassnot runnot runnot run
packages/compiler/test/source-map.test.ts
a host a macro, an island and the stamps rewrite > maps each generated position back to the source (client leg)Unitpassnot runnot runnot run
a host a macro, an island and the stamps rewrite > maps each generated position back to the source (server leg)Unitpassnot runnot runnot run
a text-only plugin macro leaves a map that maps nothing, never a wrong placeUnitpassnot runnot runnot run
packages/compiler/test/source.test.ts
macros/source — strict position law > errors on a non-exported declarationUnitpassnot runnot runnot run
macros/source — strict position law > errors on bare access and on nested callsUnitpassnot runnot runnot run
macros/source — strict position law > errors on let / destructuring / wrong arityUnitpassnot runnot runnot run
macros/source — strict position law > in a .svelte <script module>, the import goes inside the script, and no line movesUnitpassnot runnot runnot run
macros/source — strict position law > in a .ts module, the export stays on its own lineUnitpassnot runnot runnot run
macros/source — strict position law > is a no-op without the marker (same reference)Unitpassnot runnot runnot run
macros/source — strict position law > keeps the optional { key } argument verbatimUnitpassnot runnot runnot run
macros/source — strict position law > marks in both scripts of a .svelte file share one import, in whichever script comes firstUnitpassnot runnot runnot run
macros/source — strict position law > mid-edit, a module that does not parse still rewrites the legal spelling, and only itUnitpassnot runnot runnot run
macros/source — strict position law > never rewrites the marker inside a stringUnitpassnot runnot runnot run
macros/source — strict position law > rewrites the legal shape, stamping file#export and injecting the runtime importUnitpassnot runnot runnot run
source runtime > fingerprints are stable, order-insensitive on object keys, event-shape awareUnitpassnot runnot runnot run
source runtime > honors the { key } canonicalizerUnitpassnot runnot runnot run
source runtime > source_tag_of reads the stamp back (the key canonicalizer included); null when unstampedUnitpassnot runnot runnot run
source runtime > the observer sees every receipt too; a throwing seam never fails the callUnitpassnot runnot runnot run
source runtime > wraps: passes through, stamps the id, records the receipt tagUnitpassnot runnot runnot run
packages/compiler/test/standalone-driver.test.ts
standalone driver (no Vite) > a host whose raw <style lang="scss"> the CSS parser rejects still gets its island, style untouchedUnitpassnot runnot runnot run
standalone driver (no Vite) > Compiler.macros hoists an import.meta.og.$ factory into dollar_hoistsUnitpassnot runnot runnot run
standalone driver (no Vite) > Compiler.macros is inert on a module with no markersUnitpassnot runnot runnot run
standalone driver (no Vite) > Compiler.transform is memoized (same source → same result object)Unitpassnot runnot runnot run
standalone driver (no Vite) > Compiler.transform rewrites a marked host island and reports itUnitpassnot runnot runnot run
standalone driver (no Vite) > Compiler.ts_regions mints a `with { wake }` load-region importUnitpassnot runnot runnot run
standalone driver (no Vite) > the fn-manifest is the same bytes whatever order the modules transformed inUnitpassnot runnot runnot run
packages/compiler/test/style-preprocess-failures.test.ts
SCSS that does not compile is left as written, and scss_compile_failed names the fileUnitpassnot runnot runnot run
TypeScript the stripper refuses is left as written, and ts_strip_failed names the fileUnitpassnot runnot runnot run
packages/compiler/test/style-preprocess-sass-missing.test.ts
no sass compiler from the app root: the style is left as is, and sass_missing is said onceUnitpassnot runnot runnot run
packages/compiler/test/transform-edges.test.ts
a marked named import in a .ts module: the option reader > { 'wake': 'load' } with keys undefined → region:loadUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > { color: 'red' } is refusedUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > { held: 'raw' } with keys {"region":"held"} → region:rawUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > { hydrate: 'load' } with keys {"wake":"hydrate"} → region:loadUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > { region: 'raw' } with keys undefined → region:rawUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > { render: 'deferred', fetch: 'idle' } with keys undefined → defer:idleUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > { render: 'deferred', region: 'raw' } is refusedUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > { show: 'deferred', when: 'idle' } with keys {"render":"show","fetch":"when"} → defer:idleUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > { wake: 'load' } with keys undefined → region:loadUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > asRegion is gone: a call is refused with the line to writeUnitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > with a renamed key, { region: 'raw' } under the default name stays a plain import (keys {"region":"held"})Unitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > with a renamed key, { render: 'deferred', fetch: 'idle' } under the default name stays a plain import (keys {"render":"show","fetch":"when"})Unitpassnot runnot runnot run
a marked named import in a .ts module: the option reader > with a renamed key, { wake: 'load' } under the default name stays a plain import (keys {"wake":"hydrate"})Unitpassnot runnot runnot run
a portable snippet that captures a host store > `const [s] = [writable(0)];` used as <b>{s}</b> does notUnitpassnot runnot runnot run
a portable snippet that captures a host store > `const s = derived(other, (x) => x);` used as <b>{s}</b> warns that the object cannot crossUnitpassnot runnot runnot run
a portable snippet that captures a host store > `const s = fromStore(other);` used as <b>{s}</b> warns that the object cannot crossUnitpassnot runnot runnot run
a portable snippet that captures a host store > `const s = make();` used as <b>{s}{$s}</b> warns that the object cannot crossUnitpassnot runnot runnot run
a portable snippet that captures a host store > `const s = make();` used as <b>{s}</b> does notUnitpassnot runnot runnot run
a portable snippet that captures a host store > `const s = toStore(() => 1);` used as <b>{s}</b> warns that the object cannot crossUnitpassnot runnot runnot run
a portable snippet that captures a host store > `const s = writable(0);` used as <b>{s}</b> warns that the object cannot crossUnitpassnot runnot runnot run
a portable snippet that captures a host store > `const slots = {}; const all = $$slots;` used as <b>{slots.a}</b> does notUnitpassnot runnot runnot run
a portable snippet that captures a host store > `const state = make(); let n = $state(0);` used as <b>{state}</b> does notUnitpassnot runnot runnot run
a portable snippet that captures a host store > `let s = $state(0);` used as <b>{s}</b> does notUnitpassnot runnot runnot run
a portable snippet that captures a host store > the frozen-snapshot warning points at the line and column of each $store readUnitpassnot runnot runnot run
a portable snippet that captures a host store > warns once per host, though the server and the client leg both transform itUnitpassnot runnot runnot run
call-site shapes: dotted tags and a hole’s children > import C from './C.svelte' with { render: 'deferred' }; with <C> {#snippet ogygiaFallback()}<p>…</p>{/snippet} </C> → okUnitpassnot runnot runnot run
call-site shapes: dotted tags and a hole’s children > import C from './C.svelte' with { render: 'deferred' }; with <C>{#snippet ogygiaFallback()}<p>…</p>{/snippet}</C> → okUnitpassnot runnot runnot run
call-site shapes: dotted tags and a hole’s children > import C from './C.svelte' with { render: 'deferred' }; with <C>{#snippet ogygiaFallback()}<p>…</p>{/snippet}<p>x</p></C> → region_children_not_portableUnitpassnot runnot runnot run
call-site shapes: dotted tags and a hole’s children > import C from './C.svelte' with { render: 'deferred' }; with <C>{#snippet other()}<p>…</p>{/snippet}</C> → region_children_not_portableUnitpassnot runnot runnot run
call-site shapes: dotted tags and a hole’s children > import C from './C.svelte' with { render: 'deferred' }; with <C><p>x</p></C> → region_children_not_portableUnitpassnot runnot runnot run
call-site shapes: dotted tags and a hole’s children > import C from './C.svelte' with { wake: 'load' }; import * as UI from './ui.ts'; with <C /><UI.Button /> → okUnitpassnot runnot runnot run
call-site shapes: dotted tags and a hole’s children > import C from './C.svelte' with { wake: 'load' }; with <C.Item /> → region_dotted_tagUnitpassnot runnot runnot run
call-site shapes: dotted tags and a hole’s children > import C from './C.svelte' with { wake: 'none' }; with <C><C.Item /></C> → okUnitpassnot runnot runnot run
inline stitch on a hole > stitch: 'edge' → defer:load:stitch:edgeUnitpassnot runnot runnot run
inline stitch on a hole > stitch: 'serve' → defer:load:stitch:serveUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > /app/.ogygia/a.js → falseUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > /app/.ogygia/a.svelte → trueUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > /app/src/A.svelte → falseUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > /app/src/entry/a.js → falseUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/binding/a.js → trueUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/binding/a.svelte → falseUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/entry/a.js → trueUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/entry/a.js?v=1 → trueUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/entry/a.svelte → trueUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/entry/a.ts → falseUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/lazy/a.js → trueUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/lazy/a.svelte → falseUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/wrapper/a.js → falseUnitpassnot runnot runnot run
is_island_path: ogygia glue ids, by family and extension > ogygia:region/wrapper/a.svelte → trueUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L {...rest} /> is allowedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L {@attach rest.a} /> is refusedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L /> is allowedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L bind:value={v} /> is refusedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L label="a {v} b" /> is allowedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L onclick={() => v++} /> is refusedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L online={true} hidden /> is allowedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L onpointerdown={rest.f} /> is refusedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L render={() => v} /> is refusedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L render={function () { return v; }} /> is refusedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L title="x" n={1} /> is allowedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L> </L> is allowedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > <L>x</L> is refusedUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > a live preset { render: 'live', revalidate: 'idle', margin: '9px' } revalidating on visible takes a margin: lake:swr:when:idleUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > a live preset { render: 'live', revalidate: 'visible' } revalidating on visible takes a margin: lake:swr:when:visible:margin:50pxUnitpassnot runnot runnot run
render: 'live' carries only what the revalidate endpoint can serialize > a live preset { render: 'live', revalidate: 'visible', margin: '9px' } revalidating on visible takes a margin: lake:swr:when:visible:margin:9pxUnitpassnot runnot runnot run
packages/compiler/test/transform.test.ts
cross-island children (runtime slot crossing) > a nested marked island inside children keeps its OWN region (wakes independently)Unitpassnot runnot runnot run
cross-island children (runtime slot crossing) > a plain island (no children) compiles identicallyUnitpassnot runnot runnot run
cross-island children (runtime slot crossing) > a server island still rejects host children (only the fallback snippet crosses)Unitpassnot runnot runnot run
cross-island children (runtime slot crossing) > children do not change the region id — one island either wayUnitpassnot runnot runnot run
cross-island children (runtime slot crossing) > children stay at the call site; the entry is the plain .js re-exportUnitpassnot runnot runnot run
cross-island children (runtime slot crossing) > host values referenced by children need no capture wiring (server closure renders them)Unitpassnot runnot runnot run
cross-island children (runtime slot crossing) > many call sites with different children share the ONE islandUnitpassnot runnot runnot run
defer / server islands > a bare render: deferred is fetched on load, the same as fetch: loadUnitpassnot runnot runnot run
defer / server islands > a hole must fetch (fetch: none is rejected)Unitpassnot runnot runnot run
defer / server islands > a hole with both fetch and wake fails on its wakeUnitpassnot runnot runnot run
defer / server islands > a hole's client wrapper never imports its component or entry (a hole ships no JS)Unitpassnot runnot runnot run
defer / server islands > defer:load → ServerIsland wrapper + defer entryUnitpassnot runnot runnot run
defer / server islands > deferred is no-store by default (no __cacheTtl emitted)Unitpassnot runnot runnot run
defer / server islands > fetch pairs with render: deferred — alone, or with another render, it is refusedUnitpassnot runnot runnot run
defer / server islands > non-fallback children on defer are an errorUnitpassnot runnot runnot run
defer / server islands > ogygiaFallback snippet stays at call siteUnitpassnot runnot runnot run
defer / server islands > preset maxAge → __cacheTtl in seconds (bare number is seconds)Unitpassnot runnot runnot run
defer / server islands > preset maxAge → __cacheTtl in seconds (duration string)Unitpassnot runnot runnot run
defer / server islands > preset maxAge: 0 stays no-store (no __cacheTtl)Unitpassnot runnot runnot run
defer / server islands > render: deferred is a hole, fetch its timing — content-only (never hydrates)Unitpassnot runnot runnot run
defer / server islands > wake on a render: deferred import fails the build, naming the fetch to writeUnitpassnot runnot runnot run
defer / server islands > wake on a render: deferred preset fails the build too, naming the presetUnitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > an unknown prefetch value is refused with the vocabularyUnitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > identity: the same component with and without a prefetch are two wrappers, not oneUnitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > inline: prefetch: idle on an interaction hole → __prefetch on the wrapper, when stays interactionUnitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > no prefetch → no __prefetch (the default is the hover warm an interaction hole already has)Unitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > prefetch equal to the fetch schedule is refused — it adds nothingUnitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > prefetch without render: deferred is refused (an island has modulepreload hints for its JS)Unitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > prefetch: 'interaction' is refused — that is the swap, fetch's jobUnitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > prefetch: visible carries the margin (its IntersectionObserver lead), a media query is a schedule tooUnitpassnot runnot runnot run
deferred `prefetch` (the warm schedule) > preset: the same, with maxAge alongsideUnitpassnot runnot runnot run
entry module shape > entry is a JS re-export of the component (props stay on the host tag)Unitpassnot runnot runnot run
errors > a file that names asRegion is read even with no region key in it, and refusedUnitpassnot runnot runnot run
errors > a wake that looks like a call ('visible(200px)') is no media query: refusedUnitpassnot runnot runnot run
errors > dynamic import with region keysUnitpassnot runnot runnot run
errors > inline stitch takes the strings 'serve' or 'edge' onlyUnitpassnot runnot runnot run
errors > keep on a hole, a lake or a live region (no island to keep) is refused, not droppedUnitpassnot runnot runnot run
errors > render: 'static' alone marks nothing: the build says so, never leaves the attribute inUnitpassnot runnot runnot run
errors > unknown strategyUnitpassnot runnot runnot run
errors > wake: 'false' suggests noneUnitpassnot runnot runnot run
foucCssVirtualId > builds .js virtual FOUC CSS ids (encoded path)Unitpassnot runnot runnot run
interaction schedule > interaction dedupes by path+strategy like any scheduleUnitpassnot runnot runnot run
interaction schedule > interaction island can carry crossed children (runtime slot, plain entry)Unitpassnot runnot runnot run
interaction schedule > preset with hydrate: interaction worksUnitpassnot runnot runnot run
interaction schedule > render: deferred + fetch: 'interaction' is an ON-DEMAND hole (fetch on intent)Unitpassnot runnot runnot run
interaction schedule > render: deferred + fetch: 'none' is rejected (a hole must fetch)Unitpassnot runnot runnot run
interaction schedule > wake: 'interaction' → wrapper attr + region kind hydrateUnitpassnot runnot runnot run
keep attribute > empty keep name is a build errorUnitpassnot runnot runnot run
keep attribute > hydrate + keep → wrapper passes __keepUnitpassnot runnot runnot run
keep attribute > keep alone (default load schedule) is allowedUnitpassnot runnot runnot run
keep attribute > keep in a preset worksUnitpassnot runnot runnot run
lakes > a cached lake is its wrapper alone; a live (swr) lake also gets a server entryUnitpassnot runnot runnot run
lakes > hydrate:none → lake wrapper bindingUnitpassnot runnot runnot run
lakes > lake on the real-wrapper client leg (linkVirtualIsland: true) still links its CSS (fouc-css)Unitpassnot runnot runnot run
lakes > lake on the SSR build does NOT link fouc-css (the real component renders + collects CSS)Unitpassnot runnot runnot run
lakes > lake on the stub client leg (linkVirtualIsland: false) links its CSS tooUnitpassnot runnot runnot run
lakes > render: live gets a server entry module (baked + revalidate)Unitpassnot runnot runnot run
lakes > render: live with children is an error (revalidate endpoint re-renders from props)Unitpassnot runnot runnot run
normalize_import_keys > defaultsUnitpassnot runnot runnot run
normalize_import_keys > one config object resolves to one key map, and one key map to one hintUnitpassnot runnot runnot run
normalize_import_keys > rejects collisionsUnitpassnot runnot runnot run
package-specifier island marks > a marked package import (no children) becomes an island keyed by the specifierUnitpassnot runnot runnot run
package-specifier island marks > an empty specifier still errors loudlyUnitpassnot runnot runnot run
package-specifier island marks > children at the call site stay put — the package island crosses them at runtimeUnitpassnot runnot runnot run
package-specifier island marks > csr=false client host: package island skips the fouc-css side-effect import (needs a real path)Unitpassnot runnot runnot run
package-specifier island marks > package islands with children share one id across hosts (children no longer key the id)Unitpassnot runnot runnot run
package-specifier island marks > two hosts marking the same package specifier share one region idUnitpassnot runnot runnot run
portable binding rewrite > a host whose <style> is SCSS still has its regions compiledUnitpassnot runnot runnot run
portable binding rewrite > a lake placed only as a dotted tag is used, so its import stays a lakeUnitpassnot runnot runnot run
portable binding rewrite > a plain import attribute beside a region import is left as writtenUnitpassnot runnot runnot run
portable binding rewrite > an empty client stub, or no wrapper path function, falls back to the built-in namesUnitpassnot runnot runnot run
portable binding rewrite > appDir threads into the baked island entry URL (no hardcoded _app, no baked base)Unitpassnot runnot runnot run
portable binding rewrite > cross-host identity: same component path yields same idUnitpassnot runnot runnot run
portable binding rewrite > csr=false client omit (BUILD): island gets the stub and NO fouc-css linkUnitpassnot runnot runnot run
portable binding rewrite > csr=false client omit (DEV): CSS-only fouc-css virtual for FOUC (not component JS)Unitpassnot runnot runnot run
portable binding rewrite > csr=false client omit: many marked imports → stub bindings, still one emit metadataUnitpassnot runnot runnot run
portable binding rewrite > dotted Menu.Item on marked import is a build errorUnitpassnot runnot runnot run
portable binding rewrite > idle / visible / media strategies bake into wrapperUnitpassnot runnot runnot run
portable binding rewrite > island tags nested 26 deep are walked once, not once more per levelUnitpassnot runnot runnot run
portable binding rewrite > islandChunkFileName / islandPublicUrl honor appDir (base-less)Unitpassnot runnot runnot run
portable binding rewrite > linkVirtualIsland true (default) rewrites to the attach binding (not the stub)Unitpassnot runnot runnot run
portable binding rewrite > list + each of binding is allowedUnitpassnot runnot runnot run
portable binding rewrite > marked import becomes wrapper virtual; template keeps <C />Unitpassnot runnot runnot run
portable binding rewrite > maxAge is DEFERRED-ONLY: an island preset maxAge is ignored (no __cacheTtl on the island)Unitpassnot runnot runnot run
portable binding rewrite > one marked declaration of two names becomes one binding import per name, in orderUnitpassnot runnot runnot run
portable binding rewrite > same component different strategies → two entriesUnitpassnot runnot runnot run
portable binding rewrite > svelte:component this={C} is allowedUnitpassnot runnot runnot run
portable binding rewrite > two static usages + dynamic + second import same path → ONE island entryUnitpassnot runnot runnot run
portable binding rewrite > unused marked import is strippedUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a body bound to an enclosing block ({#each} item, {@const}) stays a plain snippetUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a declared package's host keys its snippet entries by package, not by install pathUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a host with only a <script module> gains one instance <script> for the helperUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a named snippet handed to an ISLAND call site compiles portable too (live crossing)Unitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a parameterized snippet at an ISLAND call site compiles portable — args ride __ogArgsUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a parameterized snippet on a PLAIN component stays native (library-internal wiring)Unitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a root snippet handed to nothing leaves the file untouched (null)Unitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a snippet nested in another crossing snippet ships inside the outer entry, not as its ownUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a snippet that reassigns only its own parameter still crossesUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a snippet that writes host state is left native (a snapshot can’t write back)Unitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > a snippet-only file with no islands still transforms (relaxed bailout)Unitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > captured host value is passed to the entry as a propUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > is rewritten to og_portable + emits a hydrate entryUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > node_modules-swept sources are never portable-branded (bits-ui safety)Unitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > SSR emits a static entry import; the csr=false client loads by urlUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > SSR emits NO static modulepreload — the hint is render-gated in Region.svelteUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > the snippet as written stays in the host, at the root, and is what the component getsUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > two identical snippets dedupe to ONE entry + ONE importUnitpassnot runnot runnot run
portable snippets — a named snippet handed to a non-island component > two names from one <script module> import are imported once in the synthUnitpassnot runnot runnot run
presets > preset expands to strategy on wrapperUnitpassnot runnot runnot run
strategyKey / regionIdentity dedupe > different strategies → different idsUnitpassnot runnot runnot run
strategyKey / regionIdentity dedupe > same path + load → same idUnitpassnot runnot runnot run
strategyKey / regionIdentity dedupe > strategyKey encodes defer+hydrate comboUnitpassnot runnot runnot run
strategyKey / regionIdentity dedupe > strategyKey fingerprints cache ttl (a cached hole never dedupes onto a no-store one)Unitpassnot runnot runnot run
packages/compiler/test/transport-realm.test.ts
the app's transport hook, by realm > the browser realm takes the full transportUnitpassnot runnot runnot run
the app's transport hook, by realm > the server realm takes the transport that refuses ogygia values from the browserUnitpassnot runnot runnot run
the browser leg of the wired classes > loads every class before any island wakes only when the app sends wired values through KitUnitpassnot runnot runnot run
packages/compiler/test/transportables-detect.test.ts
a .svelte <script module> exporting a wire class > <script context='module'> → trueUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > <script context="module"> → trueUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > <script lang="ts" module> → trueUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > <script lang="ts"> → falseUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > <script module> → trueUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > <script> → falseUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > a module script is read as TypeScript, whatever its langUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > a module script with a plain class registers nothingUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > injects the registration inside the module block, tagged by the .svelte pathUnitpassnot runnot runnot run
a .svelte <script module> exporting a wire class > the word module outside a module script is not oneUnitpassnot runnot runnot run
a createContext export registers nothing: its key is Symbol.for(name) > `export const [getCart, setCart] = createContext('cart');` is left as writtenUnitpassnot runnot runnot run
a createContext export registers nothing: its key is Symbol.for(name) > `export const a = createContext('a'), b = createContext('b');` is left as writtenUnitpassnot runnot runnot run
a createContext export registers nothing: its key is Symbol.for(name) > `export const cart = createContext('cart');` is left as writtenUnitpassnot runnot runnot run
a createContext export registers nothing: its key is Symbol.for(name) > `export const cart = og.createContext('cart');` is left as writtenUnitpassnot runnot runnot run
a createContext export registers nothing: its key is Symbol.for(name) > a wire class beside a context: only the class registersUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `class C { static [k] = 1; } const = ;` → trueUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `class C { static [k] = 1; }` → falseUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `class C { static x = 1; }` → falseUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export class C { [k] = 1; static x = 1; }` → falseUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export class C { static [k] = 1; }` → falseUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export class C { static [Symbol.for('ogygia.wire')] = { encode: (c) => c.v, decode: (v) => new C(v) }; }` → trueUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export class C { static k = 1; }` → falseUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export class C { static wire = import.meta.og.wire({ encode: (c) => c.v, decode: (v) => new C(v) }); }` → trueUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export class C { x = 1; }` → falseUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export class C {` → falseUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export const C = class { static [k] = 1; };` → falseUnitpassnot runnot runnot run
moduleHasTransportable: the eager manifest signal > `export const x = { static: true, class: 1 };` → falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `[Symbol.for('ogygia.wire')] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [Sym.for('ogygia.wire')] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [Symbol.for('ogygia.other')] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [Symbol.for('ogygia.wire')] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: trueUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [Symbol.for("ogygia.wire")] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: trueUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [Symbol.for()] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [Symbol.for(name)] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [Symbol.iterator] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [Symbol.keyFor('ogygia.wire')] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static [wireKey] = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = { encode: (c) => c.v, decode: (v) => new C(v) };` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = import.meta.og.bake({ encode: (c) => c.v, decode: (v) => new C(v) });` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = import.meta.og.wire;` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = import.meta.og.wire({ encode: (c) => c.v, decode: (v) => new C(v) });` → registered: trueUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = import.meta.og['wire']({ encode: (c) => c.v, decode: (v) => new C(v) });` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = import.meta.og[wire]({ encode: (c) => c.v, decode: (v) => new C(v) });` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = import.meta['og'].wire({ encode: (c) => c.v, decode: (v) => new C(v) });` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = import.meta[og].wire({ encode: (c) => c.v, decode: (v) => new C(v) });` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = meta.og.wire({ encode: (c) => c.v, decode: (v) => new C(v) });` → registered: falseUnitpassnot runnot runnot run
the wire member: only the symbol key or the raw macro call > `static wire = new.target.og.wire({ encode: (c) => c.v, decode: (v) => new C(v) });` → registered: falseUnitpassnot runnot runnot run
which classes register > a module that does not parse registers nothing (the compiler reports it)Unitpassnot runnot runnot run
which classes register > a module with no class keyword is not even parsedUnitpassnot runnot runnot run
which classes register > a re-export from elsewhere registers nothing, even when a local wire class has its nameUnitpassnot runnot runnot run
which classes register > an exported name that is not a class does not registerUnitpassnot runnot runnot run
which classes register > exported by declaration, by `export { }` (local name), not a re-export from elsewhereUnitpassnot runnot runnot run
which classes register > runs once: a module that already carries the registration is left aloneUnitpassnot runnot runnot run
packages/compiler/test/transportables-gates.test.ts
a module that cannot hold a transportable is never parsed > a `createContext` alone is not parsed: a context registers nothingUnitpassnot runnot runnot run
a module that cannot hold a transportable is never parsed > a class with no `static`: the eager manifest does not parseUnitpassnot runnot runnot run
a module that cannot hold a transportable is never parsed > a component with no `class` is never scanned for a registrationUnitpassnot runnot runnot run
a module that cannot hold a transportable is never parsed > a component without the word `module` is never scanned for a module scriptUnitpassnot runnot runnot run
a module that cannot hold a transportable is never parsed > no `class`: the registration does not parseUnitpassnot runnot runnot run
packages/compiler/test/transportables-prescan.test.ts
a module the prescan cannot parse > counts as one that may define a wire class (#1486)#1486Unitpassnot runnot runnot run
a module the prescan cannot parse > still needs a class and a static to be countedUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > a class nobody exportsUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > a computed static that is no codecUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > a member over two linesUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > a plain memberUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > a readonly memberUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > a typed memberUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > agrees over generated class modulesUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > an export listUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > the construct in a commentUnitpassnot runnot runnot run
the prescan counts a wire class exactly when the registration registers it > the rewritten memberUnitpassnot runnot runnot run
packages/compiler/test/ts-region-imports.test.ts
a region import in a .ts module > /** @example import X from '$lib/X.svelte' with { wake: 'load' } */ is only textUnitpassnot runnot runnot run
a region import in a .ts module > // import X from '$lib/X.svelte' with { wake: 'load' } is only textUnitpassnot runnot runnot run
a region import in a .ts module > an import with other attributes is not a regionUnitpassnot runnot runnot run
a region import in a .ts module > const s = "import X from '$lib/X.svelte' with { wake: 'load' }"; is only textUnitpassnot runnot runnot run
a region import in a .ts module > const s = `import X from '$lib/X.svelte' with { wake: 'load' }`; is only textUnitpassnot runnot runnot run
a region import in a .ts module > export { default as X } from '$lib/X.svelte' with { wake: 'load' }; is refusedUnitpassnot runnot runnot run
a region import in a .ts module > export * from '$lib/X.svelte' with { region: 'raw' }; is refusedUnitpassnot runnot runnot run
a region import in a .ts module > import '$lib/X.svelte' with { wake: 'load' }; is refusedUnitpassnot runnot runnot run
a region import in a .ts module > import { X } from '$lib/X.svelte' with { wake: 'load' }; is a region per bindingUnitpassnot runnot runnot run
a region import in a .ts module > import * as X from '$lib/X.svelte' with { wake: 'load' }; is refusedUnitpassnot runnot runnot run
a region import in a .ts module > import X from '$lib/X.svelte' with { wake: 'load' }; becomes a regionUnitpassnot runnot runnot run
a region import in a .ts module > import X from '$lib/X.svelte' /* why */ with { wake: 'load' }; becomes a regionUnitpassnot runnot runnot run
a region import in a .ts module > import X from '$lib/X.svelte' with { wake: 'load' }; becomes a regionUnitpassnot runnot runnot run
a region import in a .ts module > import X from '$lib/X.svelte' with { "wake": "load" }; becomes a regionUnitpassnot runnot runnot run
a region import in a .ts module > import X from '$lib/X.svelte' with { wake: 'load' } becomes a regionUnitpassnot runnot runnot run
a region import in a .ts module > import X, { y } from '$lib/X.svelte' with { wake: 'load' }; is a region per bindingUnitpassnot runnot runnot run
a region import in a .ts module > rewrites at the right place after text outside ASCIIUnitpassnot runnot runnot run
packages/compiler/test/virtual-core.test.ts
core’s boot modules > installs every hydrate feature in dev from the runtime directory as given when its package.json is not JSONUnitpassnot runnot runnot run
core’s boot modules > installs every hydrate feature in dev, from the runtime the app resolves (a workspace’s .ts source)Unitpassnot runnot runnot run
core’s boot modules > leaves the og.$ factories to the page-inline manifest: the browser bundle imports noneUnitpassnot runnot runnot run
core’s boot modules > names every region’s component for devtools in a build, and none in dev (the dev server serves them)Unitpassnot runnot runnot run
core’s boot modules > on the dev server the boot imports no fn manifest either: a factory registers where its module runsUnitpassnot runnot runnot run
core’s boot modules > picks the boot entry’s features only after every host is prescannedUnitpassnot runnot runnot run
core’s boot modules > re-exports the hydrate features after the runtime flags, which the runtime they import reads backUnitpassnot runnot runnot run
core’s boot modules > runs the app’s client hooks from the boot, and adds nothing for an app without themUnitpassnot runnot runnot run
core’s boot modules > the dev boot calls bootDev, so a sideEffects:false package is not tree-shaken out of itUnitpassnot runnot runnot run
core’s boot modules > turns every runtime flag on in dev, and in a build only the ones its marks needUnitpassnot runnot runnot run
core’s dev modules > boots the plugins’ browser halves on a Kit page, after Vite’s env module in devUnitpassnot runnot runnot run
core’s dev modules > serves the soft HMR bridge in dev onlyUnitpassnot runnot runnot run
core’s region modules > gives a region entry its codecs eagerly on the server, and nothing in the browserUnitpassnot runnot runnot run
core’s region modules > loads transportable classes eagerly on the server, and as lazy loaders by root-relative tag in the browserUnitpassnot runnot runnot run
core’s region modules > serves Kit’s transport the codec cluster only when the app crosses a region or wired value over itUnitpassnot runnot runnot run
core’s server modules > gives the build’s key only to the server leg, and says whether an OGYGIA_SECRET salted its idsUnitpassnot runnot runnot run
core’s server modules > hands csr=true pages the devtools boot URL only in dev with a plugin browser halfUnitpassnot runnot runnot run
core’s server modules > keeps the server’s rate limit, session cookie and profiler maps off the browser legUnitpassnot runnot runnot run
core’s server modules > marks the regions the build’s server-regions module wrote, so a later one is a late regionUnitpassnot runnot runnot run
core’s server modules > names the runtime by its dev URL in dev, and in a build by its chunk once every host is prescannedUnitpassnot runnot runnot run
core’s server modules > prescans before writing the server manifest, in dev and in a buildUnitpassnot runnot runnot run
core’s server modules > re-exports Kit’s own wire codec from its absolute path, and leaves the id to the bundler without oneUnitpassnot runnot runnot run
packages/compiler/test/virtual-reads.test.ts
a dev change reloads exactly the modules that read it > a module whose server load read a part is named, though its browser load read nothing afterUnitpassnot runnot runnot run
a dev change reloads exactly the modules that read it > leaves a module that reads no part untouched, whatever changesUnitpassnot runnot runnot run
a dev change reloads exactly the modules that read it > names a module once per load: reloaded, it is fresh until the part moves againUnitpassnot runnot runnot run
a dev change reloads exactly the modules that read it > names no module that was never loadedUnitpassnot runnot runnot run
a dev change reloads exactly the modules that read it > options: the modules that read the optionsUnitpassnot runnot runnot run
a dev change reloads exactly the modules that read it > plugins: the modules that read the plugin listUnitpassnot runnot runnot run
a dev change reloads exactly the modules that read it > regions: the modules that read the regionsUnitpassnot runnot runnot run
a dev change reloads exactly the modules that read it > routes: the modules that read the routesUnitpassnot runnot runnot run
a dev change reloads exactly the modules that read it > styles: the modules that read the style inputsUnitpassnot runnot runnot run
a load is a reader of the session’s queries > a part moved names the modules that read it, beside any query that changedUnitpassnot runnot runnot run
a load is a reader of the session’s queries > a query it read that changed names it, and only itUnitpassnot runnot runnot run
a load is a reader of the session’s queries > an answer that comes out the same names nobody (early cutoff)Unitpassnot runnot runnot run
core’s session parts > give every field core’s entries read a part, or none on purposeUnitpassnot runnot runnot run
packages/compiler/test/virtual-split.test.ts
a realm module’s names, imported per entry > give the bundle the same chunks as direct imports of the entry modulesUnitpassnot runnot runnot run
packages/compiler/test/virtual-table.test.ts
the virtual-module table > answers every id the code outside the table names (ids.ts)Unitpassnot runnot runnot run
the virtual-module table > declares every virtual module the packages’ source importsUnitpassnot runnot runnot run
the virtual-module table > fails an undeclared id in the namespace with virtual_unknownUnitpassnot runnot runnot run
the virtual-module table > finds a module a leg’s output may not hold, however it got inUnitpassnot runnot runnot run
the virtual-module table > imports a realm module’s names from the entries that have themUnitpassnot runnot runnot run
the virtual-module table > leaves a declared id with a query to the bundler, and fails an undeclared oneUnitpassnot runnot runnot run
the virtual-module table > leaves ids outside the namespace to the bundlerUnitpassnot runnot runnot run
the virtual-module table > leaves the families the driver resolves to the driver, without calling them unknownUnitpassnot runnot runnot run
the virtual-module table > loads a family member by its prefixUnitpassnot runnot runnot run
the virtual-module table > reaches the server (and never the browser) with the region ttlUnitpassnot runnot runnot run
the virtual-module table > refuses a browser-leg load of a server module, by its resolved id, with virtual_wrong_realm; the server leg still loads itUnitpassnot runnot runnot run
the virtual-module table > refuses a module of a realm the leg may not import, with virtual_wrong_realmUnitpassnot runnot runnot run
the virtual-module table > refuses two declarations of one module with virtual_duplicateUnitpassnot runnot runnot run
the virtual-module table > refuses two entries that give their realm one nameUnitpassnot runnot runnot run
the virtual-module table > reloads core’s route modules on a route change, and its plugin list on a plugin changeUnitpassnot runnot runnot run
the virtual-module table > resolves a realm-named specifier, and leaves the old virtual:ogygia/* ids to the bundlerUnitpassnot runnot runnot run
the virtual-module table > resolves an id it already resolved to itself (a barrel’s import, resolved again in SSR)Unitpassnot runnot runnot run
the virtual-module table > serves each realm as one module of named re-exports, values firstUnitpassnot runnot runnot run
the virtual-module table > stubs every realm export for the unit tests (test/_stubs/realm-<realm>.ts)Unitpassnot runnot runnot run
the virtual-module table > takes a constant among its entries as a define, never a module it resolvesUnitpassnot runnot runnot run
the virtual-module table > words the table’s messages, and their pagesUnitpassnot runnot runnot run
the virtual-module table > writes a request module as a re-export of the built core moduleUnitpassnot runnot runnot run
the virtual-module table > writes a value as module source (JSON, with each Set as a Set)Unitpassnot runnot runnot run
packages/compiler/test/virtual-types.test.ts
the virtual modules’ declarations > are the ones the table generates (run scripts/virtual-types.ts after changing an entry)Unitpassnot runnot runnot run
the virtual modules’ declarations > declare each entry by its realm-named id onlyUnitpassnot runnot runnot run
the virtual modules’ declarations > declare each switch from its constant, and the switches are the build’s definesUnitpassnot runnot runnot run
the virtual modules’ declarations > name a shape in core’s contract for every module and switch the table declaresUnitpassnot runnot runnot run
the virtual modules’ declarations > name each value entry’s exports as a fresh probe of its `from` doesUnitpassnot runnot runnot run
the virtual modules’ declarations > refuse a value module whose names were not generated, or whose live names movedUnitpassnot runnot runnot run
the virtual modules’ declarations > type each realm export from core’s contract, never from the compilerUnitpassnot runnot runnot run
packages/compiler/test/vite-hooks.test.ts
a plugin's stage transforms and seams > a barrel's edit is seen by the next export map once the watcher reports itUnitpassnot runnot runnot run
a plugin's stage transforms and seams > a barrel's export map is the environment's: each resolves its names as its own modules doUnitpassnot runnot runnot run
a plugin's stage transforms and seams > a region mark pins an import, whatever names it takes; any other attribute does notUnitpassnot runnot runnot run
a plugin's stage transforms and seams > a stage resolves past this plugin, as a forward-slash id; an external or a throw is nullUnitpassnot runnot runnot run
a plugin's stage transforms and seams > a stage sees the module with no byte-order mark, and its edits land at the code's offsetsUnitpassnot runnot runnot run
a plugin's stage transforms and seams > a stage transform runs only on the modules its filter takesUnitpassnot runnot runnot run
a plugin's stage transforms and seams > every transform of a stage edits the code the stage received, and the stage gives one result and one mapUnitpassnot runnot runnot run
a plugin's stage transforms and seams > why a module stayed: every plugin's answer, for the browser's leg, once each in the findings' orderUnitpassnot runnot runnot run
configResolved > a build leaves the scan entries aloneUnitpassnot runnot runnot run
configResolved > a hand-built config with no optimizeDeps gets one, holding the islandsUnitpassnot runnot runnot run
configResolved > a plugin's own pages are compiled, but never handed to the scanner as the app's entriesUnitpassnot runnot runnot run
configResolved > a scan entry is a glob: a route group or a [param] dir in its path is escapedUnitpassnot runnot runnot run
configResolved > a second configResolved (a builder's next environment) keeps the program the first one builtUnitpassnot runnot runnot run
configResolved > an app-dir define that is not JSON keeps the `_app` default, and nothing throwsUnitpassnot runnot runnot run
configResolved > dev hands Vite's scanner each island file as an entry, after the app's own, onceUnitpassnot runnot runnot run
configResolved > dev warns once when the app's own optimizer include names ogygia; a build does notUnitpassnot runnot runnot run
configResolved > the build cache lives under the configured app's node_modulesUnitpassnot runnot runnot run
configResolved > the dev server sweeps a keep-client route a crashed build leftUnitpassnot runnot runnot run
configResolved > the runtime is named under Kit's appDir; a define that is not a name keeps _appUnitpassnot runnot runnot run
load > a lake's scoped CSS stays scoped when its template reads its scriptUnitpassnot runnot runnot run
load > a page's CSS module carries side effects; one with no path is empty and has noneUnitpassnot runnot runnot run
resolveId > a Kit without its client remote functions fails the browser's remote runtime by nameUnitpassnot runnot runnot run
resolveId > an island's closure follows the app's aliases, in Vite's object form as in its array formUnitpassnot runnot runnot run
resolveId > Kit's client paths module is stubbed in the browser onlyUnitpassnot runnot runnot run
resolveId > Kit's remote functions get stub paths and state in the browser, from their own dir onlyUnitpassnot runnot runnot run
resolveId > ogygia's injected imports resolve to its own files, even on an instance Vite never configuredUnitpassnot runnot runnot run
resolveId > Region's twin imports are the awaiting ones only when the app compiles in Svelte's async modeUnitpassnot runnot runnot run
resolveId > the browser's Kit remote runtime is Kit's own remote functions; the server's is Kit'sUnitpassnot runnot runnot run
the build legs > a content module's asset: its own style from its source, then what no client chunk ships, as the bundler resolves itUnitpassnot runnot runnot run
the build legs > a content module's own style compiles with an await in its markup; one that does not compile goes unstyled, never a failed buildUnitpassnot runnot runnot run
the build legs > a handoff the server leg cannot write is a coded warning, never a failed buildUnitpassnot runnot runnot run
the build legs > a hook with no environment runs in the build's own legUnitpassnot runnot runnot run
the build legs > a leg the bundler closed is no longer the open leg a hook without an environment runs inUnitpassnot runnot runnot run
the build legs > a markup format's islands are scanned once per build, and in dev before any requestUnitpassnot runnot runnot run
the build legs > a markup format's scan reads a file that is not there as nullUnitpassnot runnot runnot run
the build legs > a page module's whole-tree CSS ships as one asset (a programmatic router's page)Unitpassnot runnot runnot run
the build legs > a plugin's prescan reader hears that the build is written once, when the browser leg writes, after the server'sUnitpassnot runnot runnot run
the build legs > a server module in the browser bundle fails the buildUnitpassnot runnot runnot run
the build legs > a server-only region's whole-tree CSS ships as one asset per component, from the server leg's list when it handed one offUnitpassnot runnot runnot run
the build legs > a sheet the bundle dropped is left unlinked, never a failed buildUnitpassnot runnot runnot run
the build legs > a standalone build writes no handoffUnitpassnot runnot runnot run
the build legs > an app with no Kit page but a region to hydrate (a programmatic router) still gets the runtimeUnitpassnot runnot runnot run
the build legs > an island whose host the server leg never loaded gets no chunk; with no handoff, every island doesUnitpassnot runnot runnot run
the build legs > the browser leg hands the server its region deps; the server leg does notUnitpassnot runnot runnot run
the build legs > the browser leg's handoff links each sheet it emitted by URL: a router page's, a hole's, a content body's; and inlines those under Kit's thresholdUnitpassnot runnot runnot run
the build legs > the browser leg's handoff: each entry's chunks and page reads by its identity, its location beside itUnitpassnot runnot runnot run
the build legs > the client environment's own configResolved, after the server leg wrote the handoff, keeps itUnitpassnot runnot runnot run
the build legs > the client leg emits no runtime and no island for an app Kit hydrates whole, or a standalone buildUnitpassnot runnot runnot run
the build legs > the client leg emits the runtime and each island's entryUnitpassnot runnot runnot run
the build legs > the client leg names our entries and keeps the app's own naming for the restUnitpassnot runnot runnot run
the build legs > the client leg neither drops nor writes itUnitpassnot runnot runnot run
the build legs > the plugin keeps its app's Kit config however many other apps were configured since (#633)#633Unitpassnot runnot runnot run
the build legs > the server leg drops an earlier build's handoff, then writes its ownUnitpassnot runnot runnot run
the build legs > under OGYGIA_PROFILE the build ends with a digest of what it transformed: same output, same digestUnitpassnot runnot runnot run
the build legs > what only a profiler reads leaves the handoff without one: each chunk's contents, its heaviest modules, the island's hazards, the doubled modules, why it ships all of the pageUnitpassnot runnot runnot run
the build legs > with a profiler, the barrels each chunk still holds: by fanout, the three widestUnitpassnot runnot runnot run
the config hook > a build of an all-csr=false app injects Kit's keep-client routeUnitpassnot runnot runnot run
the config hook > a build of an app Kit hydrates sweeps a stale keep-client routeUnitpassnot runnot runnot run
the config hook > a dependency that declares ogygia files is SSR-inlined and kept out of the optimizer, onceUnitpassnot runnot runnot run
the config hook > a keep-client route left on disk is not one of the routes that decide itUnitpassnot runnot runnot run
the config hook > a keep-client route the exit cannot remove stays on disk, and the exit goes onUnitpassnot runnot runnot run
the config hook > a standalone build runs none of the ogygia plugins listed beside itUnitpassnot runnot runnot run
the config hook > an ogygia plugin's package is SSR-inlined and kept out of the optimizer, like ogygiaUnitpassnot runnot runnot run
the config hook > core's events compile in when a plugin asks, lazily when it asks for lazyUnitpassnot runnot runnot run
the config hook > dev pre-declares the deps every island imports; a build declares noneUnitpassnot runnot runnot run
the config hook > no client plugin, no client plugin codeUnitpassnot runnot runnot run
the config hook > the app's own Kit major compiles inUnitpassnot runnot runnot run
the config hook > the dev server and a standalone build never inject itUnitpassnot runnot runnot run
the config hook > the keep-client route goes at process exit, armed once however often Vite configuresUnitpassnot runnot runnot run
the config hook > the keep-client route goes in the routes dir the app's Kit config namesUnitpassnot runnot runnot run
the config hook > the router options, the version and the dev server's HMR bridge compile in as constantsUnitpassnot runnot runnot run
the config hook > the rules fold in only under OGYGIA_RULES=1Unitpassnot runnot runnot run
the config hook > what ogygia hands Vite, before Kit's config: one Kit, itself SSR-inlined and never pre-bundled, its files served, entry exports keptUnitpassnot runnot runnot run
the dev server > a build never answers a hot updateUnitpassnot runnot runnot run
the dev server > a csr flip in dev is seen by the next route-csr loadUnitpassnot runnot runnot run
the dev server > a deleted island entry reloads the page; an edit or a build does notUnitpassnot runnot runnot run
the dev server > a host's edit drops its islands' modules; the server it came from then hears of a deleted entryUnitpassnot runnot runnot run
the dev server > a module an island added while the server runs pulls into its world is dropped, to load again as island codeUnitpassnot runnot runnot run
the dev server > a stylesheet a page already joined is Vite's own soft update; one outside src is Vite's tooUnitpassnot runnot runnot run
the dev server > a stylesheet no page joined yet goes out as a scoped join; a package's is Vite'sUnitpassnot runnot runnot run
the dev server > an edit to a route, an island or a deleted file reloads the page; a plain module does notUnitpassnot runnot runnot run
the dev server > an edit to a style-bearing file drops the router's inlined CSS module; a script edit does notUnitpassnot runnot runnot run
the dev server > every stylesheet kind the browser's bridge can join goes out as a scoped join, and only thoseUnitpassnot runnot runnot run
the dev server > two ogygia() instances share no program: what one served, the other never heard of (Kit's throwaway config)Unitpassnot runnot runnot run
the dev server > with a profiler, the dev server answers its source maps, server and browser, and with seed shaping each island's page keysUnitpassnot runnot runnot run
the plugin carries no svelte-config helpers: markdown ones come from @ogygia/content/viteUnitpassnot runnot runnot run
the signing secret > a build refuses a short OGYGIA_SECRET; the dev server takes itUnitpassnot runnot runnot run
the signing secret > a secret already in the environment wins over the .env fileUnitpassnot runnot runnot run
the signing secret > a strong secret salts the build; none leaves it unsaltedUnitpassnot runnot runnot run
the signing secret > each build bakes a fresh key of its own into the serverUnitpassnot runnot runnot run
the signing secret > is read from the app's .env, in its envDir, unless envDir is offUnitpassnot runnot runnot run
the signing secret > region ids are salted from the secret alone, so every build of one secret mints the same idsUnitpassnot runnot runnot run
transform > a build's browser leg emits the entry of an island the prescan missed as it compiles the host; the server leg does notUnitpassnot runnot runnot run
transform > a hook's leg is its environment: a server consumer is the server whatever its name, and ssr isUnitpassnot runnot runnot run
transform > a host is compiled for the leg askedUnitpassnot runnot runnot run
transform > a module's names from a realm module are imported from the entries that have themUnitpassnot runnot runnot run
transform > Kit's client app entry is found under Kit 2's and Kit 3's generated dirs, dev and buildUnitpassnot runnot runnot run
transform > Kit's client app entry publishes Kit's page and the version, in the browser onlyUnitpassnot runnot runnot run
transform > the page Kit's entry publishes carries Kit's own navigating and navigation, never $app/storesUnitpassnot runnot runnot run
packages/compiler/test/watch-island-closure.test.ts
a watch rebuild marks the island’s whole closure again (#1448)#1448Unitpassnot runnot runnot run
packages/compiler/test/wire-gating.test.ts
wire gating — the four detection legs > .ts-minted hydrate regions (the factory-registry pattern) → wireUnitpassnot runnot runnot run
wire gating — the four detection legs > a .ts registry mints no lake: `wake: 'none'` there fails, so every .ts wake region wakesUnitpassnot runnot runnot run
wire gating — the four detection legs > a crossing {#snippet} needs wire on its ownUnitpassnot runnot runnot run
wire gating — the four detection legs > dynamic-only use via {#each}/svelte:component → wireUnitpassnot runnot runnot run
wire gating — the four detection legs > EXCLUDE: a .ts registry of deferred (server) islands stays leanUnitpassnot runnot runnot run
wire gating — the four detection legs > EXCLUDE: a .ts registry of raw (held) regions stays lean — the blocks patternUnitpassnot runnot runnot run
wire gating — the four detection legs > EXCLUDE: a hole mark never placed, only handed on as a value, does not force wireUnitpassnot runnot runnot run
wire gating — the four detection legs > EXCLUDE: an unplaced lake/server mark does not force wireUnitpassnot runnot runnot run
wire gating — the four detection legs > EXCLUDE: static childless placement stays lean (no wire)Unitpassnot runnot runnot run
wire gating — the four detection legs > EXCLUDE: whitespace between an island’s tags is no children (no wire)Unitpassnot runnot runnot run
wire gating — the four detection legs > hydrate binding with NO static placement (registry/each/prop use) → wireUnitpassnot runnot runnot run
wire gating — the four detection legs > static placement WITH children → wire (slot pointers cross)Unitpassnot runnot runnot run