Backtestsvuerun-20261002-115633#15070
SSR memory leak after a render error in a dynamic component
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Root cause: during SSR, a dynamic component's vnode-based slot path calls `renderSlot`, which runs `openBlock()` and then the slot. When the slot throws, nothing closes that block. Unlike the client, `renderComponentRoot`'s catch does not cover this path. So `blockStack` and `currentBlock` stay dangling, and every vnode created afterwards is pushed into the stale block, which retains all later apps. Both patches fix the reported scenario. Patch A: - Adds `resetBlockStack(depth)`, which truncates the stack and also restores `currentBlock`. - Applies it on throw in `renderSlot`, in `normalizeChildren` (the slot-object branch used by `<component :is="'div'">`) and in `normalizeSuspenseSlot`. - Restores the compiled slot `_d` flag in each of those places. - Fixes a latent bug in `renderComponentRoot`: it previously did `blockStack.length = 0` without resetting `currentBlock`, leaving a stale reference. - Nested blocks opened inside the throwing slot (e.g. `v-if`) are handled by truncating to the recorded depth. - Tests are deterministic and directly assert `blockStack`/`currentBlock` balance and `_d` restoration. They would fail before the change. They cover renderSlot, Suspense, normalizeChildren, the render-function error path, and SSR end-to-end cases including nested `v-if` blocks. Patch B: - Adds unwinding in `withCtx` and `renderSlot` via a `closeBlock` loop, which also covers the inline `v-if` case. - Does not touch the stale-`currentBlock` issue in `renderComponentRoot`, Suspense slot normalization, or `_d` restoration in `normalizeChildren`. - Changing `withCtx` (a very hot path) to scan the block stack on every call is a broader behavioral change with slightly more risk. - Its tests are GC/WeakRef based: they test the real symptom, but are skipped unless `--expose-gc` is available and are less precise. Overall, A fixes the root cause more completely and consistently, through a single helper that keeps `currentBlock` correct. Its tests are stronger and deterministic, so A is the better fix.
The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.
Solve
17m 54s
Wall-clock time in the container
Full test suite
No new failures
3,619 passed · 6 skipped · 3,625 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
277vs 152 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.39
Link to minimal reproduction
https://stackblitz.com/edit/vitejs-vite-qfkzyzwp?file=leak.mjs
Steps to reproduce
- download the reproduction from stackblitz (won't work there, needs to be run locally)
- run
pnpm i && pnpm leak - see the heap size & alive app instances grow with each request after the single failed render
The script renders 500 fresh SSR apps, which all get garbage-collected. Then renders one app whose slot content throws, then renders 500 more identical healthy apps, which will never be garbage collected afterwards.
A dynamic component <component :is> with a <slot /> is needed for this to reproduce.
Card
<script setup>
defineProps({ tag: { type: String, default: 'div' } })
</script>
<template>
<component :is="tag" class="card">
<slot />
</component>
</template>
app:
<script setup>
defineProps(['payload']) // one request renders with `payload: null` → throws
</script>
<template>
<main>
<Card>{{ payload.title }}</Card>
</main>
</template>
What is expected?
A failed renderToString should not affect subsequent renders and all apps rendered after it should get garbage collected.
What is actually happening?
Every app created after the single failed render is kept in memory forever.
--- phase 1: 500 healthy renders ---
after 500: created=500 finalized=500 alive=0 heap=20.6MB
--- one crashing render (SSR render error) ---
render rejected as expected: Cannot read properties of null (reading 'title')
--- phase 2: 500 healthy renders (identical to phase 1) ---
after 500: created=1001 finalized=500 alive=501 heap=29.0MB
FINAL: created=1001 finalized=500 alive=501
System Info
Any additional comments?
_No response_
The two patches
packages/runtime-core/__tests__/components/Suspense.spec.tsindex 63560ce81..26ea8464f 100644@@ -12,6 +12,7 @@ import { createBlock, createCommentVNode, createElementBlock,+ createVNode, getCurrentInstance, h, nextTick,@@ -31,6 +32,7 @@ import { watch, watchEffect, withAsyncContext,+ withCtx, withDirectives, } from '@vue/runtime-test' import {@@ -44,6 +46,7 @@ import { } from 'vue' import type { RawSlots } from 'packages/runtime-core/src/componentSlots' import { resetSuspenseId } from '../../src/components/Suspense'+import { blockStack, currentBlock } from '../../src/vnode' import { PatchFlags } from '@vue/shared' describe('Suspense', () => {@@ -86,6 +89,33 @@ describe('Suspense', () => { }, } + // #15070+ test('should keep block stack balanced when slot throws', () => {+ const slot = withCtx(() => {+ throw new Error('slot error')+ }, { type: {} } as any)+ const depth = blockStack.length+ expect(() => createVNode(Suspense, null, { default: slot })).toThrow(+ 'slot error',+ )+ expect(blockStack.length).toBe(depth)+ expect(currentBlock).toBe(null)+ })++ test('should keep block stack balanced when slot throws inside a nested block', () => {+ const slot = withCtx(() => {+ openBlock()+ throw new Error('slot error')+ }, { type: {} } as any) as any+ const depth = blockStack.length+ expect(() => createVNode(Suspense, null, { default: slot })).toThrow(+ 'slot error',+ )+ expect(blockStack.length).toBe(depth)+ expect(currentBlock).toBe(null)+ expect(slot._d).toBe(true)+ })+ test('fallback content', async () => { const Async = defineAsyncComponent({ render() {packages/runtime-core/__tests__/errorHandling.spec.tsindex 0cd3efa58..8facc93e7 100644@@ -7,6 +7,7 @@ import { nextTick, nodeOps, onErrorCaptured,+ openBlock, onMounted, ref, render,@@ -14,6 +15,7 @@ import { watchEffect, } from '@vue/runtime-test' import { ErrorCodes, ErrorTypeStrings } from '../src/errorHandling'+import { blockStack, currentBlock } from '../src/vnode' describe('error handling', () => { test('propagation', () => {@@ -246,6 +248,36 @@ describe('error handling', () => { expect(fn).toHaveBeenCalledWith(err, 'render function') }) + // #15070+ test('in render function with open blocks', () => {+ const err = new Error('foo')+ const fn = vi.fn()++ const Comp = {+ setup() {+ onErrorCaptured((err, instance, info) => {+ fn(err, info)+ return false+ })+ return () => h(Child)+ },+ }++ const Child = {+ setup() {+ return () => {+ openBlock()+ throw err+ }+ },+ }++ render(h(Comp), nodeOps.createElement('div'))+ expect(fn).toHaveBeenCalledWith(err, 'render function')+ expect(blockStack.length).toBe(0)+ expect(currentBlock).toBe(null)+ })+ test('in function ref', () => { const err = new Error('foo') const ref = () => {packages/runtime-core/__tests__/helpers/renderSlot.spec.tsindex bc0678b51..6450503f6 100644@@ -11,6 +11,7 @@ import { } from '../../src' import { PatchFlags } from '@vue/shared' import { setCurrentRenderingInstance } from '../../src/componentRenderContext'+import { blockStack, currentBlock } from '../../src/vnode' describe('renderSlot', () => { beforeEach(() => {@@ -95,4 +96,43 @@ describe('renderSlot', () => { expect(vnode.patchFlag).toBe(PatchFlags.BAIL) }) })++ // #15070+ it('should close its block and restore slot flag when slot throws', () => {+ const slot = withCtx(() => {+ throw new Error('slot error')+ }, { type: {} } as any) as Slot & { _d: boolean }+ const depth = blockStack.length+ expect(() => renderSlot({ default: slot }, 'default')).toThrow(+ 'slot error',+ )+ expect(blockStack.length).toBe(depth)+ expect(currentBlock).toBe(null)+ expect(slot._d).toBe(true)+ })++ it('should close nested blocks opened by a throwing slot', () => {+ const slot = withCtx(() => {+ openBlock()+ throw new Error('slot error')+ }, { type: {} } as any) as Slot & { _d: boolean }+ const depth = blockStack.length+ expect(() => renderSlot({ default: slot }, 'default')).toThrow(+ 'slot error',+ )+ expect(blockStack.length).toBe(depth)+ expect(currentBlock).toBe(null)+ expect(slot._d).toBe(true)+ })++ it('should close its block when fallback throws', () => {+ const depth = blockStack.length+ expect(() =>+ renderSlot({}, 'default', {}, () => {+ throw new Error('fallback error')+ }),+ ).toThrow('fallback error')+ expect(blockStack.length).toBe(depth)+ expect(currentBlock).toBe(null)+ }) })packages/runtime-core/__tests__/vnode.spec.tsindex 3a88f302b..fad6e6ace 100644@@ -140,6 +140,17 @@ describe('vnode', () => { }) describe('children normalization', () => {+ // #15070+ test('restore compiled slot flag when slot normalized to element children throws', () => {+ const slot = withCtx(() => {+ throw new Error('slot error')+ }, { type: {} } as any) as any+ expect(() => createVNode('div', null, { default: slot })).toThrow(+ 'slot error',+ )+ expect(slot._d).toBe(true)+ })+ test('null', () => { const vnode = createVNode('p', null, null) expect(vnode.children).toBe(null)packages/runtime-core/src/componentRenderUtils.tsindex 0b46130c0..39b0b7233 100644@@ -8,11 +8,11 @@ import { Comment, type VNode, type VNodeArrayChildren,- blockStack, cloneVNode, createVNode, isVNode, normalizeVNode,+ resetBlockStack, } from './vnode' import { ErrorCodes, handleError } from './errorHandling' import {@@ -141,7 +141,7 @@ export function renderComponentRoot( : getFunctionalFallthrough(attrs) } } catch (err) {- blockStack.length = 0+ resetBlockStack() handleError(err, instance, ErrorCodes.RENDER_FUNCTION) result = createVNode(Comment) }packages/runtime-core/src/components/Suspense.tsindex ba5e194ae..588b340c8 100644@@ -2,6 +2,7 @@ import { Comment, type VNode, type VNodeProps,+ blockStack, closeBlock, createVNode, currentBlock,@@ -9,6 +10,7 @@ import { isSameVNodeType, normalizeVNode, openBlock,+ resetBlockStack, } from '../vnode' import { ShapeFlags, isArray, isFunction, toNumber } from '@vue/shared' import {@@ -868,6 +870,7 @@ function normalizeSuspenseSlot(s: any) { let block: VNode[] | null | undefined if (isFunction(s)) { const trackBlock = isBlockTreeEnabled && s._c+ const blockDepth = blockStack.length if (trackBlock) { // disableTracking: false // allow block tracking for compiled slots@@ -875,7 +878,15 @@ function normalizeSuspenseSlot(s: any) { s._d = false openBlock() }- s = s()+ try {+ s = s()+ } catch (err) {+ // keep the block stack balanced if the slot (or a nested block in it)+ // throws+ resetBlockStack(blockDepth)+ if (trackBlock) s._d = true+ throw err+ } if (trackBlock) { s._d = true block = currentBlockpackages/runtime-core/src/helpers/renderSlot.tsindex 2f1296bb1..0114b64bd 100644@@ -9,10 +9,12 @@ import { Fragment, type VNode, type VNodeArrayChildren,+ blockStack, createBlock, createVNode, isVNode, openBlock,+ resetBlockStack, } from '../vnode' import { PatchFlags, SlotFlags, isSymbol } from '@vue/shared' import { warn } from '../warning'@@ -71,26 +73,40 @@ export function renderSlot( if (slot && (slot as ContextualRenderFn)._c) { ;(slot as ContextualRenderFn)._d = false }+ const blockDepth = blockStack.length openBlock()- const validSlotContent = slot && ensureValidVNode(slot(props))- const slotKey =- props.key ||- // slot content array of a dynamic conditional slot may have a branch- // key attached in the `createSlots` helper, respect that- (validSlotContent && (validSlotContent as any).key)- const rendered = createBlock(- Fragment,- {- key:- (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) +- // #7256 force differentiate fallback content from actual content- (!validSlotContent && fallback ? '_fb' : ''),- },- validSlotContent || (fallback ? fallback() : []),- validSlotContent && (slots as RawSlots)._ === SlotFlags.STABLE- ? PatchFlags.STABLE_FRAGMENT- : PatchFlags.BAIL,- )+ let rendered: VNode+ try {+ const validSlotContent = slot && ensureValidVNode(slot(props))+ const slotKey =+ props.key ||+ // slot content array of a dynamic conditional slot may have a branch+ // key attached in the `createSlots` helper, respect that+ (validSlotContent && (validSlotContent as any).key)+ rendered = createBlock(+ Fragment,+ {+ key:+ (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) ++ // #7256 force differentiate fallback content from actual content+ (!validSlotContent && fallback ? '_fb' : ''),+ },+ validSlotContent || (fallback ? fallback() : []),+ validSlotContent && (slots as RawSlots)._ === SlotFlags.STABLE+ ? PatchFlags.STABLE_FRAGMENT+ : PatchFlags.BAIL,+ )+ } catch (err) {+ // keep the block stack balanced (including blocks opened inside the slot)+ // and restore the slot flag if the slot or fallback throws, otherwise a+ // dangling block would collect every vnode created afterwards (e.g.+ // leaking subsequent SSR apps)+ resetBlockStack(blockDepth)+ if (slot && (slot as ContextualRenderFn)._c) {+ ;(slot as ContextualRenderFn)._d = true+ }+ throw err+ } if (!noSlotted && rendered.scopeId) { rendered.slotScopeIds = [rendered.scopeId + '-s'] }packages/runtime-core/src/vnode.tsindex b4fe6f237..78694ff8e 100644@@ -290,6 +290,16 @@ export function closeBlock(): void { currentBlock = blockStack[blockStack.length - 1] || null } +/**+ * Discard open blocks above the given depth, e.g. after a render function or+ * slot threw before its (possibly nested) blocks could be closed.+ * @internal+ */+export function resetBlockStack(depth = 0): void {+ blockStack.length = depth+ currentBlock = blockStack[depth - 1] || null+}+ // Whether we should be tracking dynamic child nodes inside a block. // Only tracks when this value is > 0 // We are not using a simple boolean because this value may need to be@@ -829,8 +839,16 @@ export function normalizeChildren(vnode: VNode, children: unknown): void { if (slot) { // _c marker is added by withCtx() indicating this is a compiled slot slot._c && (slot._d = false)- normalizeChildren(vnode, slot())- slot._c && (slot._d = true)+ const blockDepth = blockStack.length+ try {+ normalizeChildren(vnode, slot())+ } catch (err) {+ // close any blocks the slot opened before throwing+ resetBlockStack(blockDepth)+ throw err+ } finally {+ slot._c && (slot._d = true)+ } } return } else {packages/server-renderer/__tests__/ssrDynamicComponent.spec.tsindex 0679c8216..399450087 100644@@ -1,5 +1,6 @@ import { createApp, createVNode } from 'vue' import { renderToString } from '../src'+import { blockStack, currentBlock } from '../../runtime-core/src/vnode' describe('ssr: dynamic component', () => { test('resolved to component', async () => {@@ -77,4 +78,74 @@ describe('ssr: dynamic component', () => { ), ).toBe(`<div id="test"><span>slot</span></div>`) })++ // #15070+ test('render error in slot of dynamic element should not leak open blocks', async () => {+ const Card = {+ template: `<component :is="'div'" class="card"><slot /></component>`,+ }+ const createAppWithPayload = (payload: { title: string } | null) =>+ createApp({+ components: { Card },+ data: () => ({ payload }),+ template: `<main><Card>{{ payload.title }}</Card></main>`,+ })++ await expect(renderToString(createAppWithPayload(null))).rejects.toThrow(+ TypeError,+ )+ expect(blockStack.length).toBe(0)+ expect(currentBlock).toBe(null)++ expect(await renderToString(createAppWithPayload({ title: 'ok' }))).toBe(+ `<main><div class="card"><!--[-->ok<!--]--></div></main>`,+ )+ expect(blockStack.length).toBe(0)+ expect(currentBlock).toBe(null)+ })++ test('render error in nested block of slot content should not leak open blocks', async () => {+ const Card = {+ template: `<component :is="'div'" class="card"><slot /></component>`,+ }+ const createAppWithPayload = (payload: { title: string } | null) =>+ createApp({+ components: { Card },+ data: () => ({ payload, ok: true }),+ template:+ `<main><Card><span v-if="ok">{{ payload.title }}</span></Card>` ++ `<component :is="'p'"><b v-if="ok">{{ payload.title }}</b></component></main>`,+ })++ await expect(renderToString(createAppWithPayload(null))).rejects.toThrow(+ TypeError,+ )+ expect(blockStack.length).toBe(0)+ expect(currentBlock).toBe(null)++ expect(await renderToString(createAppWithPayload({ title: 'ok' }))).toBe(+ `<main><div class="card"><!--[--><span>ok</span><!--]--></div>` ++ `<p><b>ok</b></p></main>`,+ )+ expect(blockStack.length).toBe(0)+ expect(currentBlock).toBe(null)+ })++ test('render error in nested block of dynamic element children should not leak open blocks', async () => {+ const createAppWithPayload = (payload: { title: string } | null) =>+ createApp({+ data: () => ({ payload, ok: true }),+ template: `<component :is="'p'"><b v-if="ok">{{ payload.title }}</b></component>`,+ })++ await expect(renderToString(createAppWithPayload(null))).rejects.toThrow(+ TypeError,+ )+ expect(blockStack.length).toBe(0)+ expect(currentBlock).toBe(null)++ expect(await renderToString(createAppWithPayload({ title: 'ok' }))).toBe(+ `<p><b>ok</b></p>`,+ )+ }) })
packages/runtime-core/src/componentRenderContext.tsindex b1fc70c03..d10eba648 100644@@ -1,6 +1,6 @@ import type { ComponentInternalInstance } from './component' import { devtoolsComponentUpdated } from './devtools'-import { setBlockTracking } from './vnode'+import { blockStack, closeBlock, setBlockTracking } from './vnode' /** * mark the current rendering instance for asset resolution (e.g.@@ -89,10 +89,14 @@ export function withCtx( setBlockTracking(-1) } const prevInstance = setCurrentRenderingInstance(ctx)+ const prevStackSize = blockStack.length let res try { res = fn(...args) } finally {+ // close blocks left dangling when the slot throws mid-block+ // inline blocks (for example `v-if`) have no helper to unwind themselves (#15070)+ for (let i = blockStack.length; i > prevStackSize; i--) closeBlock() setCurrentRenderingInstance(prevInstance) if (renderFnWithContext._d) { setBlockTracking(1)packages/runtime-core/src/helpers/renderSlot.tsindex 2f1296bb1..8f65f8af4 100644@@ -9,6 +9,8 @@ import { Fragment, type VNode, type VNodeArrayChildren,+ blockStack,+ closeBlock, createBlock, createVNode, isVNode,@@ -71,32 +73,42 @@ export function renderSlot( if (slot && (slot as ContextualRenderFn)._c) { ;(slot as ContextualRenderFn)._d = false }+ const prevStackSize = blockStack.length openBlock()- const validSlotContent = slot && ensureValidVNode(slot(props))- const slotKey =- props.key ||- // slot content array of a dynamic conditional slot may have a branch- // key attached in the `createSlots` helper, respect that- (validSlotContent && (validSlotContent as any).key)- const rendered = createBlock(- Fragment,- {- key:- (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) +- // #7256 force differentiate fallback content from actual content- (!validSlotContent && fallback ? '_fb' : ''),- },- validSlotContent || (fallback ? fallback() : []),- validSlotContent && (slots as RawSlots)._ === SlotFlags.STABLE- ? PatchFlags.STABLE_FRAGMENT- : PatchFlags.BAIL,- )+ let rendered: VNode+ try {+ const validSlotContent = slot && ensureValidVNode(slot(props))+ const slotKey =+ props.key ||+ // slot content array of a dynamic conditional slot may have a branch+ // key attached in the `createSlots` helper, respect that+ (validSlotContent && (validSlotContent as any).key)+ rendered = createBlock(+ Fragment,+ {+ key:+ (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) ++ // #7256 force differentiate fallback content from actual content+ (!validSlotContent && fallback ? '_fb' : ''),+ },+ validSlotContent || (fallback ? fallback() : []),+ validSlotContent && (slots as RawSlots)._ === SlotFlags.STABLE+ ? PatchFlags.STABLE_FRAGMENT+ : PatchFlags.BAIL,+ )+ } catch (err) {+ // close blocks left dangling when the slot throws mid-block+ // they would otherwise retain every vnode created afterwards (#15070)+ for (let i = blockStack.length; i > prevStackSize; i--) closeBlock()+ throw err+ } finally {+ if (slot && (slot as ContextualRenderFn)._c) {+ ;(slot as ContextualRenderFn)._d = true+ }+ } if (!noSlotted && rendered.scopeId) { rendered.slotScopeIds = [rendered.scopeId + '-s'] }- if (slot && (slot as ContextualRenderFn)._c) {- ;(slot as ContextualRenderFn)._d = true- } return rendered } packages/server-renderer/__tests__/ssrRender.spec.tsnew file mode 100644index 000000000..2d23452a3@@ -0,0 +1,84 @@+import { createSSRApp } from 'vue'+import { renderToString } from '../src/renderToString'++const gc = () =>+ new Promise<void>(resolve => {+ setTimeout(() => {+ global.gc!()+ resolve()+ })+ })++const Card = {+ props: { tag: { type: String, default: 'div' } },+ template: `<component :is="tag" class="card"><slot /></component>`,+}++const Page = {+ components: { Card },+ props: ['payload'],+ template: `<main><Card>{{ payload.title }}</Card></main>`,+}++describe.skipIf(!global.gc)('ssr: render error leak', () => {+ // #15070+ test('should GC apps created after a render error in a forwarded slot', async () => {+ const createApp = (payload: any) => createSSRApp(Page, { payload })++ expect(await renderToString(createApp({ title: 'ok' }))).toContain('ok')++ await expect(renderToString(createApp(null))).rejects.toThrow(+ `Cannot read properties of null`,+ )++ const weakRefs: { deref(): unknown | undefined }[] = []+ const renderOnce = async () => {+ const app = createApp({ title: 'ok' })+ // @ts-expect-error ES2021 API+ weakRefs.push(new WeakRef(app))+ expect(await renderToString(app)).toContain('ok')+ }+ for (let i = 0; i < 20; i++) {+ await renderOnce()+ }++ for (let i = 0; i < 5; i++) {+ await gc()+ }++ expect(weakRefs.filter(ref => ref.deref()).length).toBe(0)+ })++ test('should GC apps created after a render error in an inline block (`v-if`)', async () => {+ const PageIf = {+ props: ['payload'],+ template: `<component :is="'div'"><div v-if="payload.list">{{ payload.list.missing.x }}</div></component>`,+ }+ const createApp = (payload: any) => createSSRApp(PageIf, { payload })++ expect(+ await renderToString(createApp({ list: { missing: { x: 'ok' } } })),+ ).toContain('ok')++ await expect(renderToString(createApp({ list: {} }))).rejects.toThrow(+ `Cannot read properties of undefined`,+ )++ const weakRefs: { deref(): unknown | undefined }[] = []+ const renderOnce = async () => {+ const app = createApp({ list: { missing: { x: 'ok' } } })+ // @ts-expect-error ES2021 API+ weakRefs.push(new WeakRef(app))+ expect(await renderToString(app)).toContain('ok')+ }+ for (let i = 0; i < 20; i++) {+ await renderOnce()+ }++ for (let i = 0; i < 5; i++) {+ await gc()+ }++ expect(weakRefs.filter(ref => ref.deref()).length).toBe(0)+ })+})vitest.config.tsindex 2fbc92f92..8e1f5bec8 100644@@ -58,6 +58,7 @@ export default defineConfig({ '**/e2e/**', '**/{vue,vue-compat,runtime-dom}/**', 'packages/server-renderer/__tests__/ssrWatch.spec.ts',+ 'packages/server-renderer/__tests__/ssrRender.spec.ts', ], }, },@@ -66,7 +67,10 @@ export default defineConfig({ test: { name: 'unit-gc', pool: 'forks',- include: ['packages/server-renderer/__tests__/ssrWatch.spec.ts'],+ include: [+ 'packages/server-renderer/__tests__/ssrWatch.spec.ts',+ 'packages/server-renderer/__tests__/ssrRender.spec.ts',+ ], execArgv: ['--expose-gc'], }, },