@ankhorage/zora 0.10.0 → 0.12.0

package/src/components/select/Select.tsx

@@ -1,10 +1,14 @@
-import { Box, useTheme } from '@ankhorage/surface';
+import { Box } from '@ankhorage/surface';
 import { Picker } from '@react-native-picker/picker';
 import React from 'react';
 
+import { useZoraTheme } from '../../theme/useZoraTheme';
+import { withZoraThemeScope } from '../../theme/withZoraThemeScope';
 import type { SelectProps } from './types';
 
-export function Select<TValue extends string = string>({
+function SelectInner<TValue extends string = string>({
+  themeId: _themeId,
+  mode: _mode,
   value,
   options,
   onValueChange,
@@ -12,7 +16,7 @@ export function Select<TValue extends string = string>({
   invalid,
   testID,
 }: SelectProps<TValue>) {
-  const { theme } = useTheme();
+  const { theme } = useZoraTheme();
 
   return (
     <Box
@@ -47,3 +51,5 @@ export function Select<TValue extends string = string>({
     </Box>
   );
 }
+
+export const Select = withZoraThemeScope(SelectInner);

package/src/components/select/types.ts

@@ -1,14 +1,15 @@
+import type { ZoraBaseProps } from '../../theme/ZoraBaseProps';
+
 export interface SelectOption<TValue extends string = string> {
   value: TValue;
   label: string;
   disabled?: boolean;
 }
 
-export interface SelectProps<TValue extends string = string> {
+export interface SelectProps<TValue extends string = string> extends ZoraBaseProps {
   value: TValue;
   options: readonly SelectOption<TValue>[];
   onValueChange: (value: TValue) => void;
   disabled?: boolean;
   invalid?: boolean;
-  testID?: string;
 }

package/src/components/tabs/Tabs.tsx

@@ -1,11 +1,15 @@
-import { Box, Stack, useTheme } from '@ankhorage/surface';
+import { Box, Stack } from '@ankhorage/surface';
 import React from 'react';
 
+import { useZoraTheme } from '../../theme/useZoraTheme';
+import { withZoraThemeScope } from '../../theme/withZoraThemeScope';
 import { Button } from '../button';
 import { Text } from '../text';
 import type { TabItem, TabsProps } from './types';
 
-export function Tabs<TValue extends string = string>({
+function TabsInner<TValue extends string = string>({
+  themeId: _themeId,
+  mode: _mode,
   value,
   items,
   onValueChange,
@@ -14,7 +18,7 @@ export function Tabs<TValue extends string = string>({
   disabled: tabsDisabled,
   testID,
 }: TabsProps<TValue>) {
-  const { theme } = useTheme();
+  const { theme } = useZoraTheme();
 
   const renderTab = (item: TabItem<TValue>) => {
     const isActive = item.value === value;
@@ -98,3 +102,5 @@ export function Tabs<TValue extends string = string>({
     </Stack>
   );
 }
+
+export const Tabs = withZoraThemeScope(TabsInner);

package/src/components/tabs/types.ts

@@ -2,6 +2,7 @@ import type { ButtonIconSpec } from '@ankhorage/surface';
 import type { ReactNode } from 'react';
 
 import type { ZoraControlSize } from '../../internal/recipes';
+import type { ZoraBaseProps } from '../../theme/ZoraBaseProps';
 
 export interface TabItem<TValue extends string = string> {
   value: TValue;
@@ -14,12 +15,11 @@ export interface TabItem<TValue extends string = string> {
 
 export type TabsVariant = 'underline' | 'pill' | 'segmented';
 
-export interface TabsProps<TValue extends string = string> {
+export interface TabsProps<TValue extends string = string> extends ZoraBaseProps {
   value: TValue;
   items: readonly TabItem<TValue>[];
   onValueChange: (value: TValue) => void;
   variant?: TabsVariant;
   size?: ZoraControlSize;
   disabled?: boolean;
-  testID?: string;
 }

package/src/components/textarea/Textarea.tsx

@@ -2,10 +2,19 @@ import * as Surface from '@ankhorage/surface';
 import React from 'react';
 
 import { resolveIconSize } from '../../internal/recipes';
+import { useZoraTheme } from '../../theme/useZoraTheme';
+import { withZoraThemeScope } from '../../theme/withZoraThemeScope';
 import type { TextareaProps } from './types';
 
-export function Textarea({ size = 'l', leadingIcon, trailingIcon, ...props }: TextareaProps) {
-  const { theme } = Surface.useTheme();
+function TextareaInner({
+  themeId: _themeId,
+  mode: _mode,
+  size = 'l',
+  leadingIcon,
+  trailingIcon,
+  ...props
+}: TextareaProps) {
+  const { theme } = useZoraTheme();
   const iconSize = resolveIconSize(size);
   const iconColor = theme.semantics.content.muted;
 
@@ -36,3 +45,5 @@ export function Textarea({ size = 'l', leadingIcon, trailingIcon, ...props }: Te
     />
   );
 }
+
+export const Textarea = withZoraThemeScope(TextareaInner);

package/src/components/textarea/types.ts

@@ -1,11 +1,15 @@
 import type * as Surface from '@ankhorage/surface';
 
 import type { ZoraControlSize } from '../../internal/recipes';
+import type { ZoraBaseProps } from '../../theme/ZoraBaseProps';
 
-export interface TextareaProps extends Omit<
-  Surface.TextareaProps,
-  'leadingAccessory' | 'size' | 'trailingAccessory'
-> {
+export interface TextareaProps
+  extends
+    ZoraBaseProps,
+    Omit<
+      Surface.TextareaProps,
+      'leadingAccessory' | 'size' | 'trailingAccessory' | 'mode' | 'themeId'
+    > {
   size?: ZoraControlSize;
   leadingIcon?: Surface.ButtonIconSpec;
   trailingIcon?: Surface.ButtonIconSpec;

package/src/components/toolbar/Toolbar.tsx

@@ -1,10 +1,13 @@
 import { Stack } from '@ankhorage/surface';
 import React from 'react';
 
+import { withZoraThemeScope } from '../../theme/withZoraThemeScope';
 import { Card } from '../card';
 import type { ToolbarProps } from './types';
 
-export function Toolbar({
+function ToolbarInner({
+  themeId: _themeId,
+  mode: _mode,
   children,
   position = 'inline',
   floating = false,
@@ -35,3 +38,5 @@ export function Toolbar({
     </Card>
   );
 }
+
+export const Toolbar = withZoraThemeScope(ToolbarInner);

package/src/components/toolbar/ToolbarAction.tsx

@@ -1,9 +1,15 @@
 import React from 'react';
 
+import { withZoraThemeScope } from '../../theme/withZoraThemeScope';
 import { IconButton } from '../icon-button';
 import type { ToolbarActionProps } from './types';
 
-export function ToolbarAction({ active, ...props }: ToolbarActionProps) {
+function ToolbarActionInner({
+  themeId: _themeId,
+  mode: _mode,
+  active,
+  ...props
+}: ToolbarActionProps) {
   return (
     <IconButton
       {...props}
@@ -13,3 +19,5 @@ export function ToolbarAction({ active, ...props }: ToolbarActionProps) {
     />
   );
 }
+
+export const ToolbarAction = withZoraThemeScope(ToolbarActionInner);

package/src/components/toolbar/types.ts

@@ -3,19 +3,19 @@ import type React from 'react';
 
 export type ToolbarPosition = 'top' | 'bottom' | 'inline';
 
-export interface ToolbarProps {
+import type { ZoraBaseProps } from '../../theme/ZoraBaseProps';
+
+export interface ToolbarProps extends ZoraBaseProps {
   children?: React.ReactNode;
   position?: ToolbarPosition;
   floating?: boolean;
   compact?: boolean;
-  testID?: string;
 }
 
-export interface ToolbarActionProps {
+export interface ToolbarActionProps extends ZoraBaseProps {
   label: string;
   icon: ButtonIconSpec;
   active?: boolean;
   disabled?: boolean;
   onPress?: () => void;
-  testID?: string;
 }

package/src/foundation/Box.tsx

@@ -0,0 +1,13 @@
+import { Box as SurfaceBox, type BoxProps as SurfaceBoxProps } from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface BoxProps extends ZoraBaseProps, Omit<SurfaceBoxProps, 'mode' | 'themeId'> {}
+
+function BoxInner({ themeId: _themeId, mode: _mode, ...props }: BoxProps) {
+  return <SurfaceBox {...props} />;
+}
+
+export const Box = withZoraThemeScope(BoxInner);

package/src/foundation/Center.tsx

@@ -0,0 +1,16 @@
+import {
+  Center as SurfaceCenter,
+  type CenterProps as SurfaceCenterProps,
+} from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface CenterProps extends ZoraBaseProps, Omit<SurfaceCenterProps, 'mode' | 'themeId'> {}
+
+function CenterInner({ themeId: _themeId, mode: _mode, ...props }: CenterProps) {
+  return <SurfaceCenter {...props} />;
+}
+
+export const Center = withZoraThemeScope(CenterInner);

package/src/foundation/Container.tsx

@@ -0,0 +1,17 @@
+import {
+  Container as SurfaceContainer,
+  type ContainerProps as SurfaceContainerProps,
+} from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface ContainerProps
+  extends ZoraBaseProps, Omit<SurfaceContainerProps, 'mode' | 'themeId'> {}
+
+function ContainerInner({ themeId: _themeId, mode: _mode, ...props }: ContainerProps) {
+  return <SurfaceContainer {...props} />;
+}
+
+export const Container = withZoraThemeScope(ContainerInner);

package/src/foundation/Divider.tsx

@@ -0,0 +1,17 @@
+import {
+  Divider as SurfaceDivider,
+  type DividerProps as SurfaceDividerProps,
+} from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface DividerProps
+  extends ZoraBaseProps, Omit<SurfaceDividerProps, 'mode' | 'themeId'> {}
+
+function DividerInner({ themeId: _themeId, mode: _mode, ...props }: DividerProps) {
+  return <SurfaceDivider {...props} />;
+}
+
+export const Divider = withZoraThemeScope(DividerInner);

package/src/foundation/Grid.tsx

@@ -0,0 +1,13 @@
+import { Grid as SurfaceGrid, type GridProps as SurfaceGridProps } from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface GridProps extends ZoraBaseProps, Omit<SurfaceGridProps, 'mode' | 'themeId'> {}
+
+function GridInner({ themeId: _themeId, mode: _mode, ...props }: GridProps) {
+  return <SurfaceGrid {...props} />;
+}
+
+export const Grid = withZoraThemeScope(GridInner);

package/src/foundation/Inline.tsx

@@ -0,0 +1,16 @@
+import {
+  Inline as SurfaceInline,
+  type InlineProps as SurfaceInlineProps,
+} from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface InlineProps extends ZoraBaseProps, Omit<SurfaceInlineProps, 'mode' | 'themeId'> {}
+
+function InlineInner({ themeId: _themeId, mode: _mode, ...props }: InlineProps) {
+  return <SurfaceInline {...props} />;
+}
+
+export const Inline = withZoraThemeScope(InlineInner);

package/src/foundation/Show.tsx

@@ -0,0 +1,13 @@
+import { Show as SurfaceShow, type ShowProps as SurfaceShowProps } from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface ShowProps extends ZoraBaseProps, Omit<SurfaceShowProps, 'mode' | 'themeId'> {}
+
+function ShowInner({ themeId: _themeId, mode: _mode, ...props }: ShowProps) {
+  return <SurfaceShow {...props} />;
+}
+
+export const Show = withZoraThemeScope(ShowInner);

package/src/foundation/Spacer.tsx

@@ -0,0 +1,16 @@
+import {
+  Spacer as SurfaceSpacer,
+  type SpacerProps as SurfaceSpacerProps,
+} from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface SpacerProps extends ZoraBaseProps, Omit<SurfaceSpacerProps, 'mode' | 'themeId'> {}
+
+function SpacerInner({ themeId: _themeId, mode: _mode, ...props }: SpacerProps) {
+  return <SurfaceSpacer {...props} />;
+}
+
+export const Spacer = withZoraThemeScope(SpacerInner);

package/src/foundation/Stack.tsx

@@ -0,0 +1,13 @@
+import { Stack as SurfaceStack, type StackProps as SurfaceStackProps } from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export interface StackProps extends ZoraBaseProps, Omit<SurfaceStackProps, 'mode' | 'themeId'> {}
+
+function StackInner({ themeId: _themeId, mode: _mode, ...props }: StackProps) {
+  return <SurfaceStack {...props} />;
+}
+
+export const Stack = withZoraThemeScope(StackInner);

package/src/foundation/Surface.tsx

@@ -0,0 +1,20 @@
+import {
+  Surface as SurfaceSurface,
+  type SurfaceProps as SurfaceSurfaceProps,
+  type SurfaceVariant,
+} from '@ankhorage/surface';
+import React from 'react';
+
+import { withZoraThemeScope } from '../theme/withZoraThemeScope';
+import type { ZoraBaseProps } from '../theme/ZoraBaseProps';
+
+export type { SurfaceVariant };
+
+export interface SurfaceProps
+  extends ZoraBaseProps, Omit<SurfaceSurfaceProps, 'mode' | 'themeId'> {}
+
+function SurfaceInner({ themeId: _themeId, mode: _mode, ...props }: SurfaceProps) {
+  return <SurfaceSurface {...props} />;
+}
+
+export const Surface = withZoraThemeScope(SurfaceInner);

package/src/foundation/index.test.ts

@@ -7,19 +7,19 @@ const foundationIndex = readFileSync(join(import.meta.dir, 'index.ts'), 'utf8');
 const rootIndex = readFileSync(join(import.meta.dir, '..', 'index.ts'), 'utf8');
 
 describe('foundation exports', () => {
-  it('defines a narrow Surface foundation export layer', () => {
+  it('defines a narrow ZORA foundation export layer', () => {
     expect(foundationIndex).toMatch(/export type \{/);
     expect(foundationIndex).toMatch(/BoxProps/);
     expect(foundationIndex).toMatch(/ContainerProps/);
     expect(foundationIndex).toMatch(/GridProps/);
     expect(foundationIndex).toMatch(/StackProps/);
     expect(foundationIndex).toMatch(/SurfaceProps/);
-    expect(foundationIndex).toMatch(/export \{/);
     expect(foundationIndex).toMatch(/Box/);
     expect(foundationIndex).toMatch(/Container/);
     expect(foundationIndex).toMatch(/Grid/);
     expect(foundationIndex).toMatch(/Stack/);
     expect(foundationIndex).toMatch(/Surface/);
+    expect(foundationIndex).not.toMatch(/@ankhorage\/surface/);
     expect(foundationIndex).not.toMatch(/Heading/);
     expect(foundationIndex).not.toMatch(/Text/);
     expect(foundationIndex).not.toMatch(/ThemeProvider/);

package/src/foundation/index.ts

@@ -1,25 +1,20 @@
-export type {
-  BoxProps,
-  CenterProps,
-  ContainerProps,
-  DividerProps,
-  GridProps,
-  InlineProps,
-  ShowProps,
-  SpacerProps,
-  StackProps,
-  SurfaceProps,
-  SurfaceVariant,
-} from '@ankhorage/surface';
-export {
-  Box,
-  Center,
-  Container,
-  Divider,
-  Grid,
-  Inline,
-  Show,
-  Spacer,
-  Stack,
-  Surface,
-} from '@ankhorage/surface';
+export type { BoxProps } from './Box';
+export { Box } from './Box';
+export type { CenterProps } from './Center';
+export { Center } from './Center';
+export type { ContainerProps } from './Container';
+export { Container } from './Container';
+export type { DividerProps } from './Divider';
+export { Divider } from './Divider';
+export type { GridProps } from './Grid';
+export { Grid } from './Grid';
+export type { InlineProps } from './Inline';
+export { Inline } from './Inline';
+export type { ShowProps } from './Show';
+export { Show } from './Show';
+export type { SpacerProps } from './Spacer';
+export { Spacer } from './Spacer';
+export type { StackProps } from './Stack';
+export { Stack } from './Stack';
+export type { SurfaceProps, SurfaceVariant } from './Surface';
+export { Surface } from './Surface';

package/src/internal/color/index.ts

@@ -0,0 +1,2 @@
+export { parseHexToOklch } from './oklch';
+export { resolveModePrimaryColor } from './primary';

package/src/internal/color/oklch.ts

@@ -0,0 +1,69 @@
+import { converter, formatHex, parse, toGamut } from 'culori';
+
+import type { ZoraHexColor } from '../../theme/types';
+import type { ZoraOklchColor } from './types';
+
+const toOklch = converter('oklch');
+const gamutMapToSrgb = toGamut('rgb', 'oklch');
+
+function normalizeHueDegrees(hue: number): number {
+  const normalized = ((hue % 360) + 360) % 360;
+  return normalized;
+}
+
+function isSixDigitHexColor(value: string): value is ZoraHexColor {
+  return /^#[0-9a-fA-F]{6}$/.test(value);
+}
+
+export function parseHexToOklch(hex: ZoraHexColor): ZoraOklchColor {
+  if (!isSixDigitHexColor(hex)) {
+    throw new Error(`Expected a 6-digit hex color like '#0f766e', got '${String(hex)}'.`);
+  }
+
+  const parsed = parse(hex);
+  if (!parsed) {
+    throw new Error(`Unable to parse hex color '${String(hex)}'.`);
+  }
+
+  const oklch = toOklch(parsed);
+  if (typeof oklch.l !== 'number' || typeof oklch.c !== 'number') {
+    throw new Error(`Unable to convert hex color '${String(hex)}' to OKLCH.`);
+  }
+
+  return {
+    l: oklch.l,
+    c: oklch.c,
+    h: normalizeHueDegrees(typeof oklch.h === 'number' ? oklch.h : 0),
+  };
+}
+
+export function formatOklchAsHex(color: ZoraOklchColor): ZoraHexColor {
+  const mapped = gamutMapToSrgb({ mode: 'oklch', l: color.l, c: color.c, h: color.h });
+  const hex = formatHex(mapped);
+
+  if (!hex || !isSixDigitHexColor(hex)) {
+    throw new Error('Unable to format OKLCH color as a 6-digit hex value.');
+  }
+
+  const normalized = hex.toLowerCase();
+  if (!isSixDigitHexColor(normalized)) {
+    throw new Error('Unable to format OKLCH color as a 6-digit hex value.');
+  }
+
+  return normalized;
+}
+
+export function clampOklchToGamut(color: ZoraOklchColor): ZoraOklchColor {
+  const mapped = gamutMapToSrgb({ mode: 'oklch', l: color.l, c: color.c, h: color.h });
+  const clamped = toOklch(mapped);
+
+  if (typeof clamped.l !== 'number' || typeof clamped.c !== 'number') {
+    throw new Error('Unable to clamp OKLCH color to sRGB gamut.');
+  }
+
+  return {
+    l: clamped.l,
+    c: clamped.c,
+    h: normalizeHueDegrees(typeof clamped.h === 'number' ? clamped.h : 0),
+  };
+}

package/src/internal/color/primary.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from 'bun:test';
+
+import type { ZoraHexColor } from '../../theme/types';
+import { parseHexToOklch } from './oklch';
+import { resolveModePrimaryColor } from './primary';
+
+function isSixDigitHexColor(value: string): value is ZoraHexColor {
+  return /^#[0-9a-f]{6}$/.test(value);
+}
+
+function hueDeltaDegrees(a: number, b: number): number {
+  const raw = Math.abs(a - b) % 360;
+  return Math.min(raw, 360 - raw);
+}
+
+describe('resolveModePrimaryColor', () => {
+  test('returns valid hex for light and dark mode', () => {
+    const seed: ZoraHexColor = '#0f766e';
+
+    const light = resolveModePrimaryColor(seed, 'light');
+    const dark = resolveModePrimaryColor(seed, 'dark');
+
+    expect(isSixDigitHexColor(light)).toBe(true);
+    expect(isSixDigitHexColor(dark)).toBe(true);
+  });
+
+  test('derives different colors for light vs dark for a typical saturated seed', () => {
+    const seed: ZoraHexColor = '#0f766e';
+
+    const light = resolveModePrimaryColor(seed, 'light');
+    const dark = resolveModePrimaryColor(seed, 'dark');
+
+    expect(light).not.toBe(dark);
+  });
+
+  test('dark derived primary has higher OKLCH lightness than the light derived primary', () => {
+    const seed: ZoraHexColor = '#0f766e';
+
+    const light = resolveModePrimaryColor(seed, 'light');
+    const dark = resolveModePrimaryColor(seed, 'dark');
+
+    const lightOklch = parseHexToOklch(light);
+    const darkOklch = parseHexToOklch(dark);
+
+    expect(darkOklch.l).toBeGreaterThan(lightOklch.l);
+  });
+
+  test('preserves hue approximately for a non-neutral seed', () => {
+    const seed: ZoraHexColor = '#0f766e';
+    const seedOklch = parseHexToOklch(seed);
+
+    const light = resolveModePrimaryColor(seed, 'light');
+    const dark = resolveModePrimaryColor(seed, 'dark');
+
+    const lightOklch = parseHexToOklch(light);
+    const darkOklch = parseHexToOklch(dark);
+
+    expect(hueDeltaDegrees(seedOklch.h, lightOklch.h)).toBeLessThan(20);
+    expect(hueDeltaDegrees(seedOklch.h, darkOklch.h)).toBeLessThan(20);
+  });
+
+  test('bounds chroma', () => {
+    const seed: ZoraHexColor = '#ff00ff';
+
+    const light = resolveModePrimaryColor(seed, 'light');
+    const dark = resolveModePrimaryColor(seed, 'dark');
+
+    const lightOklch = parseHexToOklch(light);
+    const darkOklch = parseHexToOklch(dark);
+
+    expect(lightOklch.c).toBeLessThanOrEqual(0.18 + 0.01);
+    expect(darkOklch.c).toBeLessThanOrEqual(0.2 + 0.01);
+  });
+
+  test('handles low-chroma colors without crashing', () => {
+    const seed: ZoraHexColor = '#808080';
+
+    const light = resolveModePrimaryColor(seed, 'light');
+    const dark = resolveModePrimaryColor(seed, 'dark');
+
+    expect(isSixDigitHexColor(light)).toBe(true);
+    expect(isSixDigitHexColor(dark)).toBe(true);
+  });
+
+  test('throws on invalid hex in test/development', () => {
+    const invalid: ZoraHexColor = '#nope';
+
+    expect(() => resolveModePrimaryColor(invalid, 'light')).toThrow();
+  });
+
+  test('falls back in production when input is invalid', () => {
+    const invalid: ZoraHexColor = '#nope';
+
+    const originalEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'production';
+
+    try {
+      const resolved = resolveModePrimaryColor(invalid, 'light');
+      expect(resolved).not.toBe('#0f766e');
+      expect(resolved).toBe(resolveModePrimaryColor('#0f766e', 'light'));
+    } finally {
+      process.env.NODE_ENV = originalEnv;
+    }
+  });
+});